This commit was manufactured by cvs2svn to create tag 'SVN'.

svn path=/tags/SVN/; revision=12413

freeldr/COPYING

@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                          675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    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.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

freeldr/FREELDR.INI

@@ -0,0 +1,158 @@
+; FreeLoader by Brian Palmer
+; FREELDR.INI - FreeLoader Initialization file
+;
+; Each line must be less than 1024 characters long
+; and must be either a section heading (i.e. [section_name])
+; or a setting (i.e. name=value) or a blank line.
+; Comments start with a ';' character.
+
+; Background colors can be any one of the following:
+; Black
+; Blue
+; Green
+; Cyan
+; Red
+; Magenta
+; Brown
+; Gray
+
+; Text colors can be any one of the background
+; colors and any of the following:
+; DarkGray
+; LightBlue
+; LightGreen
+; LightCyan
+; LightRed
+; LightMagenta
+; Yellow
+; White
+
+; [FREELOADER] Section Commands:
+;
+; MessageBox		- displays the specified text in a message box upon bootup
+; MessageLine		- adds a new line of text to a message box (must come before MessageBox command)
+; TitleText		- text that is displayed in the title box
+; StatusBarColor	- color of status bar's background
+; StatusBarTextColor	- color of status bar's text
+; BackdropTextColor	- color of the backdrop's fill
+; BackdropColor		- color of the backdrop's background
+; BackdropFillStyle	- backdrop fill style - can be Light, Medium, or Dark
+; TitleBoxTextColor	- title box text color
+; TitleBoxColor		- title box background color
+; MessageBoxTextColor	- message box text color
+; MessageBoxColor	- message box background color
+; MenuTextColor		- menu text color
+; MenuColor		- menu color
+; TextColor		- normal text color
+; SelectedTextColor	- selected text color
+; SelectedColor		- selected text background color
+; TimeOut		- sets the timeout (in seconds) before the first OS listed gets booted automagically
+
+; [OS-General] Section Commands:
+;
+; BootType		- sets the boot type: ReactOS, Linux, BootSector, Partition, Drive
+; BootDrive		- sets the boot drive: 0 - first floppy, 1 - second floppy, 0x80 - first hard disk, 0x81 - second hard disk
+; BootPartition		- sets the boot partition
+; DriveMap		- maps a BIOS drive number to another (i.e. DriveMap=hd1,hd0 maps harddisk1 to harddisk0 or DriveMap=fd1,fd0)
+
+; [BootSector OSType] Section Commands:
+;
+; BootSector		- sets the filename of the bootsector to be loaded
+
+; [ReactOS OSType] Section Commands:
+;
+; SystemPath	- sets the system root path (must be a valid ARC - Path):
+;			multi(0)disk(0)rdisk(0)partition(1)\reactos
+;			multi(0)disk(0)fdisk(0)
+; Options		- sets the command line options for the kernel being booted
+; Kernel		- sets the kernel filename (default: ntoskrnl.exe)
+; Hal			- sets the HAL filename (default: hal.dll)
+
+
+[FREELOADER]
+MessageBox=Welcome to FreeLoader!\nCopyright (c) 2003 by Brian Palmer <brianp@sginet.com>\n\nThis is a sample FreeLoader configuration file.\nEdit FREELDR.INI to change the boot settings.
+DefaultOS=ReactOSHD
+TimeOut=10
+
+; DisplayMode can be:
+; NORMAL_VGA for 80x25
+; EXTENDED_VGA for 80x50 on VGA 80x43 on EGA
+; 0x501C for 80x28
+; 0x501E for 80x30
+; 0x5022 for 80x34
+; 0x502B for 80x43
+; 0x503C for 80x60
+[Display]
+DisplayMode=NORMAL_VGA
+TitleText=Brian<61>s Custom FreeLoader Boot Disk 
+StatusBarColor=Cyan
+StatusBarTextColor=Black
+BackdropTextColor=White
+BackdropColor=Blue
+BackdropFillStyle=Medium
+TitleBoxTextColor=White
+TitleBoxColor=Red
+MessageBoxTextColor=White
+MessageBoxColor=Blue
+MenuTextColor=White
+MenuColor=Blue
+TextColor=Yellow
+SelectedTextColor=Black
+SelectedColor=Gray
+SpecialEffects=Yes
+
+[Operating Systems]
+ReactOSHD="ReactOS (HardDrive)"
+ReactOSFloppy="ReactOS (Floppy)"
+Linux="Debian Linux"
+Floppy="3 1/2 Floppy (A:)"
+MSWinders="Microsoft Windows (C:)"
+DriveD="Drive D:"
+
+; Load ReactOS from harddisk (drive C:)
+[ReactOSHD]
+BootType=ReactOS
+SystemPath=multi(0)disk(0)rdisk(0)partition(1)\reactos
+Options=/DEBUGPORT=SCREEN
+Kernel=\REACTOS\SYSTEM32\NTOSKRNL.EXE
+Hal=\REACTOS\SYSTEM32\HAL.DLL
+
+; Load ReactOS from floppy (drive A:)
+[ReactOSFloppy]
+BootType=ReactOS
+SystemPath=multi(0)disk(0)fdisk(0)
+Options=/DEBUGPORT=SCREEN
+Kernel=\reactos\NTOSKRNL.EXE
+Hal=\reactos\HAL.DLL
+
+;[ReactOS (Debug)]
+;BootType=ReactOS
+;SystemPath=multi(0)disk(0)rdisk(0)partition(1)\reactos
+;Options=/DEBUG /DEBUGPORT=COM1 /BAUDRATE=19200
+;Kernel=\NTOSKRNL.EXE
+;Hal=\HAL.DLL
+
+[Linux]
+BootType=Linux
+BootDrive=hd1
+BootPartition=1
+Kernel=/vmlinuz
+Initrd=/initrd.img
+CommandLine="root=/dev/sdb1"
+
+[Floppy]
+BootType=Drive
+BootDrive=fd0
+
+[MSWinders]
+BootType=Partition
+BootDrive=hd0
+BootPartition=1
+;DriveMap=hd1,hd0
+;DriveMap=hd2,hd0
+;DriveMap=hd3,hd0
+
+[DriveD]
+BootType=Partition
+BootDrive=hd1
+BootPartition=1

freeldr/Makefile

@@ -0,0 +1,45 @@
+#
+#  FreeLoader
+#  Copyright (C) 1999, 2000, 2001  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.
+#
+
+# Windows is default host environment
+ifeq ($(HOST),)
+HOST = mingw32-windows
+endif
+
+include rules.mak
+
+all:
+	$(MAKE) -C tools
+	$(MAKE) -C bootsect
+	$(MAKE) -C freeldr
+	$(MAKE) -C install
+	$(MAKE) -C fdebug
+
+freeldr:
+	$(MAKE) -C freeldr
+.PHONY : freeldr
+
+clean:
+	$(MAKE) -C bootsect clean
+	$(MAKE) -C freeldr clean
+	$(MAKE) -C install clean
+	$(MAKE) -C fdebug clean
+	$(MAKE) -C tools clean
+
+.PHONY : clean

freeldr/bootsect/.cvsignore

@@ -0,0 +1,3 @@
+*.exe
+*.bin
+*.h

freeldr/bootsect/Makefile

@@ -0,0 +1,76 @@
+#
+#  FreeLoader
+#  Copyright (C) 1999, 2000, 2001  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.
+#
+
+BOOTCD_DIR	= ../../bootcd
+
+.PHONY : clean bootcd
+
+all: $(BIN2C) dosmbr.bin fat.bin fat32.bin isoboot.bin ext2.bin
+
+
+$(BIN2C) :
+	@$(MAKE) --no-print-directory -C $(TOOLSDIR)
+
+dosmbr.bin : dosmbr.asm
+	@echo ===================================================== Assembling dosmbr
+	@$(NASM_CMD) $(NFLAGS) -o dosmbr.bin -f bin dosmbr.asm
+
+fat.bin : fat.asm $(BIN2C)
+	@echo ===================================================== Assembling fat
+	@$(NASM_CMD) $(NFLAGS) -o fat.bin -f bin fat.asm
+	@$(BIN2C) fat.bin fat.h fat_data
+
+
+fat32.bin : fat32.asm $(BIN2C)
+	@echo ===================================================== Assembling fat32
+	@$(NASM_CMD) $(NFLAGS) -o fat32.bin -f bin fat32.asm
+	@$(BIN2C) fat32.bin fat32.h fat32_data
+
+isoboot.bin : isoboot.asm
+	@echo ===================================================== Assembling isoboot
+	@$(NASM_CMD) $(NFLAGS) -o isoboot.bin -f bin isoboot.asm
+
+ext2.bin : ext2.asm
+	@echo ===================================================== Assembling ext2
+	@$(NASM_CMD) $(NFLAGS) -o ext2.bin -f bin ext2.asm
+	@$(BIN2C) ext2.bin ext2.h ext2_data
+
+
+.PHONY : bootcd
+bootcd: bootcd_dirs isoboot.bin
+	$(CP) isoboot.bin $(BOOTCD_DIR)
+	$(CP) dosmbr.bin $(BOOTCD_DIR)/disk/loader
+	$(CP) ext2.bin $(BOOTCD_DIR)/disk/loader
+	$(CP) fat.bin $(BOOTCD_DIR)/disk/loader
+	$(CP) fat32.bin $(BOOTCD_DIR)/disk/loader
+	$(CP) isoboot.bin $(BOOTCD_DIR)/disk/loader
+
+.PHONY : bootcd_dirs
+bootcd_dirs:
+	$(MKDIR) $(BOOTCD_DIR)
+	$(MKDIR) $(BOOTCD_DIR)/disk
+	$(MKDIR) $(BOOTCD_DIR)/disk/reactos
+	$(MKDIR) $(BOOTCD_DIR)/disk/install
+	$(MKDIR) $(BOOTCD_DIR)/disk/bootdisk
+	$(MKDIR) $(BOOTCD_DIR)/disk/loader
+
+clean:
+	@-$(RM) *.bin
+	@-$(RM) *.h
+	@echo Clean ALL done.

freeldr/bootsect/dosmbr.asm

@@ -0,0 +1,179 @@
+;
+; normal DOS boot sector
+;
+; Ported to nasm from FreeDOS fdisk 1.2.0 by:
+; Casper Hornstrup (chorns@users.sourceforge.net)
+;
+
+                align 2, db 0
+
+  global  _bootnormal_code
+_bootnormal_code:
+
+;-----------------------------------------------------------------------
+;   ENTRY (copied from freedos bootsector)
+;
+; IN: DL = boot drive
+;OUT: DL = boot drive
+;
+;-----------------------------------------------------------------------
+
+real_start:     cli
+                cld
+                xor     ax, ax
+                mov     ss, ax          ; initialize stack
+                mov     ds, ax
+                mov     bp, 0x7c00
+                lea     sp, [bp-0x20]
+                sti
+                
+                mov     ax, 0x1FE0
+                mov     es, ax
+                mov     si, bp
+                mov     di, bp
+                mov     cx, 0x0100
+                rep     movsw
+
+                jmp     word 0x1FE0:0x7c00+ cont-real_start
+
+cont:           mov     ds, ax
+                mov     ss, ax
+                xor     ax,ax
+                mov     es,ax
+
+
+										 ; search for active partition
+                lea di, [bp+0x1be] ; start of partition table
+test_next_for_active:				
+                test byte [di],0x80
+                jne  active_partition_found
+                add  di,0x10                    ; next table
+                cmp  di, 07c00h+0x1fe; scanned beyond end of table ??
+                jb  test_next_for_active
+
+;*****************************************************************				
+                call print
+                db 'no active partition found',0
+				
+WAIT_FOR_REBOOT:
+                jmp $
+
+
+;*****************************************************************
+trouble_reading_drive:
+                call print
+                db 'read error while reading drive',0
+                jmp WAIT_FOR_REBOOT
+
+;*****************************************************************
+
+invalid_partition_code:
+                call print
+                db 'partition signature != 55AA',0
+			
+                jmp WAIT_FOR_REBOOT
+
+								
+;*****************************************************************
+
+active_partition_found:
+;				call print
+;				db 'loading active partition',0
+
+                call read_boot_sector                    
+				
+                jc  trouble_reading_drive
+			
+                cmp word [es:0x7c00+0x1fe],0xaa55
+                jne invalid_partition_code
+			
+                jmp word 0x0:0x7c00             ; and jump to boot sector code
+
+
+;*****************************
+; read_boot_sector				
+;
+; IN: DI--> partition info
+;OUT:CARRY
+;*****************************
+
+read_boot_sector:
+                ;  /* check for LBA support */
+		mov bx,0x55aa		
+		mov ah,0x41
+		int 0x13
+
+		jc  StandardBios    ;  if (regs.b.x != 0xaa55 || (regs.flags & 0x01))
+		cmp bx,0xaa55       ;    goto StandardBios;
+		jne StandardBios
+
+                              ;  /* if DAP cannot be used, don't use LBA */
+                              ;  if ((regs.c.x & 1) == 0)
+                              ;    goto StandardBios;
+ 		test cl,1
+ 		jz StandardBios
+ 
+        jmp short LBABios
+
+
+_bios_LBA_address_packet:
+	db 0x10
+	db 0
+	db 4				; read four sectors - why not
+	db 0
+	dw 0x7c00			; fixed boot address for DOS sector
+	dw 0x0000	
+_bios_LBA_low  dw 0
+_bios_LBA_high dw 0
+	dw 0,0
+
+
+LBABios:
+						; copy start address of partition to DAP
+	mov ax,[di+8]
+	mov [0x7c00+ (_bios_LBA_low-real_start)],ax
+	mov ax,[di+8+2]
+	mov [0x7c00+ (_bios_LBA_high-real_start)],ax
+
+    mov ax,0x4200		;  regs.a.x = LBA_READ;
+    mov si,0x7c00+ (_bios_LBA_address_packet-real_start); regs.si = FP_OFF(&dap);
+
+	int 0x13
+	ret
+
+;*****************************************************************
+; read disk, using standard BIOS
+;
+StandardBios:
+    mov ax,0x0204			;  regs.a.x = 0x0201;
+    mov bx,0x7c00			;  regs.b.x = FP_OFF(buffer);
+	mov cx,[di+2]			;      regs.c.x =
+          					; ((chs.Cylinder & 0xff) << 8) + ((chs.Cylinder & 0x300) >> 2) +
+          					; chs.Sector;
+          					; that was easy ;-)
+    mov dh,[di+1]			;  regs.d.b.h = chs.Head;
+    						;  regs.es = FP_SEG(buffer);
+	int 0x13
+	ret	
+	
+
+
+;****** PRINT
+; prints text after call to this function.
+
+print_1char:        
+                xor   bx, bx                   ; video page 0
+                mov   ah, 0x0E                 ; else print it
+                int   0x10                     ; via TTY mode
+print:          pop   si                       ; this is the first character
+print1:         lodsb                          ; get token
+                push  si                       ; stack up potential return address
+                cmp   al, 0                    ; end of string?
+                jne   print_1char              ; until done
+                ret                            ; and jump to it
+
+
+
+		times	0x1fe-$+$$ db 0
+		db 0x55,0xaa
+		

freeldr/bootsect/ext2.asm

@@ -0,0 +1,663 @@
+; EXT2.ASM
+; EXT2 Boot Sector
+; Copyright (c) 2002, 2003 Brian Palmer
+
+; [bp-0x04] Here we will store the number of sectors per track
+; [bp-0x08] Here we will store the number of heads
+; [bp-0x0c] Here we will store the size of the disk as the BIOS reports in CHS form
+; [bp-0x10] Here we will store the number of LBA sectors read
+
+SECTORS_PER_TRACK		equ	0x04
+NUMBER_OF_HEADS			equ	0x08
+BIOS_CHS_DRIVE_SIZE		equ	0x0C
+LBA_SECTORS_READ		equ	0x10
+
+
+EXT2_ROOT_INO			equ 2
+EXT2_S_IFMT				equ	0f0h
+EXT2_S_IFREG			equ 080h
+
+
+org 7c00h
+
+segment .text
+
+bits 16
+
+start:
+        jmp short main
+        nop
+
+BootDrive				db 0x80
+;BootPartition			db 0					; Moved to end of boot sector to have a standard format across all boot sectors
+;SectorsPerTrack		db 63					; Moved to [bp-SECTORS_PER_TRACK]
+;NumberOfHeads			dw 16					; Moved to [bp-NUMBER_OF_HEADS]
+;BiosCHSDriveSize		dd (1024 * 1024 * 63)	; Moved to [bp-BIOS_CHS_DRIVE_SIZE]
+;LBASectorsRead			dd 0					; Moved to [bp-LBA_SECTORS_READ]
+
+Ext2VolumeStartSector	dd 263088				; Start sector of the ext2 volume
+Ext2BlockSize			dd 2					; Block size in sectors
+Ext2BlockSizeInBytes	dd 1024					; Block size in bytes
+Ext2PointersPerBlock	dd 256					; Number of block pointers that can be contained in one block
+Ext2GroupDescPerBlock	dd 32					; Number of group descriptors per block
+Ext2FirstDataBlock		dd 1					; First data block (1 for 1024-byte blocks, 0 for bigger sizes)
+Ext2InodesPerGroup		dd 2048					; Number of inodes per group
+Ext2InodesPerBlock		dd 8					; Number of inodes per block
+
+Ext2ReadEntireFileLoadSegment:
+	dw	0
+Ext2InodeIndirectPointer:
+	dd	0
+Ext2InodeDoubleIndirectPointer:
+	dd	0
+Ext2BlocksLeftToRead:
+	dd	0
+
+main:
+        xor ax,ax               ; Setup segment registers
+        mov ds,ax               ; Make DS correct
+        mov es,ax               ; Make ES correct
+        mov ss,ax				; Make SS correct
+		mov bp,7c00h
+        mov sp,7b00h            ; Setup a stack
+
+
+		cmp BYTE [BYTE bp+BootDrive],BYTE 0xff	; If they have specified a boot drive then use it
+		jne GetDriveParameters
+
+        mov [BYTE bp+BootDrive],dl				; Save the boot drive
+
+
+GetDriveParameters:
+		mov  ah,08h
+		mov  dl,[BYTE bp+BootDrive]					; Get boot drive in dl
+		int  13h									; Request drive parameters from the bios
+		jnc  CalcDriveSize							; If the call succeeded then calculate the drive size
+
+		; If we get here then the call to the BIOS failed
+		; so just set CHS equal to the maximum addressable
+		; size
+		mov  cx,0ffffh
+		mov  dh,cl
+
+CalcDriveSize:
+		; Now that we have the drive geometry
+		; lets calculate the drive size
+		mov  bl,ch								; Put the low 8-bits of the cylinder count into BL
+		mov  bh,cl								; Put the high 2-bits in BH
+		shr  bh,6								; Shift them into position, now BX contains the cylinder count
+		and  cl,3fh								; Mask off cylinder bits from sector count
+		; CL now contains sectors per track and DH contains head count
+		movzx eax,dh							; Move the heads into EAX
+		movzx ebx,bx							; Move the cylinders into EBX
+		movzx ecx,cl							; Move the sectors per track into ECX
+		inc   eax								; Make it one based because the bios returns it zero based
+		mov   [BYTE bp-NUMBER_OF_HEADS],eax		; Save number of heads
+		mov   [BYTE bp-SECTORS_PER_TRACK],ecx	; Save number of sectors per track
+		inc   ebx								; Make the cylinder count one based also
+		mul   ecx								; Multiply heads with the sectors per track, result in edx:eax
+		mul   ebx								; Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
+
+		; We now have the total number of sectors as reported
+		; by the bios in eax, so store it in our variable
+		mov   [BYTE bp-BIOS_CHS_DRIVE_SIZE],eax
+
+
+LoadExtraBootCode:
+		; First we have to load our extra boot code at
+		; sector 1 into memory at [0000:7e00h]
+		;mov  eax,01h
+		xor  eax,eax
+		inc  eax								; Read logical sector 1, EAX now = 1
+		mov  cx,1								; Read one sector
+		mov  bx,7e00h							; Read sector to [0000:7e00h]
+		call ReadSectors
+
+		jmp  LoadRootDirectory
+
+
+
+; Reads ext2 group descriptor into [7000:8000]
+; We read it to this arbitrary location so
+; it will not cross a 64k boundary
+; EAX has group descriptor number to read
+Ext2ReadGroupDesc:
+		shl   eax,5										; Group = (Group * sizeof(GROUP_DESCRIPTOR) /* 32 */)
+		xor   edx,edx
+		div   DWORD [BYTE bp+Ext2GroupDescPerBlock]		; Group = (Group / Ext2GroupDescPerBlock)
+		add   eax,DWORD [BYTE bp+Ext2FirstDataBlock]	; Group = Group + Ext2FirstDataBlock + 1
+		inc   eax										; EAX now has the group descriptor block number
+														; EDX now has the group descriptor offset in the block
+
+		; Adjust the read offset so that the
+		; group descriptor is read to 7000:8000
+		mov   ebx,78000h
+		sub   ebx,edx
+		shr   ebx,4
+		mov   es,bx
+		xor   bx,bx
+
+
+		; Everything is now setup to call Ext2ReadBlock
+		; Instead of using the call instruction we will
+		; just put Ext2ReadBlock right after this routine
+
+; Reads ext2 block into [ES:BX]
+; EAX has logical block number to read
+Ext2ReadBlock:
+		mov   ecx,DWORD [BYTE bp+Ext2BlockSize]
+		mul   ecx
+		jmp   ReadSectors
+
+; Reads ext2 inode into [6000:8000]
+; We read it to this arbitrary location so
+; it will not cross a 64k boundary
+; EAX has inode number to read
+Ext2ReadInode:
+		dec   eax										; Inode = Inode - 1
+		xor   edx,edx
+		div   DWORD [BYTE bp+Ext2InodesPerGroup]		; Inode = (Inode / Ext2InodesPerGroup)
+		mov   ebx,eax									; EBX now has the inode group number
+		mov   eax,edx
+		xor   edx,edx
+		div   DWORD [BYTE bp+Ext2InodesPerBlock]		; Inode = (Inode / Ext2InodesPerBlock)
+		shl   edx,7										; FIXME: InodeOffset *= 128 (make the array index a byte offset)
+														; EAX now has the inode offset block number from inode table
+														; EDX now has the inode offset in the block
+
+		; Save the inode values and put the group
+		; descriptor number in EAX and read it in
+		push  edx
+		push  eax
+		mov   eax,ebx
+		call  Ext2ReadGroupDesc
+
+		; Group descriptor has been read, now
+		; grab the inode table block number from it
+		push  WORD 7000h
+		pop   es
+		mov   di,8008h
+		pop   eax										; Restore inode offset block number from stack
+		add   eax,DWORD [es:di]							; Add the inode table start block
+
+		; Adjust the read offset so that the
+		; inode we want is read to 6000:8000
+		pop   edx										; Restore inode offset in the block from stack
+		mov   ebx,68000h
+		sub   ebx,edx
+		shr   ebx,4
+		mov   es,bx
+		xor   bx,bx
+
+		call  Ext2ReadBlock
+		ret
+
+
+; Reads logical sectors into [ES:BX]
+; EAX has logical sector number to read
+; CX has number of sectors to read
+ReadSectors:
+        add  eax,DWORD [BYTE bp+Ext2VolumeStartSector]	; Add the start of the volume
+		cmp  eax,DWORD [BYTE bp-BIOS_CHS_DRIVE_SIZE]	; Check if they are reading a sector outside CHS range
+		jae  ReadSectorsLBA						; Yes - go to the LBA routine
+												; If at all possible we want to use LBA routines because
+												; They are optimized to read more than 1 sector per read
+
+		pushad									; Save logical sector number & sector count
+
+CheckInt13hExtensions:							; Now check if this computer supports extended reads
+		mov  ah,0x41							; AH = 41h
+		mov  bx,0x55aa							; BX = 55AAh
+		mov  dl,[BYTE bp+BootDrive]				; DL = drive (80h-FFh)
+		int  13h								; IBM/MS INT 13 Extensions - INSTALLATION CHECK
+		jc   ReadSectorsCHS						; CF set on error (extensions not supported)
+		cmp  bx,0xaa55							; BX = AA55h if installed
+		jne  ReadSectorsCHS
+		test cl,1								; CX = API subset support bitmap
+		jz   ReadSectorsCHS						; Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
+
+		popad									; Restore sector count & logical sector number
+
+ReadSectorsLBA:
+		pushad									; Save logical sector number & sector count
+
+		cmp  cx,byte 64							; Since the LBA calls only support 0x7F sectors at a time we will limit ourselves to 64
+		jbe  ReadSectorsSetupDiskAddressPacket	; If we are reading less than 65 sectors then just do the read
+		mov  cx,64								; Otherwise read only 64 sectors on this loop iteration
+
+ReadSectorsSetupDiskAddressPacket:
+		mov  [BYTE bp-LBA_SECTORS_READ],cx
+		mov  WORD [BYTE bp-LBA_SECTORS_READ+2],0
+		o32 push byte 0
+		push eax								; Put 64-bit logical block address on stack
+		push es									; Put transfer segment on stack
+		push bx									; Put transfer offset on stack
+		push cx									; Set transfer count
+		push byte 0x10							; Set size of packet to 10h
+		mov  si,sp								; Setup disk address packet on stack
+
+
+        mov  dl,[BYTE bp+BootDrive]				; Drive number
+		mov  ah,42h								; Int 13h, AH = 42h - Extended Read
+		int  13h								; Call BIOS
+		jc   PrintDiskError						; If the read failed then abort
+
+		add  sp,byte 0x10						; Remove disk address packet from stack
+
+		popad									; Restore sector count & logical sector number
+
+		push bx
+		mov  ebx,DWORD [BYTE bp-LBA_SECTORS_READ]
+        add  eax,ebx							; Increment sector to read
+		shl  ebx,5
+        mov  dx,es
+        add  dx,bx								; Setup read buffer for next sector
+        mov  es,dx
+		pop  bx
+
+		sub  cx,[BYTE bp-LBA_SECTORS_READ]
+        jnz  ReadSectorsLBA						; Read next sector
+
+        ret
+
+
+; Reads logical sectors into [ES:BX]
+; EAX has logical sector number to read
+; CX has number of sectors to read
+ReadSectorsCHS:
+		popad										; Get logical sector number & sector count off stack
+
+ReadSectorsCHSLoop:
+        pushad
+        xor   edx,edx
+		mov   ecx,DWORD [BYTE bp-SECTORS_PER_TRACK]
+		div   ecx									; Divide logical by SectorsPerTrack
+        inc   dl									; Sectors numbering starts at 1 not 0
+		mov   cl,dl									; Sector in CL
+		mov   edx,eax
+		shr   edx,16
+        div   WORD [BYTE bp-NUMBER_OF_HEADS]		; Divide logical by number of heads
+        mov   dh,dl									; Head in DH
+        mov   dl,[BYTE bp+BootDrive]				; Drive number in DL
+        mov   ch,al									; Cylinder in CX
+        ror   ah,2									; Low 8 bits of cylinder in CH, high 2 bits
+                									;  in CL shifted to bits 6 & 7
+        or    cl,ah									; Or with sector number
+        mov   ax,0201h
+        int   13h    ; DISK - READ SECTORS INTO MEMORY
+                     ; AL = number of sectors to read, CH = track, CL = sector
+                     ; DH = head, DL    = drive, ES:BX -> buffer to fill
+                     ; Return: CF set on error, AH =    status (see AH=01h), AL    = number of sectors read
+
+        jc    PrintDiskError						; If the read failed then abort
+
+        popad
+
+        inc   eax									; Increment Sector to Read
+
+        mov   dx,es
+        add   dx,byte 20h							; Increment read buffer for next sector
+        mov   es,dx
+
+        loop  ReadSectorsCHSLoop					; Read next sector
+
+        ret   
+
+
+
+
+; Displays a disk error message
+; And reboots
+PrintDiskError:
+        mov  si,msgDiskError			; Bad boot disk message
+        call PutChars					; Display it
+
+Reboot:
+        mov  si,msgAnyKey				; Press any key message
+        call PutChars					; Display it
+        xor ax,ax       
+        int 16h							; Wait for a keypress
+        int 19h							; Reboot
+
+PutChars:
+        lodsb
+        or al,al
+        jz short Done
+		call PutCharsCallBios
+        jmp short PutChars
+PutCharsCallBios:
+        mov ah,0eh
+        mov bx,07h
+        int 10h
+		retn
+Done:
+		mov al,0dh
+		call PutCharsCallBios
+		mov al,0ah
+		call PutCharsCallBios
+        retn
+
+
+
+msgDiskError		db 'Disk error',0
+; Sorry, need the space...
+;msgAnyKey			db 'Press any key to restart',0
+msgAnyKey			db 'Press any key',0
+
+        times 509-($-$$) db 0   ; Pad to 509 bytes
+
+BootPartition			db 0
+
+        dw 0aa55h       ; BootSector signature
+        
+
+; End of bootsector
+;
+; Now starts the extra boot code that we will store
+; at sector 1 on a EXT2 volume
+
+
+
+LoadRootDirectory:
+
+		mov  eax,EXT2_ROOT_INO			; Put the root directory inode number in EAX
+		call Ext2ReadInode				; Read in the inode
+
+		; Point ES:DI to the inode structure at 6000:8000
+		push WORD 6000h
+		pop  es
+		mov  di,8000h
+		push di
+		push es							; Save these for later
+
+		; Get root directory size from inode structure
+		mov  eax,DWORD [es:di+4]
+		push eax
+
+		; Now that the inode has been read in load
+		; the root directory file data to 0000:8000
+		call Ext2ReadEntireFile
+
+		; Since the root directory was loaded to 0000:8000
+		; then add 8000h to the root directory's size
+		pop  eax
+		mov  edx,8000h					; Set EDX to the current offset in the root directory
+		add  eax,edx					; Initially add 8000h to the size of the root directory
+
+SearchRootDirectory:
+		push edx						; Save current offset in root directory
+		push eax						; Save the size of the root directory
+
+		; Now we have to convert the current offset
+		; in the root directory to a SEGMENT:OFFSET pair
+		mov  eax,edx
+		xor  edx,edx
+		mov  ecx,16
+		div  ecx						; Now AX:DX has segment & offset
+		mov  es,ax
+		mov  di,dx
+		push di							; Save the start of the directory entry
+		add  di,byte 8					; Add the offset to the filename
+		mov  si,filename
+		mov  cl,11
+		rep  cmpsb						; Compare the file names
+		pop  di
+		pop  eax
+		pop  edx
+		jz   FoundFile
+
+		; Nope, didn't find it in this entry, keep looking
+		movzx ecx,WORD [es:di+4]
+		add   edx,ecx
+
+		; Check to see if we have reached the
+		; end of the root directory
+		cmp  edx,eax
+		jb   SearchRootDirectory
+		jmp  PrintFileNotFound
+
+FoundFile:
+		mov  eax,[es:di]				; Get inode number from directory entry
+		call Ext2ReadInode				; Read in the inode
+
+		; Point ES:DI to the inode structure at 6000:8000
+		pop  es
+		pop  di							; These were saved earlier
+
+		mov  cx,[es:di]					; Get the file mode so we can make sure it's a regular file
+		and  ch,EXT2_S_IFMT				; Mask off everything but the file type
+		cmp  ch,EXT2_S_IFREG			; Make sure it's a regular file
+		je   LoadFreeLoader
+		jmp  PrintRegFileError
+
+LoadFreeLoader:
+        mov  si,msgLoading				; "Loading FreeLoader..." message
+        call PutChars					; Display it
+
+		call Ext2ReadEntireFile			; Read freeldr.sys to 0000:8000
+
+        mov  dl,[BYTE bp+BootDrive]
+		mov  dh,[BYTE bp+BootPartition]
+        push byte 0						; We loaded at 0000:8000
+        push WORD 8000h					; We will do a far return to 0000:8000h
+        retf							; Transfer control to FreeLoader
+
+
+
+
+
+; Reads ext2 file data into [0000:8000]
+; This function assumes that the file's
+; inode has been read in to 6000:8000 *and*
+; ES:DI points to 6000:8000
+; This will load all the blocks up to
+; and including the double-indirect pointers.
+; This should be sufficient because it
+; allows for ~64MB which is much bigger
+; than we need for a boot loader.
+Ext2ReadEntireFile:
+
+		; Reset the load segment
+		mov  WORD [BYTE bp+Ext2ReadEntireFileLoadSegment],800h
+
+		; Now we must calculate how
+		; many blocks to read in
+		; We will do this by rounding the
+		; file size up to the next block
+		; size and then dividing by the block size
+		mov  eax,DWORD [BYTE bp+Ext2BlockSizeInBytes]		; Get the block size in bytes
+		push eax
+		dec  eax											; Ext2BlockSizeInBytes -= 1
+		add  eax,DWORD [es:di+4]							; Add the file size
+		xor  edx,edx
+		pop  ecx											; Divide by the block size in bytes
+		div  ecx											; EAX now contains the number of blocks to load
+		push eax
+
+		; Make sure the file size isn't zero
+		cmp  eax,byte 0
+		jnz  Ext2ReadEntireFile2
+		jmp  PrintFileSizeError
+
+Ext2ReadEntireFile2:
+		; Save the indirect & double indirect pointers
+		mov  edx,DWORD [es:di+0x58]							; Get indirect pointer
+		mov  [BYTE bp+Ext2InodeIndirectPointer],edx			; Save indirect pointer
+		mov  edx,DWORD [es:di+0x5c]							; Get double indirect pointer
+		mov  [BYTE bp+Ext2InodeDoubleIndirectPointer],edx	; Save double indirect pointer
+
+		; Now copy the direct pointers to 7000:0000
+		; so that we can call Ext2ReadDirectBlocks
+		push ds												; Save DS
+		push es
+		push WORD 7000h
+		pop  es
+		pop  ds
+		mov  si,8028h
+		xor  di,di											; DS:SI = 6000:8028 ES:DI = 7000:0000
+		mov  cx,24											; Moving 24 words of data
+		rep  movsw
+		pop  ds												; Restore DS
+
+		; Now we have all the block pointers in the
+		; right location so read them in
+		pop  eax											; Restore the total number of blocks in this file
+		xor  ecx,ecx										; Set the max count of blocks to read to 12
+		mov  cl,12											; which is the number of direct block pointers in the inode
+		call Ext2ReadDirectBlockList
+
+		; Check to see if we actually have
+		; blocks left to read
+		cmp  eax,byte 0
+		jz   Ext2ReadEntireFileDone
+
+		; Now we have read all the direct blocks in
+		; the inode. So now we have to read the indirect
+		; block and read all it's direct blocks
+		push eax											; Save the total block count
+		mov  eax,DWORD [BYTE bp+Ext2InodeIndirectPointer]	; Get the indirect block pointer
+		push WORD 7000h
+		pop  es
+		xor  bx,bx											; Set the load address to 7000:0000
+		call Ext2ReadBlock									; Read the block
+
+		; Now we have all the block pointers from the
+		; indirect block in the right location so read them in
+		pop  eax											; Restore the total block count
+		mov  ecx,DWORD [BYTE bp+Ext2PointersPerBlock]		; Get the number of block pointers that one block contains
+		call Ext2ReadDirectBlockList
+
+		; Check to see if we actually have
+		; blocks left to read
+		cmp  eax,byte 0
+		jz   Ext2ReadEntireFileDone
+
+		; Now we have read all the direct blocks from
+		; the inode's indirect block pointer. So now
+		; we have to read the double indirect block
+		; and read all it's indirect blocks
+		; (whew, it's a good thing I don't support triple indirect blocks)
+		mov  [BYTE bp+Ext2BlocksLeftToRead],eax				; Save the total block count
+		mov  eax,DWORD [BYTE bp+Ext2InodeDoubleIndirectPointer]	; Get the double indirect block pointer
+		push WORD 7800h
+		pop  es
+		push es												; Save an extra copy of this value on the stack
+		xor  bx,bx											; Set the load address to 7000:8000
+		call Ext2ReadBlock									; Read the block
+
+		pop  es												; Put 7800h into ES (saved on the stack already)
+		xor  di,di
+
+Ext2ReadIndirectBlock:
+		mov  eax,DWORD [es:di]								; Get indirect block pointer
+		add  di,BYTE 4										; Update DI for next array index
+		push es
+		push di
+
+		push WORD 7000h
+		pop  es
+		xor  bx,bx											; Set the load address to 7000:0000
+		call Ext2ReadBlock									; Read the indirect block
+
+		; Now we have all the block pointers from the
+		; indirect block in the right location so read them in
+		mov  eax,DWORD [BYTE bp+Ext2BlocksLeftToRead]		; Restore the total block count
+		mov  ecx,DWORD [BYTE bp+Ext2PointersPerBlock]		; Get the number of block pointers that one block contains
+		call Ext2ReadDirectBlockList
+		mov  [BYTE bp+Ext2BlocksLeftToRead],eax				; Save the total block count
+		pop  di
+		pop  es
+
+		; Check to see if we actually have
+		; blocks left to read
+		cmp  eax,byte 0
+		jnz  Ext2ReadIndirectBlock
+
+Ext2ReadEntireFileDone:
+		ret
+
+; Reads a maximum number of blocks
+; from an array at 7000:0000
+; and updates the total count
+; ECX contains the max number of blocks to read
+; EAX contains the number of blocks left to read
+; On return:
+;  EAX contians the new number of blocks left to read
+Ext2ReadDirectBlockList:
+		cmp  eax,ecx										; Compare it to the maximum number of blocks to read
+		ja   CallExt2ReadDirectBlocks						; If it will take more blocks then just read all of the blocks
+		mov  cx,ax											; Otherwise adjust the block count accordingly
+
+CallExt2ReadDirectBlocks:
+		sub  eax,ecx										; Subtract the number of blocks being read from the total count
+		push eax											; Save the new total count
+		call Ext2ReadDirectBlocks
+		pop  eax											; Restore the total count
+		ret
+
+
+; Reads a specified number of blocks
+; from an array at 7000:0000
+; CX contains the number of blocks to read
+Ext2ReadDirectBlocks:
+
+		push WORD 7000h
+		pop  es
+		xor  di,di											; Set ES:DI = 7000:0000
+
+Ext2ReadDirectBlocksLoop:
+		mov  eax,[es:di]									; Get direct block pointer from array
+		add  di,BYTE 4										; Update DI for next array index
+
+		push cx												; Save number of direct blocks left
+		push es												; Save array segment
+		push di												; Save array offset
+		mov  es,[BYTE bp+Ext2ReadEntireFileLoadSegment]
+		xor  bx,bx											; Setup load address for next read
+
+		call Ext2ReadBlock									; Read the block (this updates ES for the next read)
+
+		mov  [BYTE bp+Ext2ReadEntireFileLoadSegment],es		; Save updated ES
+
+		pop  di												; Restore the array offset
+		pop  es												; Restore the array segment
+		pop  cx												; Restore the number of blocks left
+
+		loop Ext2ReadDirectBlocksLoop
+
+		; At this point all the direct blocks should
+		; be loaded and ES (Ext2ReadEntireFileLoadSegment)
+		; should be ready for the next read.
+		ret
+
+
+
+; Displays a file not found error message
+; And reboots
+PrintFileNotFound:
+        mov  si,msgFreeLdr      ; FreeLdr not found message
+		jmp short DisplayItAndReboot
+
+; Displays a file size is 0 error
+; And reboots
+PrintFileSizeError:
+        mov  si,msgFileSize     ; Error message
+		jmp short DisplayItAndReboot
+
+; Displays a file is not a regular file error
+; And reboots
+PrintRegFileError:
+        mov  si,msgRegFile      ; Error message
+DisplayItAndReboot:
+        call PutChars           ; Display it
+		jmp  Reboot
+
+msgFreeLdr   db 'freeldr.sys not found',0
+msgFileSize  db 'File size is 0',0
+msgRegFile   db 'freeldr.sys isnt a regular file',0
+filename     db 'freeldr.sys'
+msgLoading   db 'Loading FreeLoader...',0
+
+        times 1022-($-$$) db 0   ; Pad to 1022 bytes
+
+        dw 0aa55h       ; BootSector signature

freeldr/bootsect/fat.asm

@@ -0,0 +1,402 @@
+; FAT.ASM
+; FAT12/16 Boot Sector
+; Copyright (c) 1998, 2001, 2002 Brian Palmer
+
+
+
+; This is a FAT12/16 file system boot sector
+; that searches the entire root directory
+; for the file freeldr.sys and loads it into
+; memory.
+;
+; The stack is set to 0000:7BF2 so that the first
+; WORD pushed will be placed at 0000:7BF0
+;
+; The DWORD at 0000:7BFC or BP-04h is the logical
+; sector number of the start of the data area.
+;
+; The DWORD at 0000:7BF8 or BP-08h is the total
+; sector count of the boot drive as reported by
+; the computers bios.
+;
+; The WORD at 0000:7BF6 or BP-0ah is the offset
+; of the ReadSectors function in the boot sector.
+;
+; The WORD at 0000:7BF4 or BP-0ch is the offset
+; of the ReadCluster function in the boot sector.
+;
+; The WORD at 0000:7BF2 or BP-0eh is the offset
+; of the PutChars function in the boot sector.
+;
+; When it locates freeldr.sys on the disk it will
+; load the first sector of the file to 0000:8000
+; With the help of this sector we should be able
+; to load the entire file off the disk, no matter
+; how fragmented it is.
+;
+; We load the entire FAT table into memory at
+; 7000:0000. This improves the speed of floppy disk
+; boots dramatically.
+
+
+BootSectorStackTop		equ		0x7bf2
+DataAreaStartHigh		equ		0x2
+DataAreaStartLow		equ		0x4
+BiosCHSDriveSizeHigh	equ		0x6
+BiosCHSDriveSizeLow		equ		0x8
+BiosCHSDriveSize		equ		0x8
+ReadSectorsOffset		equ		0xa
+ReadClusterOffset		equ		0xc
+PutCharsOffset			equ		0xe
+
+
+org 7c00h
+
+segment .text
+
+bits 16
+
+start:
+        jmp short main
+        nop
+
+OEMName         db 'FrLdr1.0'
+BytesPerSector  dw 512
+SectsPerCluster db 1
+ReservedSectors dw 1
+NumberOfFats    db 2
+MaxRootEntries  dw 224
+TotalSectors    dw 2880
+MediaDescriptor db 0f0h
+SectorsPerFat   dw 9
+SectorsPerTrack dw 18
+NumberOfHeads   dw 2
+HiddenSectors   dd 0
+TotalSectorsBig dd 0
+BootDrive       db 0
+Reserved        db 0
+ExtendSig       db 29h
+SerialNumber    dd 00000000h
+VolumeLabel     db 'NO NAME    '
+FileSystem      db 'FAT12   '
+
+main:
+        xor ax,ax
+        mov ss,ax
+        mov bp,7c00h
+        mov sp,BootSectorStackTop				; Setup a stack
+        mov ds,ax								; Make DS correct
+        mov es,ax								; Make ES correct
+
+
+		cmp BYTE [BYTE bp+BootDrive],BYTE 0xff	; If they have specified a boot drive then use it
+		jne GetDriveParameters
+
+        mov [BYTE bp+BootDrive],dl				; Save the boot drive
+
+
+GetDriveParameters:
+		mov  ah,08h
+		mov  dl,[BYTE bp+BootDrive]					; Get boot drive in dl
+		int  13h									; Request drive parameters from the bios
+		jnc  CalcDriveSize							; If the call succeeded then calculate the drive size
+
+		; If we get here then the call to the BIOS failed
+		; so just set CHS equal to the maximum addressable
+		; size
+		mov  cx,0ffffh
+		mov  dh,cl
+
+CalcDriveSize:
+		; Now that we have the drive geometry
+		; lets calculate the drive size
+		mov  bl,ch			; Put the low 8-bits of the cylinder count into BL
+		mov  bh,cl			; Put the high 2-bits in BH
+		shr  bh,6			; Shift them into position, now BX contains the cylinder count
+		and  cl,3fh			; Mask off cylinder bits from sector count
+		; CL now contains sectors per track and DH contains head count
+		movzx eax,dh		; Move the heads into EAX
+		movzx ebx,bx		; Move the cylinders into EBX
+		movzx ecx,cl		; Move the sectors per track into ECX
+		inc   eax			; Make it one based because the bios returns it zero based
+		inc   ebx			; Make the cylinder count one based also
+		mul   ecx			; Multiply heads with the sectors per track, result in edx:eax
+		mul   ebx			; Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
+
+		; We now have the total number of sectors as reported
+		; by the bios in eax, so store it in our variable
+		mov   [BYTE bp-BiosCHSDriveSize],eax
+
+
+        ; Now we must find our way to the first sector of the root directory
+        xor ax,ax
+		xor cx,cx
+        mov al,[BYTE bp+NumberOfFats]			; Number of fats
+        mul WORD [BYTE bp+SectorsPerFat]		; Times sectors per fat
+        add ax,WORD [BYTE bp+HiddenSectors] 
+        adc dx,WORD [BYTE bp+HiddenSectors+2]	; Add the number of hidden sectors 
+        add ax,WORD [BYTE bp+ReservedSectors]	; Add the number of reserved sectors
+        adc dx,cx								; Add carry bit
+		mov WORD [BYTE bp-DataAreaStartLow],ax	; Save the starting sector of the root directory
+		mov WORD [BYTE bp-DataAreaStartHigh],dx	; Save it in the first 4 bytes before the boot sector
+		mov si,WORD [BYTE bp+MaxRootEntries]	; Get number of root dir entries in SI
+        pusha									; Save 32-bit logical start sector of root dir
+        ; DX:AX now has the number of the starting sector of the root directory
+
+        ; Now calculate the size of the root directory
+		xor dx,dx
+        mov ax,0020h							; Size of dir entry
+        mul si									; Times the number of entries
+        mov bx,[BYTE bp+BytesPerSector]
+        add ax,bx
+        dec ax
+        div bx									; Divided by the size of a sector
+		; AX now has the number of root directory sectors
+
+		add [BYTE bp-DataAreaStartLow],ax		; Add the number of sectors of the root directory to our other value
+		adc [BYTE bp-DataAreaStartHigh],cx		; Now the first 4 bytes before the boot sector contain the starting sector of the data area
+        popa									; Restore root dir logical sector start to DX:AX
+
+LoadRootDirSector:
+        mov  bx,7e0h							; We will load the root directory sector
+        mov  es,bx								; Right after the boot sector in memory
+        xor  bx,bx								; We will load it to [0000:7e00h]
+		xor  cx,cx								; Zero out CX
+		inc  cx									; Now increment it to 1, we are reading one sector
+		xor  di,di								; Zero out di
+		push es									; Save ES because it will get incremented by 20h
+		call ReadSectors						; Read the first sector of the root directory
+		pop  es									; Restore ES (ES:DI = 07E0:0000)
+
+SearchRootDirSector:
+		cmp  [es:di],ch							; If the first byte of the directory entry is zero then we have
+		jz   ErrBoot							; reached the end of the directory and FREELDR.SYS is not here so reboot
+		pusha									; Save all registers
+		mov  cl,0xb								; Put 11 in cl (length of filename in directory entry)
+		mov  si,filename						; Put offset of filename string in DS:SI
+		repe cmpsb								; Compare this directory entry against 'FREELDR SYS'
+		popa									; Restore all the registers
+		jz   FoundFreeLoader					; If we found it then jump
+		dec  si									; SI holds MaxRootEntries, subtract one
+		jz   ErrBoot							; If we are out of root dir entries then reboot
+		add  di,BYTE +0x20						; Increment DI by the size of a directory entry
+		cmp  di,0200h							; Compare DI to 512 (DI has offset to next dir entry, make sure we haven't gone over one sector)
+		jc   SearchRootDirSector				; If DI is less than 512 loop again
+		jmp short LoadRootDirSector				; Didn't find FREELDR.SYS in this directory sector, try again
+
+FoundFreeLoader:
+		; We found freeldr.sys on the disk
+		; so we need to load the first 512
+		; bytes of it to 0000:8000
+        ; ES:DI has dir entry (ES:DI == 07E0:XXXX)
+        mov  ax,WORD [es:di+1ah]				; Get start cluster
+		push ax									; Save start cluster
+		push WORD 800h							; Put 800h on the stack and load it
+		pop  es									; Into ES so that we load the cluster at 0000:8000
+		call ReadCluster						; Read the cluster
+		pop  ax									; Restore start cluster of FreeLoader
+
+		; Save the addresses of needed functions so
+		; the helper code will know where to call them.
+		mov  WORD [BYTE bp-ReadSectorsOffset],ReadSectors		; Save the address of ReadSectors
+		mov  WORD [BYTE bp-ReadClusterOffset],ReadCluster		; Save the address of ReadCluster
+		mov  WORD [BYTE bp-PutCharsOffset],PutChars				; Save the address of PutChars
+
+		; Now AX has start cluster of FreeLoader and we
+		; have loaded the helper code in the first 512 bytes
+		; of FreeLoader to 0000:8000. Now transfer control
+		; to the helper code. Skip the first three bytes
+		; because they contain a jump instruction to skip
+		; over the helper code in the FreeLoader image.
+		;jmp  0000:8003h
+		jmp  8003h
+
+
+
+
+; Displays an error message
+; And reboots
+ErrBoot:
+        mov  si,msgFreeLdr      ; FreeLdr not found message
+        call PutChars           ; Display it
+
+Reboot:
+        mov  si,msgAnyKey       ; Press any key message
+        call PutChars           ; Display it
+        xor ax,ax       
+        int 16h                 ; Wait for a keypress
+        int 19h                 ; Reboot
+
+PutChars:
+        lodsb
+        or al,al
+        jz short Done
+        mov ah,0eh
+        mov bx,07h
+        int 10h
+        jmp short PutChars
+Done:
+        retn
+
+; Displays a bad boot message
+; And reboots
+BadBoot:
+        mov  si,msgDiskError    ; Bad boot disk message
+        call PutChars           ; Display it
+
+		jmp short Reboot
+
+
+; Reads cluster number in AX into [ES:0000]
+ReadCluster:
+		; StartSector = ((Cluster - 2) * SectorsPerCluster) + ReservedSectors + HiddenSectors;
+        dec   ax								; Adjust start cluster by 2
+        dec   ax								; Because the data area starts on cluster 2
+        xor   ch,ch
+        mov   cl,BYTE [BYTE bp+SectsPerCluster]
+        mul   cx								; Times sectors per cluster
+        add   ax,[BYTE bp-DataAreaStartLow]		; Add start of data area
+        adc   dx,[BYTE bp-DataAreaStartHigh]	; Now we have DX:AX with the logical start sector of OSLOADER.SYS
+        xor   bx,bx								; We will load it to [ES:0000], ES loaded before function call
+		;mov   cl,BYTE [BYTE bp+SectsPerCluster]; Sectors per cluster still in CX
+		;call  ReadSectors
+		;ret
+
+
+
+; Reads logical sectors into [ES:BX]
+; DX:AX has logical sector number to read
+; CX has number of sectors to read
+ReadSectors:
+		
+		; We can't just check if the start sector is
+		; in the BIOS CHS range. We have to check if
+		; the start sector + length is in that range.
+		pusha
+		dec cx
+		add ax,cx
+		adc dx,byte 0
+
+		cmp dx,WORD [BYTE bp-BiosCHSDriveSizeHigh]	; Check if they are reading a sector within CHS range
+		ja  ReadSectorsLBA							; No - go to the LBA routine
+		jb  ReadSectorsCHS							; Yes - go to the old CHS routine
+		cmp ax,WORD [BYTE bp-BiosCHSDriveSizeLow]	; Check if they are reading a sector within CHS range
+		jbe ReadSectorsCHS							; Yes - go to the old CHS routine
+
+ReadSectorsLBA:
+		popa
+ReadSectorsLBALoop:
+		pusha									; Save logical sector number & sector count
+
+		o32 push byte 0
+		push dx									; Put 64-bit logical
+		push ax									; block address on stack
+		push es									; Put transfer segment on stack
+		push bx									; Put transfer offset on stack
+		push byte 1								; Set transfer count to 1 sector
+		push byte 0x10							; Set size of packet to 10h
+		mov  si,sp								; Setup disk address packet on stack
+
+; We are so totally out of space here that I am forced to
+; comment out this very beautifully written piece of code
+; It would have been nice to have had this check...
+;CheckInt13hExtensions:							; Now make sure this computer supports extended reads
+;		mov  ah,0x41							; AH = 41h
+;		mov  bx,0x55aa							; BX = 55AAh
+;		mov  dl,[BYTE bp+BootDrive]				; DL = drive (80h-FFh)
+;		int  13h								; IBM/MS INT 13 Extensions - INSTALLATION CHECK
+;		jc   PrintDiskError						; CF set on error (extensions not supported)
+;		cmp  bx,0xaa55							; BX = AA55h if installed
+;		jne  PrintDiskError
+;		test cl,1								; CX = API subset support bitmap
+;		jz   PrintDiskError						; Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
+
+
+												; Good, we're here so the computer supports LBA disk access
+												; So finish the extended read
+        mov  dl,[BYTE bp+BootDrive]				; Drive number
+		mov  ah,42h								; Int 13h, AH = 42h - Extended Read
+		int  13h								; Call BIOS
+		jc   BadBoot							; If the read failed then abort
+
+		add  sp,byte 0x10						; Remove disk address packet from stack
+
+		popa									; Restore sector count & logical sector number
+
+        inc  ax									; Increment Sector to Read
+		adc  dx,byte 0
+
+        push bx
+        mov  bx,es
+        add  bx,byte 20h						; Increment read buffer for next sector
+        mov  es,bx
+        pop  bx
+												
+        loop ReadSectorsLBALoop					; Read next sector
+
+        ret   
+
+
+; Reads logical sectors into [ES:BX]
+; DX:AX has logical sector number to read
+; CX has number of sectors to read
+; CarryFlag set on error
+ReadSectorsCHS:
+		popa
+ReadSectorsCHSLoop:
+        pusha
+        xchg ax,cx
+        xchg ax,dx
+        xor  dx,dx
+        div  WORD [BYTE bp+SectorsPerTrack]
+        xchg ax,cx                    
+        div  WORD [BYTE bp+SectorsPerTrack]    ; Divide logical by SectorsPerTrack
+        inc  dx                        ; Sectors numbering starts at 1 not 0
+        xchg cx,dx
+        div  WORD [BYTE bp+NumberOfHeads]      ; Number of heads
+        mov  dh,dl                     ; Head to DH, drive to DL
+        mov  dl,[BYTE bp+BootDrive]            ; Drive number
+        mov  ch,al                     ; Cylinder in CX
+        ror  ah,2                      ; Low 8 bits of cylinder in CH, high 2 bits
+                                       ;  in CL shifted to bits 6 & 7
+        or   cl,ah                     ; Or with sector number
+        mov  ax,0201h
+        int  13h     ; DISK - READ SECTORS INTO MEMORY
+                     ; AL = number of sectors to read, CH = track, CL = sector
+                     ; DH = head, DL    = drive, ES:BX -> buffer to fill
+                     ; Return: CF set on error, AH =    status (see AH=01h), AL    = number of sectors read
+
+        jc   BadBoot
+
+        popa
+        inc  ax       ;Increment Sector to Read
+        jnz  NoCarryCHS
+        inc  dx
+
+
+NoCarryCHS:
+        push bx
+        mov  bx,es
+        add  bx,byte 20h
+        mov  es,bx
+        pop  bx
+                                        ; Increment read buffer for next sector
+        loop ReadSectorsCHSLoop         ; Read next sector
+
+        ret   
+
+
+msgDiskError db 'Disk error',0dh,0ah,0
+msgFreeLdr   db 'freeldr.sys not found',0dh,0ah,0
+; Sorry, need the space...
+;msgAnyKey    db 'Press any key to restart',0dh,0ah,0
+msgAnyKey    db 'Press any key',0dh,0ah,0
+filename     db 'FREELDR SYS'
+
+        times 509-($-$$) db 0   ; Pad to 509 bytes
+
+BootPartition:
+		db 0
+
+BootSignature:
+        dw 0aa55h       ; BootSector signature

freeldr/bootsect/fat32.asm

@@ -0,0 +1,505 @@
+; FAT32.ASM
+; FAT32 Boot Sector
+; Copyright (c) 1998, 2000, 2001, 2002 Brian Palmer
+
+org 7c00h
+
+segment .text
+
+bits 16
+
+start:
+        jmp short main
+        nop
+
+OEMName				db 'FrLdr1.0'
+BytesPerSector		dw 512
+SectsPerCluster		db 0
+ReservedSectors		dw 32
+NumberOfFats		db 2
+MaxRootEntries		dw 0			; Always zero for FAT32 volumes
+TotalSectors		dw 0			; Always zero for FAT32 volumes
+MediaDescriptor		db 0f8h
+SectorsPerFat		dw 0			; Always zero for FAT32 volumes
+SectorsPerTrack		dw 0
+NumberOfHeads		dw 0
+HiddenSectors		dd 0
+TotalSectorsBig		dd 0
+; FAT32 Inserted Info
+SectorsPerFatBig	dd	0
+ExtendedFlags		dw	0
+FSVersion			dw	0
+RootDirStartCluster	dd	0
+FSInfoSector		dw	0
+BackupBootSector	dw	6
+Reserved1			times 12 db 0
+; End FAT32 Inserted Info
+BootDrive			db 0
+Reserved			db 0
+ExtendSig			db 29h
+SerialNumber		dd 00000000h
+VolumeLabel			db 'NO NAME    '
+FileSystem			db 'FAT32   '
+
+main:
+        xor ax,ax               ; Setup segment registers
+        mov ds,ax               ; Make DS correct
+        mov es,ax               ; Make ES correct
+        mov ss,ax				; Make SS correct
+		mov bp,7c00h
+        mov sp,7c00h            ; Setup a stack
+
+
+
+		cmp BYTE [BYTE bp+BootDrive],BYTE 0xff	; If they have specified a boot drive then use it
+		jne CheckSectorsPerFat
+
+        mov [BYTE bp+BootDrive],dl				; Save the boot drive
+
+
+
+CheckSectorsPerFat:
+        cmp	WORD [BYTE bp+SectorsPerFat],byte 0x00	; Check the old 16-bit value of SectorsPerFat
+		jnz CheckFailed								; If it is non-zero then exit with an error
+CheckTotalSectors:									; Check the old 16-bit value of TotalSectors & MaxRootEntries
+        cmp	DWORD [BYTE bp+MaxRootEntries],byte 0x00; by comparing the DWORD at offset MaxRootEntries to zero
+		jnz CheckFailed								; If it is non-zero then exit with an error
+CheckFileSystemVersion:
+        cmp WORD [BYTE bp+FSVersion],byte 0x00		; Check the file system version word
+		jna GetDriveParameters						; It is zero, so continue
+CheckFailed:
+        jmp PrintFileSystemError					; If it is not zero then exit with an error
+
+
+GetDriveParameters:
+		mov  ax,0800h
+		mov  dl,[BYTE bp+BootDrive]					; Get boot drive in dl
+		int  13h									; Request drive parameters from the bios
+		jnc  CalcDriveSize							; If the call succeeded then calculate the drive size
+
+		; If we get here then the call to the BIOS failed
+		; so just set CHS equal to the maximum addressable
+		; size
+		mov  cx,0ffffh
+		mov  dh,cl
+
+CalcDriveSize:
+		; Now that we have the drive geometry
+		; lets calculate the drive size
+		mov  bl,ch			; Put the low 8-bits of the cylinder count into BL
+		mov  bh,cl			; Put the high 2-bits in BH
+		shr  bh,6			; Shift them into position, now BX contains the cylinder count
+		and  cl,3fh			; Mask off cylinder bits from sector count
+		; CL now contains sectors per track and DH contains head count
+		movzx eax,dh		; Move the heads into EAX
+		movzx ebx,bx		; Move the cylinders into EBX
+		movzx ecx,cl		; Move the sectors per track into ECX
+		inc   eax			; Make it one based because the bios returns it zero based
+		inc   ebx			; Make the cylinder count one based also
+		mul   ecx			; Multiply heads with the sectors per track, result in edx:eax
+		mul   ebx			; Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
+
+		; We now have the total number of sectors as reported
+		; by the bios in eax, so store it in our variable
+		mov   [BiosCHSDriveSize],eax
+
+
+LoadExtraBootCode:
+		; First we have to load our extra boot code at
+		; sector 14 into memory at [0000:7e00h]
+		mov  eax,0eh
+        add  eax,DWORD [BYTE bp+HiddenSectors]	; Add the number of hidden sectors 
+		mov  cx,1
+        xor  bx,bx
+        mov  es,bx								; Read sector to [0000:7e00h]
+		mov  bx,7e00h
+		call ReadSectors
+		jmp  StartSearch
+
+
+
+; Reads logical sectors into [ES:BX]
+; EAX has logical sector number to read
+; CX has number of sectors to read
+ReadSectors:
+		cmp  eax,DWORD [BiosCHSDriveSize]		; Check if they are reading a sector outside CHS range
+		jae  ReadSectorsLBA						; Yes - go to the LBA routine
+												; If at all possible we want to use LBA routines because
+												; They are optimized to read more than 1 sector per read
+
+		pushad									; Save logical sector number & sector count
+
+CheckInt13hExtensions:							; Now check if this computer supports extended reads
+		mov  ah,0x41							; AH = 41h
+		mov  bx,0x55aa							; BX = 55AAh
+		mov  dl,[BYTE bp+BootDrive]				; DL = drive (80h-FFh)
+		int  13h								; IBM/MS INT 13 Extensions - INSTALLATION CHECK
+		jc   ReadSectorsCHS						; CF set on error (extensions not supported)
+		cmp  bx,0xaa55							; BX = AA55h if installed
+		jne  ReadSectorsCHS
+		test cl,1								; CX = API subset support bitmap
+		jz   ReadSectorsCHS						; Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
+
+		popad									; Restore sector count & logical sector number
+
+ReadSectorsLBA:
+		pushad									; Save logical sector number & sector count
+
+		cmp  cx,64								; Since the LBA calls only support 0x7F sectors at a time we will limit ourselves to 64
+		jbe  ReadSectorsSetupDiskAddressPacket	; If we are reading less than 65 sectors then just do the read
+		mov  cx,64								; Otherwise read only 64 sectors on this loop iteration
+
+ReadSectorsSetupDiskAddressPacket:
+		mov  [LBASectorsRead],cx
+		o32 push byte 0
+		push eax								; Put 64-bit logical block address on stack
+		push es									; Put transfer segment on stack
+		push bx									; Put transfer offset on stack
+		push cx									; Set transfer count
+		push byte 0x10							; Set size of packet to 10h
+		mov  si,sp								; Setup disk address packet on stack
+
+
+        mov  dl,[BYTE bp+BootDrive]				; Drive number
+		mov  ah,42h								; Int 13h, AH = 42h - Extended Read
+		int  13h								; Call BIOS
+		jc   PrintDiskError						; If the read failed then abort
+
+		add  sp,byte 0x10							; Remove disk address packet from stack
+
+		popad									; Restore sector count & logical sector number
+
+		push bx
+		mov  ebx,DWORD [LBASectorsRead]
+        add  eax,ebx							; Increment sector to read
+		shl  ebx,5
+        mov  dx,es
+        add  dx,bx								; Setup read buffer for next sector
+        mov  es,dx
+		pop  bx
+
+		sub  cx,[LBASectorsRead]
+        jnz  ReadSectorsLBA						; Read next sector
+
+        ret
+
+LBASectorsRead:
+	dd	0
+
+
+; Reads logical sectors into [ES:BX]
+; EAX has logical sector number to read
+; CX has number of sectors to read
+ReadSectorsCHS:
+		popad										; Get logical sector number & sector count off stack
+
+ReadSectorsCHSLoop:
+        pushad
+        xor   edx,edx
+		movzx ecx,WORD [BYTE bp+SectorsPerTrack]
+		div   ecx									; Divide logical by SectorsPerTrack
+        inc   dl									; Sectors numbering starts at 1 not 0
+		mov   cl,dl									; Sector in CL
+		mov   edx,eax
+		shr   edx,16
+        div   WORD [BYTE bp+NumberOfHeads]			; Divide logical by number of heads
+        mov   dh,dl									; Head in DH
+        mov   dl,[BYTE bp+BootDrive]				; Drive number in DL
+        mov   ch,al									; Cylinder in CX
+        ror   ah,1									; Low 8 bits of cylinder in CH, high 2 bits
+        ror   ah,1									;  in CL shifted to bits 6 & 7
+        or    cl,ah									; Or with sector number
+        mov   ax,0201h
+        int   13h    ; DISK - READ SECTORS INTO MEMORY
+                     ; AL = number of sectors to read, CH = track, CL = sector
+                     ; DH = head, DL    = drive, ES:BX -> buffer to fill
+                     ; Return: CF set on error, AH =    status (see AH=01h), AL    = number of sectors read
+
+        jc    PrintDiskError						; If the read failed then abort
+
+        popad
+
+        inc   eax									; Increment Sector to Read
+
+        mov   dx,es
+        add   dx,byte 20h							; Increment read buffer for next sector
+        mov   es,dx
+
+        loop  ReadSectorsCHSLoop					; Read next sector
+
+        ret   
+
+
+
+
+; Displays a disk error message
+; And reboots
+PrintDiskError:
+        mov  si,msgDiskError			; Bad boot disk message
+        call PutChars					; Display it
+
+		jmp  Reboot
+
+; Displays a file system error message
+; And reboots
+PrintFileSystemError:
+        mov  si,msgFileSystemError		; FreeLdr not found message
+        call PutChars					; Display it
+
+Reboot:
+        mov  si,msgAnyKey				; Press any key message
+        call PutChars					; Display it
+        xor ax,ax       
+        int 16h							; Wait for a keypress
+        int 19h							; Reboot
+
+PutChars:
+        lodsb
+        or al,al
+        jz short Done
+        mov ah,0eh
+        mov bx,07h
+        int 10h
+        jmp short PutChars
+Done:
+        retn
+
+
+
+BiosCHSDriveSize dd 0
+
+msgDiskError		db 'Disk error',0dh,0ah,0
+msgFileSystemError	db 'File system error',0dh,0ah,0
+msgAnyKey			db 'Press any key to restart',0dh,0ah,0
+
+        times 509-($-$$) db 0   ; Pad to 509 bytes
+
+BootPartition:
+		db 0
+
+BootSignature:
+        dw 0aa55h       ; BootSector signature
+        
+
+; End of bootsector
+;
+; Now starts the extra boot code that we will store
+; at sector 14 on a FAT32 volume
+;
+; To remain multi-boot compatible with other operating
+; systems we must not overwrite anything other than
+; the bootsector which means we will have to use
+; a different sector like 14 to store our extra boot code
+
+
+
+StartSearch:
+        ; Now we must get the first cluster of the root directory
+		mov  eax,DWORD [BYTE bp+RootDirStartCluster]
+		cmp  eax,0ffffff8h		; Check to see if this is the last cluster in the chain
+		jb	 ContinueSearch		; If not continue, if so then we didn't find freeldr.sys
+		jmp  PrintFileNotFound
+ContinueSearch:
+        mov  bx,2000h
+        mov  es,bx				; Read cluster to [2000:0000h]
+        call ReadCluster        ; Read the cluster
+
+
+        ; Now we have to find our way through the root directory to
+        ; The OSLOADER.SYS file
+		xor  bx,bx
+        mov  bl,[BYTE bp+SectsPerCluster]
+		shl  bx,4				; BX = BX * 512 / 32
+        mov  ax,2000h            ; We loaded at 2000:0000
+        mov  es,ax
+        xor  di,di
+        mov  si,filename
+        mov  cx,11
+        rep  cmpsb              ; Compare filenames
+        jz   FoundFile          ; If same we found it
+        dec  bx
+        jnz  FindFile
+        jmp  PrintFileNotFound
+
+FindFile:
+        mov  ax,es              ; We didn't find it in the previous dir entry
+        add  ax,2               ; So lets move to the next one
+        mov  es,ax              ; And search again
+        xor  di,di
+        mov  si,filename        
+        mov  cx,11
+        rep  cmpsb              ; Compare filenames
+        jz   FoundFile          ; If same we found it
+        dec  bx                 ; Keep searching till we run out of dir entries
+        jnz  FindFile           ; Last entry?
+
+		; Get the next root dir cluster and try again until we run out of clusters
+		mov  eax,DWORD [BYTE bp+RootDirStartCluster]
+		call GetFatEntry
+		mov  [BYTE bp+RootDirStartCluster],eax
+        jmp  StartSearch
+
+FoundFile:
+
+										; Display "Loading FreeLoader..." message
+        mov  si,msgLoading				; Loading message
+        call PutChars					; Display it
+
+        xor  di,di						; ES:DI has dir entry
+        xor  dx,dx
+        mov  ax,WORD [es:di+14h]        ; Get start cluster high word
+		shl  eax,16
+        mov  ax,WORD [es:di+1ah]        ; Get start cluster low word
+
+CheckStartCluster:
+		cmp  eax,2						; Check and see if the start cluster starts at cluster 2 or above
+		jnb  CheckEndCluster			; If so then continue
+		jmp  PrintFileSystemError		; If not exit with error
+CheckEndCluster:
+		cmp  eax,0ffffff8h				; Check and see if the start cluster is and end of cluster chain indicator
+		jb   InitializeLoadSegment		; If not then continue
+		jmp  PrintFileSystemError		; If so exit with error
+
+InitializeLoadSegment:
+        mov  bx,800h
+        mov  es,bx
+
+LoadFile:
+		cmp  eax,0ffffff8h		; Check to see if this is the last cluster in the chain
+		jae	 LoadFileDone		; If so continue, if not then read the next one
+		push eax
+        xor  bx,bx              ; Load ROSLDR starting at 0000:8000h
+		push es
+		call ReadCluster
+		pop  es
+
+		xor  bx,bx
+        mov  bl,[BYTE bp+SectsPerCluster]
+		shl  bx,5				; BX = BX * 512 / 16
+		mov  ax,es				; Increment the load address by
+		add  ax,bx				; The size of a cluster
+		mov  es,ax
+
+		pop  eax
+		push es
+		call GetFatEntry		; Get the next entry
+		pop  es
+
+        jmp  LoadFile			; Load the next cluster (if any)
+
+LoadFileDone:
+        mov  dl,[BYTE bp+BootDrive]		; Load boot drive into DL
+		mov  dh,[BootPartition]			; Load boot partition into DH
+        xor  ax,ax
+        push ax					; We loaded at 0000:8000
+        push WORD 8000h			; We will do a far return to 0000:8000h
+        retf                    ; Transfer control to ROSLDR
+
+
+; Returns the FAT entry for a given cluster number
+; On entry EAX has cluster number
+; On return EAX has FAT entry for that cluster
+GetFatEntry:
+
+		shl   eax,2								; EAX = EAX * 4 (since FAT32 entries are 4 bytes)
+		mov   ecx,eax							; Save this for later in ECX
+		xor   edx,edx
+		movzx ebx,WORD [BYTE bp+BytesPerSector]
+		push  ebx
+		div   ebx								; FAT Sector Number = EAX / BytesPerSector
+		movzx ebx,WORD [BYTE bp+ReservedSectors]
+		add   eax,ebx							; FAT Sector Number += ReservedSectors
+		mov   ebx,DWORD [BYTE bp+HiddenSectors]
+		add   eax,ebx							; FAT Sector Number += HiddenSectors
+		pop   ebx
+		dec   ebx
+		and   ecx,ebx							; FAT Offset Within Sector = ECX % BytesPerSector
+												; EAX holds logical FAT sector number
+												; ECX holds FAT entry offset
+
+												; Now we have to check the extended flags
+												; to see which FAT is the active one
+												; and use it, or if they are mirrored then
+												; no worries
+		movzx ebx,WORD [BYTE bp+ExtendedFlags]	; Get extended flags and put into ebx
+		and   bx,0x0f							; Mask off upper 8 bits, now we have active fat in bl
+		jz    LoadFatSector						; If fat is mirrored then skip fat calcs
+		cmp   bl,[BYTE bp+NumberOfFats]			; Compare bl to number of fats
+		jb    GetActiveFatOffset
+		jmp   PrintFileSystemError				; If bl is bigger than numfats exit with error
+GetActiveFatOffset:
+		push  eax								; Save logical FAT sector number
+		mov   eax,[BYTE bp+SectorsPerFatBig]	; Get the number of sectors occupied by one fat in eax
+		mul   ebx								; Multiplied by the active FAT index we have in ebx
+		pop   edx								; Get logical FAT sector number
+		add   eax,edx							; Add the current FAT sector offset
+
+LoadFatSector:
+		push  ecx
+		; EAX holds logical FAT sector number
+		; Check if we have already loaded it
+		cmp  eax,DWORD [FatSectorInCache]
+		je   LoadFatSectorAlreadyLoaded
+
+		mov  DWORD [FatSectorInCache],eax
+        mov  bx,7000h
+        mov  es,bx
+        xor  bx,bx								; We will load it to [7000:0000h]
+		mov  cx,1
+		call ReadSectors
+
+LoadFatSectorAlreadyLoaded:
+        mov  bx,7000h
+        mov  es,bx
+		pop  ecx
+		mov  eax,DWORD [es:ecx]					; Get FAT entry
+		and  eax,0fffffffh						; Mask off reserved bits
+
+		ret
+
+FatSectorInCache:								; This variable tells us which sector we currently have in memory
+	dd	0ffffffffh								; There is no need to re-read the same sector if we don't have to
+
+
+; Reads cluster number in EAX into [ES:0000]
+ReadCluster:
+		; StartSector = ((Cluster - 2) * SectorsPerCluster) + ReservedSectors + HiddenSectors;
+
+		dec   eax
+		dec   eax
+		xor   edx,edx
+		movzx ebx,BYTE [BYTE bp+SectsPerCluster]
+		mul   ebx
+		push  eax
+		xor   edx,edx
+		movzx eax,BYTE [BYTE bp+NumberOfFats]
+		mul   DWORD [BYTE bp+SectorsPerFatBig]
+		movzx ebx,WORD [BYTE bp+ReservedSectors]
+		add   eax,ebx
+		add   eax,DWORD [BYTE bp+HiddenSectors]
+		pop   ebx
+		add   eax,ebx			; EAX now contains the logical sector number of the cluster
+        xor   bx,bx				; We will load it to [ES:0000], ES loaded before function call
+		movzx cx,BYTE [BYTE bp+SectsPerCluster]
+		call  ReadSectors
+		ret
+
+
+; Displays a file not found error message
+; And reboots
+PrintFileNotFound:
+        mov  si,msgFreeLdr      ; FreeLdr not found message
+        call PutChars           ; Display it
+        mov  si,msgAnyKey       ; Press any key message
+        call PutChars           ; Display it
+
+		jmp  Reboot
+
+msgFreeLdr   db 'freeldr.sys not found',0dh,0ah,0
+filename     db 'FREELDR SYS'
+msgLoading   db 'Loading FreeLoader...',0dh,0ah,0
+
+
+        times 1022-($-$$) db 0   ; Pad to 1022 bytes
+
+        dw 0aa55h       ; BootSector signature

freeldr/bootsect/win2k.asm

@@ -0,0 +1,466 @@
+;
+; Win2k FAT32 Boot Sector
+;
+; Brian Palmer <brianp@sginet.com>
+;
+
+;
+; The BP register is initialized to 0x7c00, the start of
+; the boot sector. The SP register is initialized to
+; 0x7bf4, leaving 12 bytes of data storage space above
+; the stack.
+;
+; The DWORD that gets stored at 0x7bf4 is 0xffffffff ??
+;
+; The DWORD that gets stored at 0x7bf8 is the count of
+; total sectors of the volume, calculated from the BPB.
+;
+; The DWORD that gets stored at 0x7bfc is the logical
+; sector number of the start of the data area.
+;
+
+org 7c00h
+
+segment .text
+
+bits 16
+
+start:
+        jmp short main
+        nop
+
+OEMName				db 'MSWIN4.0'
+BytesPerSector		dw 512
+SectsPerCluster		db 1
+ReservedSectors		dw 1
+NumberOfFats		db 2
+MaxRootEntries		dw 0			;512 - Always zero for FAT32 volumes
+TotalSectors		dw 0			;2880 - Always zero for FAT32 volumes
+MediaDescriptor		db 0f8h
+SectorsPerFat		dw 0			;9 - Always zero for FAT32 volumes
+SectorsPerTrack		dw 18
+NumberOfHeads		dw 2
+HiddenSectors		dd 0
+TotalSectorsBig		dd 0
+; FAT32 Inserted Info
+SectorsPerFatBig	dd	0
+ExtendedFlags		dw	0
+FSVersion			dw	0
+RootDirStartCluster	dd	0
+FSInfoSector		dw	0
+BackupBootSector	dw	6
+Reserved1			times 12 db 0
+; End FAT32 Inserted Info
+BootDrive			db 80h
+Reserved			db 0
+ExtendSig			db 29h
+SerialNumber		dd 00000000h
+VolumeLabel			db 'NO NAME    '
+FileSystem			db 'FAT32   '
+
+main:
+00007C5A  33C9              xor		cx,cx
+00007C5C  8ED1              mov		ss,cx			; Setup the stack
+00007C5E  BCF47B            mov		sp,0x7bf4		; Give us 12 bytes of space above the stack
+00007C61  8EC1              mov		es,cx
+00007C63  8ED9              mov		ds,cx
+00007C65  BD007C            mov		bp,0x7c00
+00007C68  884E02            mov		[bp+0x2],cl		; Zero out the nop instruction?? (3rd byte of the boot sector)
+00007C6B  8A5640            mov		dl,[bp+BootDrive]
+00007C6E  B408              mov		ah,0x8
+00007C70  CD13              int		0x13			; Int 13, func 8 - Get Drive Parameters
+00007C72  7305              jnc		drive_param_ok	; If no error jmp
+
+drive_param_error:
+00007C74  B9FFFF            mov		cx,0xffff		; We couldn't determine the drive parameters
+00007C77  8AF1              mov		dh,cl			; So just set the CHS to 0xff
+
+drive_param_ok:
+00007C79  660FB6C6          movzx	eax,dh			; Store the number of heads in eax
+00007C7D  40                inc		ax				; Make it one-based because the bios returns it zero-based
+00007C7E  660FB6D1          movzx	edx,cl			; Store the sectors per track in edx
+00007C82  80E23F            and		dl,0x3f			; Mask off the cylinder bits
+00007C85  F7E2              mul		dx				; Multiply the sectors per track with the heads, result in dx:ax
+00007C87  86CD              xchg	cl,ch			; Switch the cylinder with the sectors
+00007C89  C0ED06            shr		ch,0x6			; Move the top two cylinder bits down where they should be
+00007C8C  41                inc		cx				; Make it one-based because the bios returns it zero-based
+00007C8D  660FB7C9          movzx	ecx,cx
+00007C91  66F7E1            mul		ecx				; Multiply the cylinders with (heads * sectors) [stored in dx:ax already]
+00007C94  668946F8          mov		[bp-0x8],eax	; This value is the number of total sectors on the disk, so save it for later
+00007C98  837E1600          cmp		word [bp+TotalSectors],byte +0x0	; Check the old 16-bit value of TotalSectors
+00007C9C  7538              jnz		print_ntldr_error_message			; If it is non-zero then exit with an error
+
+00007C9E  837E2A00          cmp		word [bp+FSVersion],byte +0x0		; Check the file system version word
+00007CA2  7732              ja		print_ntldr_error_message			; If it is not zero then exit with an error
+
+
+		;
+		; We are now ready to load our second sector of boot code
+		; But first, a bit of undocumented information about how
+		; Win2k stores it's second sector of boot code.
+		;
+		; The FAT32 filesystem was designed so that you can store
+		; multiple sectors of boot code. The boot sector of a FAT32
+		; volume is actually three sectors long. Microsoft extended
+		; the BPB so much that you can't fit enough code in the
+		; boot sector to make it work. So they extended it. Sector 0
+		; is the traditional boot sector, sector 1 is the FSInfo sector,
+		; and sector 2 is used to store extra boot code to make up
+		; for the lost space the BPB takes.
+		;
+		; Now this creates an interesting problem. Suppose for example
+		; that the user has Win98 and Win2k installed. The Win2k
+		; boot sector is stored at sector 0 and the Win98 boot sector is
+		; stored as BOOTSECT.DOS on the file system. Now if Win2k were
+		; to store it's second sector of boot code in sector 2 like
+		; the fat spec says to do then when you try to dual boot back
+		; to Win98 the Win98 boot sector will load Win2k's second
+		; sector of boot code. Understand? ;-)
+		;
+		; To get around this problem Win2k stores it's second sector
+		; of boot code elsewhere. This sector is always stored at sector 13
+		; on the file system. Now don't ask me what happens when you don't
+		; have enough reserved sectors to store it, but I've never seen a
+		; FAT32 volume that didn't have at least 32 reserved sectors.
+		;
+
+00007CA4  668B461C          mov		eax,[bp+HiddenSectors]	; Get the count of hidden sectors
+00007CA8  6683C00C          add		eax,byte +0xc			; Add 12 to that value so that we are loading the 13th sector of the volume
+00007CAC  BB0080            mov		bx,0x8000				; Read the sector to address 0x8000
+00007CAF  B90100            mov		cx,0x1					; Read just one sector
+00007CB2  E82B00            call	read_sectors			; Read it
+00007CB5  E94803            jmp		0x8000					; Jump to the next sector of boot code
+
+print_disk_error_message:
+00007CB8  A0FA7D            mov		al,[DISK_ERR_offset_from_0x7d00]
+putchars:
+00007CBB  B47D              mov		ah,0x7d
+00007CBD  8BF0              mov		si,ax
+get_another_char:
+00007CBF  AC                lodsb
+00007CC0  84C0              test	al,al
+00007CC2  7417              jz		reboot
+00007CC4  3CFF              cmp		al,0xff
+00007CC6  7409              jz		print_reboot_message
+00007CC8  B40E              mov		ah,0xe
+00007CCA  BB0700            mov		bx,0x7
+00007CCD  CD10              int		0x10
+00007CCF  EBEE              jmp		short get_another_char
+print_reboot_message:
+00007CD1  A0FB7D            mov		al,[RESTART_ERR_offset_from_0x7d00]
+00007CD4  EBE5              jmp		short putchars
+print_ntldr_error_message:
+00007CD6  A0F97D            mov		al,[NTLDR_ERR_offset_from_0x7d00]
+00007CD9  EBE0              jmp		short putchars
+reboot:
+00007CDB  98                cbw
+00007CDC  CD16              int		0x16
+00007CDE  CD19              int		0x19
+
+read_sectors:
+00007CE0  6660              pushad
+00007CE2  663B46F8          cmp		eax,[bp-0x8]
+00007CE6  0F824A00          jc		near 0x7d34
+00007CEA  666A00            o32		push byte +0x0
+00007CED  6650              push	eax
+00007CEF  06                push	es
+00007CF0  53                push	bx
+00007CF1  666810000100      push	dword 0x10010
+00007CF7  807E0200          cmp		byte [bp+0x2],0x0
+00007CFB  0F852000          jnz		near 0x7d1f
+00007CFF  B441              mov		ah,0x41
+00007D01  BBAA55            mov		bx,0x55aa
+00007D04  8A5640            mov		dl,[bp+BootDrive]
+00007D07  CD13              int		0x13
+00007D09  0F821C00          jc		near 0x7d29
+00007D0D  81FB55AA          cmp		bx,0xaa55
+00007D11  0F851400          jnz		near 0x7d29
+00007D15  F6C101            test	cl,0x1
+00007D18  0F840D00          jz		near 0x7d29
+00007D1C  FE4602            inc		byte [bp+0x2]
+00007D1F  B442              mov		ah,0x42
+00007D21  8A5640            mov		dl,[bp+BootDrive]
+00007D24  8BF4              mov		si,sp
+00007D26  CD13              int		0x13
+00007D28  B0F9              mov		al,0xf9
+00007D2A  6658              pop		eax
+00007D2C  6658              pop		eax
+00007D2E  6658              pop		eax
+00007D30  6658              pop		eax
+00007D32  EB2A              jmp		short 0x7d5e
+00007D34  6633D2            xor		edx,edx
+00007D37  660FB74E18        movzx	ecx,word [bp+SectorsPerTrack]
+00007D3C  66F7F1            div		ecx
+00007D3F  FEC2              inc		dl
+00007D41  8ACA              mov		cl,dl
+00007D43  668BD0            mov		edx,eax
+00007D46  66C1EA10          shr		edx,0x10
+00007D4A  F7761A            div		word [bp+NumberOfHeads]
+00007D4D  86D6              xchg	dl,dh
+00007D4F  8A5640            mov		dl,[bp+BootDrive]
+00007D52  8AE8              mov		ch,al
+00007D54  C0E406            shl		ah,0x6
+00007D57  0ACC              or		cl,ah
+00007D59  B80102            mov		ax,0x201
+00007D5C  CD13              int		0x13
+00007D5E  6661              popad
+00007D60  0F8254FF          jc		near print_disk_error_message
+00007D64  81C30002          add		bx,0x200
+00007D68  6640              inc		eax
+00007D6A  49                dec		cx
+00007D6B  0F8571FF          jnz		near read_sectors
+00007D6F  C3                ret
+
+NTLDR		db 'NTLDR      '
+
+filler		times 49	db 0
+
+NTLDR_ERR	db 0dh,0ah,'NTLDR is missing',0ffh
+DISK_ERR	db 0dh,0ah,'Disk error',0ffh
+RESTART_ERR	db 0dh,0ah,'Press any key to restart',0dh,0ah
+
+more_filler	times 16	db 0
+
+NTLDR_offset_from_0x7d00						db 0
+NTLDR_ERR_offset_from_0x7d00					db 0ach
+DISK_ERR_offset_from_0x7d00						db 0bfh
+RESTART_ERR_offset_from_0x7d00					db 0cch
+
+						dw 0
+						dw 0aa55h
+
+
+
+
+
+
+;
+; And that ends the code that makes up the traditional boot sector
+; From here on out is a disassembly of the extra sector of boot
+; code required for a FAT32 volume. Win2k stores this code at
+; sector 13 on the file system.
+;
+
+
+
+
+00008000  660FB64610        movzx eax,byte [bp+NumberOfFats]	; Put the number of fats into eax
+00008005  668B4E24          mov ecx,[bp+SectorsPerFatBig]		; Put the count of sectors per fat into ecx
+00008009  66F7E1            mul ecx								; Multiply them, edx:eax = (eax * ecx)
+0000800C  6603461C          add eax,[bp+HiddenSectors]			; Add the hidden sectors to eax
+00008010  660FB7560E        movzx edx,word [bp+ReservedSectors]	; Put the count of reserved sectors into edx
+00008015  6603C2            add eax,edx							; Add it to eax
+00008018  668946FC          mov [bp-0x4],eax					; eax now contains the start of the data area, so save it for later
+0000801C  66C746F4FFFFFFFF  mov dword [bp-0xc],0xffffffff		; Save 0xffffffff for later??
+00008024  668B462C          mov eax,[bp+RootDirStartCluster]	; Put the starting cluster of the root directory into eax
+00008028  6683F802          cmp eax,byte +0x2					; Check and see if the root directory starts at cluster 2 or above
+0000802C  0F82A6FC          jc near print_ntldr_error_message	; If not exit with error
+00008030  663DF8FFFF0F      cmp eax,0xffffff8					; Check and see if the root directory start cluster is and end of cluster chain indicator
+00008036  0F839CFC          jnc near print_ntldr_error_message	; If so exit with error
+
+search_root_directory_cluster:
+0000803A  6650              push eax							; Save root directory start cluster on stack
+0000803C  6683E802          sub eax,byte +0x2					; Adjust it because the first two fat entries are unused so the third entry marks the first data area cluster
+00008040  660FB65E0D        movzx ebx,byte [bp+SectsPerCluster]	; Put the number of sectors per cluster in ebx
+00008045  8BF3              mov si,bx							; Now store it also in si register
+00008047  66F7E3            mul ebx								; Multiply sectors per cluster with root directory start cluster
+0000804A  660346FC          add eax,[bp-0x4]					; Add the start sector of the data area
+
+read_directory_sector:
+0000804E  BB0082            mov bx,0x8200						; We now have the start sector of the root directory, so load it to 0x8200
+00008051  8BFB              mov di,bx							; Put the address of the root directory sector in di also
+00008053  B90100            mov cx,0x1							; Read one sector
+00008056  E887FC            call read_sectors					; Perform the read
+
+check_entry_for_ntldr:
+00008059  382D              cmp [di],ch							; Check the first byte of the root directory entry for zero
+0000805B  741E              jz ntldr_not_found					; If so then NTLDR is missing so exit with error
+0000805D  B10B              mov cl,0xb							; Put the value 11 in cl so we can compare an 11-byte filename
+0000805F  56                push si								; Save si (which contains the number of sectors per cluster)
+00008060  BE707D            mov si,NTLDR ;0x7d70				; Check and see if "NTLDR" is the first file entry
+00008063  F3A6              repe cmpsb							; Do the compare
+00008065  5E                pop si								; Restore sectors per cluster into si
+00008066  741B              jz ntldr_found						; If we found it then continue, else check next entry
+00008068  03F9              add di,cx							; Add 0 to di? the next entry is 0x15 bytes away
+0000806A  83C715            add di,byte +0x15					; Add 0x15 to di
+0000806D  3BFB              cmp di,bx							; Check to see if we have reached the end of our sector we loaded, read_sectors sets bx = end address of data loaded
+0000806F  72E8              jc check_entry_for_ntldr			; If we haven't reached the end then check the next entry
+00008071  4E                dec si								; decrement si, si holds the number of sectors per cluster
+00008072  75DA              jnz read_directory_sector			; If it's not zero then search the next sector for NTLDR
+00008074  6658              pop eax								; If we got here that means we didn't find NTLDR in the previous root directory cluster, so restore eax with the start cluster
+00008076  E86500            call get_fat_entry					; Get the next cluster in the fat chain
+00008079  72BF              jc search_root_directory_cluster	; If we reached end-of-file marker then don't jump, otherwise continue search
+
+ntldr_not_found:
+0000807B  83C404            add sp,byte +0x4
+0000807E  E955FC            jmp print_ntldr_error_message
+
+ntldr_load_segment_address	dw	0x2000
+
+ntldr_found:
+00008083  83C404            add sp,byte +0x4					; Adjust stack to remove root directory start cluster
+00008086  8B7509            mov si,[di+0x9]						; Put start cluster high word in si
+00008089  8B7D0F            mov di,[di+0xf]						; Put start cluster low word in di
+0000808C  8BC6              mov ax,si							; Put high word in ax
+0000808E  66C1E010          shl eax,0x10						; Shift it into position
+00008092  8BC7              mov ax,di							; Put low word in ax, now eax contains start cluster of NTLDR
+00008094  6683F802          cmp eax,byte +0x2					; Check and see if the start cluster of NTLDR starts at cluster 2 or above
+00008098  0F823AFC          jc near print_ntldr_error_message	; If not exit with error
+0000809C  663DF8FFFF0F      cmp eax,0xffffff8					; Check and see if the start cluster of NTLDR is and end of cluster chain indicator
+000080A2  0F8330FC          jnc near print_ntldr_error_message	; If so exit with error
+
+load_next_ntldr_cluster:
+000080A6  6650              push eax							; Save NTLDR start cluster for later
+000080A8  6683E802          sub eax,byte +0x2					; Adjust it because the first two fat entries are unused so the third entry marks the first data area cluster
+000080AC  660FB64E0D        movzx ecx,byte [bp+SectsPerCluster]	; Put the sectors per cluster into ecx
+000080B1  66F7E1            mul ecx								; Multiply sectors per cluster by the start cluster, we now have the logical start sector
+000080B4  660346FC          add eax,[bp-0x4]					; Add the start of the data area logical sector
+000080B8  BB0000            mov bx,0x0							; Load NTLDR to offset zero
+000080BB  06                push es								; Save es
+000080BC  8E068180          mov es,[ntldr_load_segment_address]	; Get the segment address to load NTLDR to
+000080C0  E81DFC            call read_sectors					; Load the first cluster
+000080C3  07                pop es								; Restore es
+000080C4  6658              pop eax								; Restore eax to NTLDR start cluster
+000080C6  C1EB04            shr bx,0x4							; bx contains the amount of data we transferred, so divide it by 16
+000080C9  011E8180          add [ntldr_load_segment_address],bx	; Add that value to the segment
+000080CD  E80E00            call get_fat_entry					; Get the next cluster in eax
+000080D0  0F830200          jnc near jump_to_ntldr				; If we have reached the end of file then lets get to NTLDR
+000080D4  72D0              jc load_next_ntldr_cluster			; If not, then load another cluster
+
+jump_to_ntldr:
+000080D6  8A5640            mov dl,[bp+BootDrive]				; Put the boot drive in dl
+000080D9  EA00000020        jmp 0x2000:0x0						; Jump to NTLDR
+
+get_fat_entry:
+000080DE  66C1E002          shl eax,0x2							; Multiply cluster by 4
+000080E2  E81100            call load_fat_sector				; Load the fat sector
+000080E5  26668B01          mov eax,[es:bx+di]					; Get the fat entry
+000080E9  6625FFFFFF0F      and eax,0xfffffff					; Mask off the most significant 4 bits
+000080EF  663DF8FFFF0F      cmp eax,0xffffff8					; Compare it to end of file marker to set the flags correctly
+000080F5  C3                ret									; Return to caller
+
+load_fat_sector:
+000080F6  BF007E            mov di,0x7e00						; We will load the fat sector to 0x7e00
+000080F9  660FB74E0B        movzx ecx,word [bp+SectsPerCluster]	; Get the sectors per cluster
+000080FE  6633D2            xor edx,edx							; We will divide (cluster * 4) / sectorspercluster
+00008101  66F7F1            div ecx								; eax is already set before we get to this routine
+00008104  663B46F4          cmp eax,[bp-0xc]					; Compare eax to 0xffffffff (initially, we set this value later)
+00008108  743A              jz load_fat_sector_end				; If it is the same return
+0000810A  668946F4          mov [bp-0xc],eax					; Update that value
+0000810E  6603461C          add eax,[bp+HiddenSectors]			; Add the hidden sectors
+00008112  660FB74E0E        movzx ecx,word [bp+ReservedSectors]	; Add the reserved sectors
+00008117  6603C1            add eax,ecx							; To the hidden sectors + the value we computed earlier
+0000811A  660FB75E28        movzx ebx,word [bp+ExtendedFlags]	; Get extended flags and put into ebx
+0000811F  83E30F            and bx,byte +0xf					; Mask off upper 8 bits
+00008122  7416              jz load_fat_sector_into_memory		; If fat is mirrored then skip fat calcs
+00008124  3A5E10            cmp bl,[bp+NumberOfFats]			; Compare bl to number of fats
+00008127  0F83ABFB          jnc near print_ntldr_error_message	; If bl is bigger than numfats exit with error
+0000812B  52                push dx								; Save dx
+0000812C  668BC8            mov ecx,eax							; Put the current fat sector offset into ecx
+0000812F  668B4624          mov eax,[bp+SectorsPerFatBig]		; Get the number of sectors occupied by one fat
+00008133  66F7E3            mul ebx								; Multiplied by the active fat index
+00008136  6603C1            add eax,ecx							; Add the current fat sector offset
+00008139  5A                pop dx								; Restore dx
+load_fat_sector_into_memory:
+0000813A  52                push dx								; Save dx, what is so important in dx??
+0000813B  8BDF              mov bx,di							; Put 0x7e00 in bx
+0000813D  B90100            mov cx,0x1							; Load one sector
+00008140  E89DFB            call read_sectors					; Perform the read
+00008143  5A                pop dx								; Restore dx
+load_fat_sector_end:
+00008144  8BDA              mov bx,dx							; Put it into bx, what is this value??
+00008146  C3                ret									; Return
+
+
+00008147  0000              add [bx+si],al
+00008149  0000              add [bx+si],al
+0000814B  0000              add [bx+si],al
+0000814D  0000              add [bx+si],al
+0000814F  0000              add [bx+si],al
+00008151  0000              add [bx+si],al
+00008153  0000              add [bx+si],al
+00008155  0000              add [bx+si],al
+00008157  0000              add [bx+si],al
+00008159  0000              add [bx+si],al
+0000815B  0000              add [bx+si],al
+0000815D  0000              add [bx+si],al
+0000815F  0000              add [bx+si],al
+00008161  0000              add [bx+si],al
+00008163  0000              add [bx+si],al
+00008165  0000              add [bx+si],al
+00008167  0000              add [bx+si],al
+00008169  0000              add [bx+si],al
+0000816B  0000              add [bx+si],al
+0000816D  0000              add [bx+si],al
+0000816F  0000              add [bx+si],al
+00008171  0000              add [bx+si],al
+00008173  0000              add [bx+si],al
+00008175  0000              add [bx+si],al
+00008177  0000              add [bx+si],al
+00008179  0000              add [bx+si],al
+0000817B  0000              add [bx+si],al
+0000817D  0000              add [bx+si],al
+0000817F  0000              add [bx+si],al
+00008181  0000              add [bx+si],al
+00008183  0000              add [bx+si],al
+00008185  0000              add [bx+si],al
+00008187  0000              add [bx+si],al
+00008189  0000              add [bx+si],al
+0000818B  0000              add [bx+si],al
+0000818D  0000              add [bx+si],al
+0000818F  0000              add [bx+si],al
+00008191  0000              add [bx+si],al
+00008193  0000              add [bx+si],al
+00008195  0000              add [bx+si],al
+00008197  0000              add [bx+si],al
+00008199  0000              add [bx+si],al
+0000819B  0000              add [bx+si],al
+0000819D  0000              add [bx+si],al
+0000819F  0000              add [bx+si],al
+000081A1  0000              add [bx+si],al
+000081A3  0000              add [bx+si],al
+000081A5  0000              add [bx+si],al
+000081A7  0000              add [bx+si],al
+000081A9  0000              add [bx+si],al
+000081AB  0000              add [bx+si],al
+000081AD  0000              add [bx+si],al
+000081AF  0000              add [bx+si],al
+000081B1  0000              add [bx+si],al
+000081B3  0000              add [bx+si],al
+000081B5  0000              add [bx+si],al
+000081B7  0000              add [bx+si],al
+000081B9  0000              add [bx+si],al
+000081BB  0000              add [bx+si],al
+000081BD  0000              add [bx+si],al
+000081BF  0000              add [bx+si],al
+000081C1  0000              add [bx+si],al
+000081C3  0000              add [bx+si],al
+000081C5  0000              add [bx+si],al
+000081C7  0000              add [bx+si],al
+000081C9  0000              add [bx+si],al
+000081CB  0000              add [bx+si],al
+000081CD  0000              add [bx+si],al
+000081CF  0000              add [bx+si],al
+000081D1  0000              add [bx+si],al
+000081D3  0000              add [bx+si],al
+000081D5  0000              add [bx+si],al
+000081D7  0000              add [bx+si],al
+000081D9  0000              add [bx+si],al
+000081DB  0000              add [bx+si],al
+000081DD  0000              add [bx+si],al
+000081DF  0000              add [bx+si],al
+000081E1  0000              add [bx+si],al
+000081E3  0000              add [bx+si],al
+000081E5  0000              add [bx+si],al
+000081E7  0000              add [bx+si],al
+000081E9  0000              add [bx+si],al
+000081EB  0000              add [bx+si],al
+000081ED  0000              add [bx+si],al
+000081EF  0000              add [bx+si],al
+000081F1  0000              add [bx+si],al
+000081F3  0000              add [bx+si],al
+000081F5  0000              add [bx+si],al
+000081F7  0000              add [bx+si],al
+000081F9  0000              add [bx+si],al
+000081FB  0000              add [bx+si],al
+000081FD  0055AA            add [di-0x56],dl		; We can't forget the infamous boot signature

freeldr/bootsect/wxpfat16.asm

@@ -0,0 +1,249 @@
+
+;
+; The BP register is initialized to 0x7c00, the start of
+; the boot sector. The SP register is initialized to
+; 0x7bf0, leaving 16 bytes of data storage space above
+; the stack.
+;
+; The DWORD that gets stored at 0x7bfc is the logical
+; sector number of the start of the data area.
+;
+; The DWORD that gets stored at 0x7bf8 is ????????
+;
+; The DWORD that gets stored at 0x7bf4 is ????????
+;
+; The DWORD that gets stored at 0x7bf0 is ????????
+;
+
+
+org 7c00h
+
+segment .text
+
+bits 16
+
+start:
+        jmp short main
+        nop
+
+OEMName				db 'MSWIN4.0'
+BytesPerSector		dw 512
+SectsPerCluster		db 1
+ReservedSectors		dw 1
+NumberOfFats		db 2
+MaxRootEntries		dw 0			;512 - Always zero for FAT32 volumes
+TotalSectors		dw 0			;2880 - Always zero for FAT32 volumes
+MediaDescriptor		db 0f8h
+SectorsPerFat		dw 0			;9 - Always zero for FAT32 volumes
+SectorsPerTrack		dw 18
+NumberOfHeads		dw 2
+HiddenSectors		dd 0
+TotalSectorsBig		dd 0
+BootDrive			db 80h
+Reserved			db 0
+ExtendSig			db 29h
+SerialNumber		dd 00000000h
+VolumeLabel			db 'NO NAME    '
+FileSystem			db 'FAT16   '
+
+main:
+00007C3E  33C9              xor cx,cx
+00007C40  8ED1              mov ss,cx					; Setup stack
+00007C42  BCF07B            mov sp,0x7bf0				; Give us 16 bytes (4 dwords) of space above stack
+00007C45  8ED9              mov ds,cx
+00007C47  B80020            mov ax,0x2000
+00007C4A  8EC0              mov es,ax					; Setup ES:0000 == 2000:0000
+00007C4C  FC                cld
+00007C4D  BD007C            mov bp,0x7c00
+00007C50  384E24            cmp [bp+BootDrive],cl		; Compare the boot drive to zero (I think they are testing for a hard disk drive number)
+00007C53  7D24              jnl floppy_boot				; Nope, it's a floppy, skip partition table tests
+00007C55  8BC1              mov ax,cx					; Move zero to AX
+00007C57  99                cwd							; DX:AX now contains zero
+00007C58  E83C01            call read_one_sector		; Try to read in the MBR sector
+00007C5B  721C              jc floppy_boot				; Read failed, continue
+00007C5D  83EB3A            sub bx,byte +0x3a			; BX comes back with 512, make it equal to 454 (offset of partition table in MBR)
+00007C60  66A11C7C          mov eax,[HiddenSectors]		; Put HiddenSectors in EAX
+find_our_partition:
+00007C64  26663B07          cmp eax,[es:bx]				; Compare partition table entry's start sector to HiddenSectors
+00007C68  268A57FC          mov dl,[es:bx-0x4]			; Get partition type byte for this entry
+00007C6C  7506              jnz next_partition_entry	; If partition start sector != HiddenSectors then skip this entry
+00007C6E  80CA02            or dl,0x2					; Set the second bit in partition type?? I guess this makes types 4 & 6 identical
+00007C71  885602            mov [bp+0x2],dl				; Save it on top of nop instruction (3rd byte of boot sector)
+next_partition_entry:
+00007C74  80C310            add bl,0x10					; Add 16 to bl (offset of next entry in partition table)
+00007C77  73EB              jnc find_our_partition		; Jump back until we hit the end of the partition table
+
+; We now have our partition type at 0000:7C02
+; If the type was 4 or 6 then that byte is 6
+; I can't imagine why the boot sector needs to store
+; this information, but hopefully I will uncover it
+; as I further disassemble this boot sector.
+
+
+floppy_boot:
+00007C79  33C9              xor cx,cx					; Zero out CX
+00007C7B  8A4610            mov al,[bp+NumberOfFats]	; Get the number of FATs in AL (usually 2)
+00007C7E  98                cbw							; Sign extend it into AX (AX == 2)
+00007C7F  F76616            mul word [bp+NumberOfFats]	; Multiply it with NumberOfFats PLUS the low byte of MaxRootEntries!!??
+00007C82  03461C            add ax,[bp+HiddenSectors]	; Result is in DX:AX
+00007C85  13561E            adc dx,[bp+HiddenSectors+2]	; Add HiddenSectors to DX:AX
+00007C88  03460E            add ax,[bp+ReservedSectors]	; Add ReservedSectors to DX:AX
+00007C8B  13D1              adc dx,cx					; CX still contains zero
+00007C8D  8B7611            mov si,[bp+MaxRootEntries]	; Get MaxRootEntries in SI
+00007C90  60                pusha						; Save all registers (right now DX:AX has starting sector of root dir)
+00007C91  8946FC            mov [bp-0x4],ax				; Save the starting sector of the root directory
+00007C94  8956FE            mov [bp-0x2],dx				; Save it in the first 4 bytes before the boot sector
+00007C97  B82000            mov ax,0x20					; AX == 32 (size of a directory entry)
+00007C9A  F7E6              mul si						; Multiply it with MaxRootEntries (DX:AX == length in bytes of root directory)
+00007C9C  8B5E0B            mov bx,[bp+BytesPerSector]	; Get the BytesPerSector in BX
+00007C9F  03C3              add ax,bx					; Add it to AX (what if this addition carries? MS should 'adc dx,0' shouldn't they?)
+00007CA1  48                dec ax						; Subtract one (basically rounding up)
+00007CA2  F7F3              div bx						; Divide DX:AX (length of root dir in bytes) by the size of a sector
+00007CA4  0146FC            add [bp-0x4],ax				; Add the number of sectors of the root directory to our other value
+00007CA7  114EFE            adc [bp-0x2],cx				; Now the first 4 bytes before the boot sector contain the starting sector of the data area
+00007CAA  61                popa						; Restore all registers (DX:AX has start sector of root dir)
+load_root_dir_sector:
+00007CAB  BF0000            mov di,0x0					; Zero out di
+00007CAE  E8E600            call read_one_sector		; Read the first sector of the root directory
+00007CB1  7239              jc print_disk_error_message	; Read failed, print disk error and reboot
+search_directory:
+00007CB3  26382D            cmp [es:di],ch				; If the first byte of the directory entry is zero then we have reached the end
+00007CB6  7417              jz print_ntldr_error_message; of the directory and NTLDR is not here so reboot
+00007CB8  60                pusha						; Save all registers
+00007CB9  B10B              mov cl,0xb					; Put 11 in cl (length of filename in directory entry)
+00007CBB  BEA17D            mov si,NTLDR				; Put offset of filename string in DS:SI
+00007CBE  F3A6              repe cmpsb					; Compare this directory entry against 'NTLDR      '
+00007CC0  61                popa						; Restore all the registers
+00007CC1  7432              jz found_ntldr				; If we found NTLDR then jump
+00007CC3  4E                dec si						; SI holds MaxRootEntries, subtract one
+00007CC4  7409              jz print_ntldr_error_message; If we are out of root dir entries then reboot
+00007CC6  83C720            add di,byte +0x20			; Increment DI by the size of a directory entry
+00007CC9  3BFB              cmp di,bx					; Compare DI to BX (DI has offset to next dir entry, BX has address of end of directory sector in memory)
+00007CCB  72E6              jc search_directory			; If DI is less than BX loop again
+00007CCD  EBDC              jmp short load_root_dir_sector	; Didn't find NTLDR in this directory sector, try again
+print_ntldr_error_message:
+00007CCF  A0FB7D            mov al,[NTLDR_ERR_offset_from_0x7d00]
+putchars:
+00007CD2  B47D              mov ah,0x7d
+00007CD4  8BF0              mov si,ax
+get_another_char:
+00007CD6  AC                lodsb
+00007CD7  98                cbw
+00007CD8  40                inc ax
+00007CD9  740C              jz print_reboot_message
+00007CDB  48                dec ax
+00007CDC  7413              jz reboot
+00007CDE  B40E              mov ah,0xe
+00007CE0  BB0700            mov bx,0x7
+00007CE3  CD10              int 0x10
+00007CE5  EBEF              jmp short get_another_char
+print_reboot_message:
+00007CE7  A0FD7D            mov al,[RESTART_ERR_offset_from_0x7d00]
+00007CEA  EBE6              jmp short putchars
+print_disk_error_message:
+00007CEC  A0FC7D            mov al,[DISK_ERR_offset_from_0x7d00]
+00007CEF  EBE1              jmp short putchars
+reboot:
+00007CF1  CD16              int 0x16
+00007CF3  CD19              int 0x19
+found_ntldr:
+00007CF5  268B551A          mov dx,[es:di+0x1a]			; Get NTLDR start cluster in DX
+00007CF9  52                push dx						; Save it on the stack
+00007CFA  B001              mov al,0x1					; Read 1 cluster? Or is this one sector?
+00007CFC  BB0000            mov bx,0x0					; ES:BX is the load address (2000:0000)
+00007CFF  E83B00            call read_cluster			; Do the read
+00007D02  72E8              jc print_disk_error_message	; If it failed then reboot
+00007D04  5B                pop bx						; Get the start cluster of NTLDR in BX
+00007D05  8A5624            mov dl,[bp+BootDrive]		; Get boot drive in DL
+00007D08  BE0B7C            mov si,0x7c0b
+00007D0B  8BFC              mov di,sp
+00007D0D  C746F03D7D        mov word [bp-0x10],read_cluster
+00007D12  C746F4297D        mov word [bp-0xc],0x7d29
+00007D17  8CD9              mov cx,ds
+00007D19  894EF2            mov [bp-0xe],cx
+00007D1C  894EF6            mov [bp-0xa],cx
+00007D1F  C606967DCB        mov byte [0x7d96],0xcb
+00007D24  EA03000020        jmp 0x2000:0x3
+00007D29  0FB6C8            movzx cx,al
+00007D2C  668B46F8          mov eax,[bp-0x8]
+00007D30  6603461C          add eax,[bp+HiddenSectors]
+00007D34  668BD0            mov edx,eax
+00007D37  66C1EA10          shr edx,0x10
+00007D3B  EB5E              jmp short 0x7d9b
+read_cluster:
+00007D3D  0FB6C8            movzx cx,al
+00007D40  4A                dec dx
+00007D41  4A                dec dx
+00007D42  8A460D            mov al,[bp+SectsPerCluster]
+00007D45  32E4              xor ah,ah
+00007D47  F7E2              mul dx
+00007D49  0346FC            add ax,[bp-0x4]
+00007D4C  1356FE            adc dx,[bp-0x2]
+00007D4F  EB4A              jmp short 0x7d9b
+
+read_sectors:
+00007D51  52                push dx
+00007D52  50                push ax
+00007D53  06                push es
+00007D54  53                push bx
+00007D55  6A01              push byte +0x1
+00007D57  6A10              push byte +0x10
+00007D59  91                xchg ax,cx
+00007D5A  8B4618            mov ax,[bp+SectorsPerTrack]
+00007D5D  96                xchg ax,si
+00007D5E  92                xchg ax,dx
+00007D5F  33D2              xor dx,dx
+00007D61  F7F6              div si
+00007D63  91                xchg ax,cx
+00007D64  F7F6              div si
+00007D66  42                inc dx
+00007D67  87CA              xchg cx,dx
+00007D69  F7761A            div word [bp+NumberOfHeads]
+00007D6C  8AF2              mov dh,dl
+00007D6E  8AE8              mov ch,al
+00007D70  C0CC02            ror ah,0x2
+00007D73  0ACC              or cl,ah
+00007D75  B80102            mov ax,0x201
+00007D78  807E020E          cmp byte [bp+0x2],0xe
+00007D7C  7504              jnz 0x7d82
+00007D7E  B442              mov ah,0x42
+00007D80  8BF4              mov si,sp
+00007D82  8A5624            mov dl,[bp+BootDrive]
+00007D85  CD13              int 0x13
+00007D87  61                popa
+00007D88  61                popa
+00007D89  720B              jc 0x7d96
+00007D8B  40                inc ax
+00007D8C  7501              jnz 0x7d8f
+00007D8E  42                inc dx
+00007D8F  035E0B            add bx,[bp+BytesPerSector]
+00007D92  49                dec cx
+00007D93  7506              jnz 0x7d9b
+00007D95  F8                clc
+00007D96  C3                ret
+
+read_one_sector:
+00007D97  41                inc cx
+00007D98  BB0000            mov bx,0x0
+00007D9B  60                pusha
+00007D9C  666A00            o32 push byte +0x0
+00007D9F  EBB0              jmp short 0x7d51
+
+
+NTLDR		db 'NTLDR      '
+
+
+NTLDR_ERR	db 0dh,0ah,'NTLDR is missing',0ffh
+DISK_ERR	db 0dh,0ah,'Disk error',0ffh
+RESTART_ERR	db 0dh,0ah,'Press any key to restart',0dh,0ah
+
+filler		times 18	db 0
+
+
+NTLDR_offset_from_0x7d00						db 0
+NTLDR_ERR_offset_from_0x7d00					db 0ach
+DISK_ERR_offset_from_0x7d00						db 0bfh
+RESTART_ERR_offset_from_0x7d00					db 0cch
+
+						dw 0
+						dw 0aa55h

freeldr/fdebug/.cvsignore

@@ -0,0 +1 @@
+*.res

freeldr/fdebug/Makefile

@@ -0,0 +1,49 @@
+#
+#  FreeLoader
+#  Copyright (C) 1999 - 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.
+#
+	
+
+FLAGS = -Wall
+
+OBJS = rs232.o fdebug.o fdebug.res
+
+.PHONY : clean
+
+all: fdebug.exe
+
+fdebug.exe: $(OBJS)
+	@echo ===================================================== LINKING fdebug
+	$(CC) $(FLAGS) -o fdebug.exe $(OBJS) -lgdi32 -lcomdlg32 -Wl,--subsystem,windows
+
+fdebug.res: fdebug.rc resource.h
+	@echo ===================================================== Compiling $*
+	$(WINDRES) -o fdebug.res fdebug.rc -O coff
+
+fdebug.o: fdebug.c rs232.h
+	@echo ===================================================== Compiling $*
+	$(CC) $(FLAGS) -o fdebug.o -c fdebug.c
+
+rs232.o: rs232.c rs232.h
+	@echo ===================================================== Compiling $*
+	$(CC) $(FLAGS) -o rs232.o -c rs232.c
+
+clean:
+	@-$(RM) *.o
+	@-$(RM) *.res
+	@-$(RM) *.exe
+	@echo Clean ALL done.

freeldr/fdebug/fdebug.c

@@ -0,0 +1,554 @@
+// fdebug.cpp : Defines the entry point for the application.
+//
+
+#include <windows.h>
+#include <commdlg.h>
+#include <process.h>
+#include <stdio.h>
+#include <tchar.h>
+
+#include "resource.h"
+#include "rs232.h"
+
+#define MAX_LOADSTRING 100
+
+// Global Variables:
+HINSTANCE	hInst;										// current instance
+TCHAR		szTitle[MAX_LOADSTRING];					// The title bar text
+TCHAR		szWindowClass[MAX_LOADSTRING];				// The title bar text
+HWND		hMainWnd;									// The main window handle
+HWND		hDisplayWnd;								// The window to display the incoming data
+HWND		hEditWnd;									// The edit window to get input from the user
+TCHAR		strComPort[MAX_PATH] = TEXT("COM1");		// The COM port to use
+TCHAR		strBaudRate[MAX_PATH] = TEXT("115200");		// The baud rate to use
+TCHAR		strCaptureFileName[MAX_PATH] = TEXT("");	// The file name to capture to
+BOOL		bConnected = FALSE;							// Tells us if we are currently connected
+BOOL		bCapturing = FALSE;							// Tells us if we are currently capturing data
+BOOL		bLocalEcho = FALSE;							// Tells us if local echo is currently enabled
+HANDLE		hCaptureFile;								// Handle to the capture file
+DWORD		dwThreadId = 0;								// Thread id of RS232 communication thread
+
+// Foward declarations of functions included in this code module:
+ATOM				MyRegisterClass(HINSTANCE hInstance);
+BOOL				InitInstance(HINSTANCE, int);
+LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
+LRESULT CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
+LRESULT CALLBACK	ConnectionDialogProc(HWND, UINT, WPARAM, LPARAM);
+LRESULT CALLBACK	CaptureDialogProc(HWND, UINT, WPARAM, LPARAM);
+VOID				EnableConnectMenuItem(BOOL Enable);
+VOID				EnableDisconnectMenuItem(BOOL Enable);
+VOID				EnableStartCaptureMenuItem(BOOL Enable);
+VOID				EnableStopCaptureMenuItem(BOOL Enable);
+VOID				CheckLocalEchoMenuItem(BOOL Checked);
+VOID				Rs232Thread(VOID* Parameter);
+
+int APIENTRY WinMain(HINSTANCE hInstance,
+                     HINSTANCE hPrevInstance,
+                     LPSTR     lpCmdLine,
+                     int       nCmdShow)
+{
+ 	// TODO: Place code here.
+	MSG msg;
+	HACCEL hAccelTable;
+
+	// Initialize global strings
+	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
+	LoadString(hInstance, IDC_FDEBUG, szWindowClass, MAX_LOADSTRING);
+	MyRegisterClass(hInstance);
+
+	// Perform application initialization:
+	if (!InitInstance (hInstance, nCmdShow)) 
+	{
+		return FALSE;
+	}
+
+	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_FDEBUG);
+
+	// Main message loop:
+	while (GetMessage(&msg, NULL, 0, 0)) 
+	{
+		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
+		{
+			TranslateMessage(&msg);
+			DispatchMessage(&msg);
+		}
+	}
+
+	return msg.wParam;
+}
+
+
+
+//
+//  FUNCTION: MyRegisterClass()
+//
+//  PURPOSE: Registers the window class.
+//
+//  COMMENTS:
+//
+//    This function and its usage is only necessary if you want this code
+//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
+//    function that was added to Windows 95. It is important to call this function
+//    so that the application will get 'well formed' small icons associated
+//    with it.
+//
+ATOM MyRegisterClass(HINSTANCE hInstance)
+{
+	WNDCLASSEX wcex;
+
+	wcex.cbSize = sizeof(WNDCLASSEX); 
+
+	wcex.style			= CS_HREDRAW | CS_VREDRAW;
+	wcex.lpfnWndProc	= (WNDPROC)WndProc;
+	wcex.cbClsExtra		= 0;
+	wcex.cbWndExtra		= 0;
+	wcex.hInstance		= hInstance;
+	wcex.hIcon			= LoadIcon(hInstance, (LPCTSTR)IDI_FDEBUG);
+	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
+	wcex.hbrBackground	= NULL;//(HBRUSH)(COLOR_WINDOW+1);
+	wcex.lpszMenuName	= (LPCSTR)IDC_FDEBUG;
+	wcex.lpszClassName	= szWindowClass;
+	wcex.hIconSm		= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
+
+	return RegisterClassEx(&wcex);
+}
+
+//
+//   FUNCTION: InitInstance(HANDLE, int)
+//
+//   PURPOSE: Saves instance handle and creates main window
+//
+//   COMMENTS:
+//
+//        In this function, we save the instance handle in a global variable and
+//        create and display the main program window.
+//
+BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
+{
+   HWND hWnd;
+
+   hInst = hInstance; // Store instance handle in our global variable
+
+   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
+      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
+
+   if (!hWnd)
+   {
+      return FALSE;
+   }
+
+   hMainWnd = hWnd;
+
+   ShowWindow(hWnd, nCmdShow);
+   UpdateWindow(hWnd);
+
+   return TRUE;
+}
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	int					wmId, wmEvent;
+	PAINTSTRUCT			ps;
+	HDC					hdc;
+	RECT				rc;
+	TCHAR				WndText[MAX_PATH];
+	DWORD				Index;
+	NONCLIENTMETRICS	ncm;
+	HFONT				hFont;
+
+	switch (message) 
+	{
+	case WM_CREATE:
+
+		hEditWnd = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("EDIT"), "", WS_CHILD|WS_VISIBLE|WS_VSCROLL|ES_AUTOHSCROLL|ES_LEFT|ES_MULTILINE, 0, 0, 0, 0, hWnd, NULL, hInst, NULL);
+		hDisplayWnd = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("EDIT"), "", WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_MULTILINE, 0, 0, 0, 0, hWnd, NULL, hInst, NULL);
+
+		memset(&ncm, 0, sizeof(NONCLIENTMETRICS));
+		ncm.cbSize = sizeof(NONCLIENTMETRICS);
+		SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0);
+
+		hFont = CreateFontIndirect(&ncm.lfMessageFont);
+
+		SendMessage(hEditWnd, WM_SETFONT, (WPARAM)hFont, TRUE);
+		SendMessage(hDisplayWnd, WM_SETFONT, (WPARAM)hFont, TRUE);
+
+		break;
+	case WM_COMMAND:
+		wmId    = LOWORD(wParam); 
+		wmEvent = HIWORD(wParam);
+
+		if (lParam == (LPARAM)hEditWnd && wmEvent == EN_CHANGE)
+		{
+			GetWindowText(hEditWnd, WndText, MAX_PATH);
+
+			if (_tcslen(WndText) > 0)
+			{
+				SetWindowText(hEditWnd, TEXT(""));
+
+				if (!bConnected)
+				{
+					MessageBox(hWnd, TEXT("You are not currently connected!"), TEXT("Error"), MB_OK|MB_ICONSTOP);
+					break;
+				}
+
+				for (Index=0; Index<_tcslen(WndText); Index++)
+				{
+					if (dwThreadId != 0)
+					{
+						PostThreadMessage(dwThreadId, WM_CHAR, (WPARAM)WndText[Index], (LPARAM)0);
+					}
+				}
+			}
+		}
+
+		// Parse the menu selections:
+		switch (wmId)
+		{
+		case IDM_ABOUT:
+		   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
+		   break;
+		case IDM_EXIT:
+		   DestroyWindow(hWnd);
+		   break;
+		case ID_FILE_CONNECT:
+			if (bConnected)
+			{
+				MessageBox(hWnd, TEXT("You are already connected!"), TEXT("Error"), MB_OK|MB_ICONSTOP);
+			}
+			else
+			{
+				if (DialogBox(hInst, (LPCTSTR)IDD_CONNECTION, hWnd, (DLGPROC)ConnectionDialogProc) == IDOK)
+				{
+					bConnected = TRUE;
+					EnableDisconnectMenuItem(TRUE);
+					EnableConnectMenuItem(FALSE);
+					_beginthread(Rs232Thread, 0, NULL);
+				}
+			}
+			break;
+		case ID_FILE_DISCONNECT:
+			if (bConnected)
+			{
+				bConnected = FALSE;
+				EnableDisconnectMenuItem(FALSE);
+				EnableConnectMenuItem(TRUE);
+			}
+			else
+			{
+				MessageBox(hWnd, TEXT("You are not currently connected!"), TEXT("Error"), MB_OK|MB_ICONSTOP);
+			}
+			break;
+		case ID_FILE_STARTCAPTURE:
+			if (DialogBox(hInst, (LPCTSTR)IDD_CAPTURE, hWnd, (DLGPROC)CaptureDialogProc) == IDOK)
+			{
+				bCapturing = TRUE;
+				EnableStopCaptureMenuItem(TRUE);
+				EnableStartCaptureMenuItem(FALSE);
+				hCaptureFile = CreateFile(strCaptureFileName, FILE_APPEND_DATA, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+			}
+			break;
+		case ID_FILE_STOPCAPTURE:
+			if (bCapturing)
+			{
+				bCapturing = FALSE;
+				EnableStopCaptureMenuItem(FALSE);
+				EnableStartCaptureMenuItem(TRUE);
+				CloseHandle(hCaptureFile);
+				hCaptureFile = NULL;
+			}
+			break;
+		case ID_FILE_LOCALECHO:
+			if (bLocalEcho)
+			{
+				bLocalEcho = FALSE;
+				CheckLocalEchoMenuItem(bLocalEcho);
+			}
+			else
+			{
+				bLocalEcho = TRUE;
+				CheckLocalEchoMenuItem(bLocalEcho);
+			}
+			break;
+		default:
+		   return DefWindowProc(hWnd, message, wParam, lParam);
+		}
+		break;
+	case WM_PAINT:
+		hdc = BeginPaint(hWnd, &ps);
+		EndPaint(hWnd, &ps);
+		break;
+	case WM_SIZE:
+
+		GetClientRect(hWnd, &rc);
+
+		MoveWindow(hDisplayWnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top - 20, TRUE);
+		MoveWindow(hEditWnd, rc.left, rc.bottom - 20, rc.right - rc.left, 20, TRUE);
+
+		break;
+	case WM_DESTROY:
+		PostQuitMessage(0);
+		break;
+	default:
+		return DefWindowProc(hWnd, message, wParam, lParam);
+   }
+   return 0;
+}
+
+LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HWND	hLicenseEditWnd;
+	TCHAR	strLicense[0x1000];
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		hLicenseEditWnd = GetDlgItem(hDlg, IDC_LICENSE_EDIT);
+
+		LoadString(hInst, IDS_LICENSE, strLicense, 0x1000);
+
+		SetWindowText(hLicenseEditWnd, strLicense);
+
+		return TRUE;
+
+	case WM_COMMAND:
+		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+		break;
+	}
+    return FALSE;
+}
+
+LRESULT CALLBACK ConnectionDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		SetWindowText(GetDlgItem(hDlg, IDC_COMPORT), strComPort);
+		SetWindowText(GetDlgItem(hDlg, IDC_BAUTRATE), strBaudRate);
+
+		return TRUE;
+
+	case WM_COMMAND:
+		if (LOWORD(wParam) == IDOK)
+		{
+			GetWindowText(GetDlgItem(hDlg, IDC_COMPORT), strComPort, MAX_PATH);
+			GetWindowText(GetDlgItem(hDlg, IDC_BAUTRATE), strBaudRate, MAX_PATH);
+		}
+
+		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+		break;
+	}
+    return FALSE;
+}
+
+LRESULT CALLBACK CaptureDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	OPENFILENAME	ofn;
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		SetWindowText(GetDlgItem(hDlg, IDC_CAPTUREFILENAME), strCaptureFileName);
+
+		return TRUE;
+
+	case WM_COMMAND:
+		if (LOWORD(wParam) == IDC_BROWSE)
+		{
+			memset(&ofn, 0, sizeof(OPENFILENAME));
+			ofn.lStructSize = sizeof(OPENFILENAME);
+			ofn.hwndOwner = hDlg;
+			ofn.hInstance = hInst;
+			ofn.lpstrFilter = NULL;
+			ofn.lpstrCustomFilter = NULL;
+			ofn.nMaxCustFilter = 0;
+			ofn.nFilterIndex = 0;
+			ofn.lpstrFile = strCaptureFileName;
+			ofn.nMaxFile = MAX_PATH;
+			ofn.lpstrFileTitle = NULL;
+			ofn.nMaxFileTitle = 0;
+			ofn.lpstrInitialDir = NULL;
+			ofn.lpstrTitle = NULL;
+			ofn.Flags = OFN_HIDEREADONLY|OFN_NOREADONLYRETURN;
+
+			if (GetOpenFileName(&ofn))
+			{
+				SetWindowText(GetDlgItem(hDlg, IDC_CAPTUREFILENAME), strCaptureFileName);
+			}
+		}
+
+		if (LOWORD(wParam) == IDOK)
+		{
+			GetWindowText(GetDlgItem(hDlg, IDC_CAPTUREFILENAME), strCaptureFileName, MAX_PATH);
+		}
+
+		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+		break;
+	}
+    return FALSE;
+}
+
+VOID EnableConnectMenuItem(BOOL Enable)
+{
+	HMENU	hMenuBar;
+	HMENU	hFileMenu;
+
+	hMenuBar = GetMenu(hMainWnd);
+	hFileMenu = GetSubMenu(hMenuBar, 0);
+
+	if (Enable)
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_CONNECT, MF_BYCOMMAND|MF_ENABLED);
+	}
+	else
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_CONNECT, MF_BYCOMMAND|MF_GRAYED);
+	}
+}
+
+VOID EnableDisconnectMenuItem(BOOL Enable)
+{
+	HMENU	hMenuBar;
+	HMENU	hFileMenu;
+
+	hMenuBar = GetMenu(hMainWnd);
+	hFileMenu = GetSubMenu(hMenuBar, 0);
+
+	if (Enable)
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_DISCONNECT, MF_BYCOMMAND|MF_ENABLED);
+	}
+	else
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_DISCONNECT, MF_BYCOMMAND|MF_GRAYED);
+	}
+}
+
+VOID EnableStartCaptureMenuItem(BOOL Enable)
+{
+	HMENU	hMenuBar;
+	HMENU	hFileMenu;
+
+	hMenuBar = GetMenu(hMainWnd);
+	hFileMenu = GetSubMenu(hMenuBar, 0);
+
+	if (Enable)
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_STARTCAPTURE, MF_BYCOMMAND|MF_ENABLED);
+	}
+	else
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_STARTCAPTURE, MF_BYCOMMAND|MF_GRAYED);
+	}
+}
+
+VOID EnableStopCaptureMenuItem(BOOL Enable)
+{
+	HMENU	hMenuBar;
+	HMENU	hFileMenu;
+
+	hMenuBar = GetMenu(hMainWnd);
+	hFileMenu = GetSubMenu(hMenuBar, 0);
+
+	if (Enable)
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_STOPCAPTURE, MF_BYCOMMAND|MF_ENABLED);
+	}
+	else
+	{
+		EnableMenuItem(hFileMenu, ID_FILE_STOPCAPTURE, MF_BYCOMMAND|MF_GRAYED);
+	}
+}
+
+VOID CheckLocalEchoMenuItem(BOOL Checked)
+{
+	HMENU	hMenuBar;
+	HMENU	hFileMenu;
+
+	hMenuBar = GetMenu(hMainWnd);
+	hFileMenu = GetSubMenu(hMenuBar, 0);
+
+	if (Checked)
+	{
+		CheckMenuItem(hFileMenu, ID_FILE_LOCALECHO, MF_BYCOMMAND|MF_CHECKED);
+	}
+	else
+	{
+		CheckMenuItem(hFileMenu, ID_FILE_LOCALECHO, MF_BYCOMMAND|MF_UNCHECKED);
+	}
+}
+
+VOID Rs232Thread(VOID* Parameter)
+{
+	BYTE	Byte;
+	TCHAR	String[MAX_PATH];
+	MSG		msg;
+	DWORD	dwNumberOfBytesWritten;
+
+	dwThreadId = GetCurrentThreadId();
+
+	if (!Rs232OpenPortWin32(strComPort))
+	{
+		MessageBox(hMainWnd, TEXT("Error opening port!"), TEXT("Error"), MB_OK|MB_ICONSTOP);
+		bConnected = FALSE;
+		return;
+	}
+
+	_stprintf(String, TEXT("%s,n,8,1"), strBaudRate);
+	if (!Rs232ConfigurePortWin32(String))
+	{
+		MessageBox(hMainWnd, TEXT("Error configuring port!"), TEXT("Error"), MB_OK|MB_ICONSTOP);
+		bConnected = FALSE;
+		return;
+	}
+
+	while (bConnected)
+	{
+		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+		{
+			if (msg.message == WM_CHAR)
+			{
+				Rs232WriteByteWin32((BYTE)msg.wParam);
+
+				if (bLocalEcho && msg.wParam != (WPARAM)TEXT('\r'))
+				{
+					PostMessage(hDisplayWnd, WM_CHAR, (WPARAM)msg.wParam, (LPARAM)0);
+
+					if (hCaptureFile)
+					{
+						WriteFile(hCaptureFile, &msg.wParam, sizeof(TCHAR), &dwNumberOfBytesWritten, NULL);
+					}
+				}
+			}
+		}
+
+		if (Rs232ReadByteWin32(&Byte))
+		{
+			_stprintf(String, TEXT("%c"), Byte);
+
+			PostMessage(hDisplayWnd, WM_CHAR, (WPARAM)String[0], (LPARAM)0);
+
+			if (hCaptureFile)
+			{
+				WriteFile(hCaptureFile, &String[0], sizeof(TCHAR), &dwNumberOfBytesWritten, NULL);
+			}
+		}
+	}
+
+	dwThreadId = 0;
+	Rs232ClosePortWin32();
+}

freeldr/fdebug/fdebug.rc

@@ -0,0 +1,215 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+#include "resource.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_FDEBUG              ICON    DISCARDABLE     "fdebug.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDC_FDEBUG MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Connect",                    ID_FILE_CONNECT
+        MENUITEM "&Disconnect",                 ID_FILE_DISCONNECT, GRAYED
+        MENUITEM SEPARATOR
+        MENUITEM "&Start Capture",              ID_FILE_STARTCAPTURE
+        MENUITEM "S&top Capture",               ID_FILE_STOPCAPTURE, GRAYED
+        MENUITEM SEPARATOR
+        MENUITEM "&Local Echo",                 ID_FILE_LOCALECHO
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       IDM_EXIT
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&About ...",                  IDM_ABOUT
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDC_FDEBUG ACCELERATORS MOVEABLE PURE 
+BEGIN
+    "?",            IDM_ABOUT,              ASCII,  ALT
+    "/",            IDM_ABOUT,              ASCII,  ALT
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""windows.h""\r\n"
+    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""resource.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_ABOUTBOX, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 252
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 203
+    END
+
+    IDD_CONNECTION, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 189
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 93
+    END
+
+    IDD_CAPTURE, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 244
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 88
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_ABOUTBOX DIALOG DISCARDABLE  22, 17, 259, 210
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About FreeLoader Debugger"
+FONT 8, "Tahoma"
+BEGIN
+    CONTROL         "FreeLoader Debugger v1.0\nCopyright (C) 2003\nby Brian Palmer (brianp@reactos.org)",
+                    IDC_STATIC,"Static",SS_LEFTNOWORDWRAP | WS_GROUP,53,28,
+                    122,26
+    DEFPUSHBUTTON   "OK",IDOK,183,189,44,14,WS_GROUP
+    ICON            IDI_FDEBUG,IDC_STATIC,19,30,20,20
+    EDITTEXT        IDC_LICENSE_EDIT,53,63,174,107,ES_MULTILINE | 
+                    ES_READONLY | WS_VSCROLL
+END
+
+IDD_CONNECTION DIALOG DISCARDABLE  0, 0, 196, 100
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Connection Options"
+FONT 8, "Tahoma"
+BEGIN
+    LTEXT           "Enter the COM port (e.g. COM1):",IDC_STATIC,7,7,108,8
+    EDITTEXT        IDC_COMPORT,7,17,182,14,ES_AUTOHSCROLL
+    LTEXT           "Enter the baud rate (e.g. 115200):",IDC_STATIC,7,38,114,
+                    8
+    EDITTEXT        IDC_BAUTRATE,7,48,182,14,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,45,79,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,100,79,50,14
+END
+
+IDD_CAPTURE DIALOG DISCARDABLE  0, 0, 251, 95
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Capture File"
+FONT 8, "Tahoma"
+BEGIN
+    LTEXT           "Capture File Name:",IDC_STATIC,7,17,62,8
+    EDITTEXT        IDC_CAPTUREFILENAME,7,26,181,14,ES_AUTOHSCROLL
+    PUSHBUTTON      "&Browse",IDC_BROWSE,194,26,50,14
+    DEFPUSHBUTTON   "OK",IDOK,139,74,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,194,74,50,14
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_APP_TITLE           "fdebug"
+    IDS_HELLO               "Hello World!"
+    IDC_FDEBUG              "FDEBUG"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_LICENSE             "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.\r\n\r\nThis 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.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA."
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

freeldr/fdebug/resource.h

@@ -0,0 +1,40 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by fdebug.rc
+//
+#define IDC_MYICON                      2
+#define IDD_FDEBUG_DIALOG               102
+#define IDD_ABOUTBOX                    103
+#define IDS_APP_TITLE                   103
+#define IDM_ABOUT                       104
+#define IDM_EXIT                        105
+#define IDS_HELLO                       106
+#define IDI_FDEBUG                      107
+#define IDI_SMALL                       108
+#define IDC_FDEBUG                      109
+#define IDR_MAINFRAME                   128
+#define IDD_CONNECTION                  130
+#define IDD_CAPTURE                     131
+#define IDC_COMPORT                     1000
+#define IDC_BAUTRATE                    1001
+#define IDC_CAPTUREFILENAME             1002
+#define IDC_BROWSE                      1003
+#define IDC_LICENSE_EDIT                1029
+#define ID_FILE_CONNECT                 32771
+#define ID_FILE_DISCONNECT              32772
+#define ID_FILE_STARTCAPTURE            32773
+#define ID_FILE_STOPCAPTURE             32774
+#define ID_FILE_LOCALECHO               32775
+#define IDS_LICENSE                     32815
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        132
+#define _APS_NEXT_COMMAND_VALUE         32776
+#define _APS_NEXT_CONTROL_VALUE         1004
+#define _APS_NEXT_SYMED_VALUE           110
+#endif
+#endif

freeldr/fdebug/rs232.c

@@ -0,0 +1,257 @@
+/*
+ *  FreeLoader - rs232.c
+ *
+ *  Copyright (C) 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 <windows.h>
+#include <winioctl.h>
+#include <tchar.h>
+#include <stdio.h>
+
+#include "rs232.h"
+
+
+HANDLE	hPortHandle = NULL;
+
+
+BOOL Rs232OpenPortWin32(TCHAR* CommPort)
+{
+	TCHAR	PortName[MAX_PATH];
+	DWORD	ErrorCode;
+
+	// First check and make sure they don't already have the
+	// OBD2 connection open. We don't want to open things twice.
+	if (hPortHandle != NULL)
+	{
+		_tprintf(TEXT("Port handle not NULL. Must be already open. Returning FALSE...\n"));
+		return FALSE;
+	}
+
+	_stprintf(PortName, TEXT("\\\\.\\%s"), CommPort);
+
+	hPortHandle = CreateFile(PortName,
+							GENERIC_READ|GENERIC_WRITE,
+							0,
+							0,
+							OPEN_EXISTING,
+							0,
+							0);
+
+	if (hPortHandle == INVALID_HANDLE_VALUE)
+	{
+		hPortHandle = NULL;
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("CreateFile(\"%s\") failed. GetLastError() = %lu.\n"), PortName, ErrorCode);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+BOOL Rs232ClosePortWin32(VOID)
+{
+	HANDLE	hTempPortHandle = hPortHandle;
+
+	hPortHandle = NULL;
+
+	if (hTempPortHandle == NULL)
+	{
+		return FALSE;
+	}
+
+	return CloseHandle(hTempPortHandle);
+}
+
+// DeviceControlString
+//   [in] Pointer to a null-terminated string that specifies device-control information.
+//   The string must have the same form as the mode command's command-line arguments.
+//
+//   For example, the following string specifies a baud rate of 1200, no parity, 8 data bits, and 1 stop bit: 
+//   "baud=1200 parity=N data=8 stop=1"
+//
+//   The following string specifies a baud rate of 115200, no parity, 8 data bits, and 1 stop bit:
+//   "115200,n,8,1"
+//
+//   The device name is ignored if it is included in the string, but it must specify a valid device, as follows: 
+//   "COM1: baud=1200 parity=N data=8 stop=1"
+//
+//   For further information on mode command syntax, refer to the end-user documentation for your operating system. 
+BOOL Rs232ConfigurePortWin32(TCHAR* DeviceControlString)
+{
+	DCB		dcb;
+	DWORD	ErrorCode;
+
+	/*if (!GetCommState(hPortHandle, &dcb))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("GetCommState() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	dcb.BaudRate = BaudRate;
+	dcb.ByteSize = DataBits;
+	dcb.Parity = Parity;
+	dcb.StopBits = StopBits;
+	dcb.fBinary = TRUE;
+	dcb.fDsrSensitivity = FALSE;
+	dcb.fParity = (Parity == NOPARITY) ? FALSE : TRUE;
+	dcb.fOutX = FALSE;
+	dcb.fInX = FALSE;
+	dcb.fNull = FALSE;
+	dcb.fAbortOnError = TRUE;
+	dcb.fOutxCtsFlow = FALSE;
+	dcb.fOutxDsrFlow = FALSE;
+	dcb.fDtrControl = DTR_CONTROL_DISABLE;
+	dcb.fDsrSensitivity = FALSE;
+	dcb.fRtsControl = RTS_CONTROL_DISABLE;
+	dcb.fOutxCtsFlow = FALSE;
+	dcb.fOutxCtsFlow = FALSE;*/
+
+
+	memset(&dcb, 0, sizeof(DCB));
+	dcb.DCBlength = sizeof(dcb);
+	if (!BuildCommDCB(DeviceControlString, &dcb))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("BuildCommDCB() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	if (!SetCommState(hPortHandle, &dcb))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("SetCommState() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	// Set the timeouts
+	if (!Rs232SetCommunicationTimeoutsWin32(MAXDWORD, 0, 0, 0, 0))
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+// Members
+//  ReadIntervalTimeout 
+//   Specifies the maximum time, in milliseconds, allowed to elapse between the arrival of two characters on the communications line. During a ReadFile operation, the time period begins when the first character is received. If the interval between the arrival of any two characters exceeds this amount, the ReadFile operation is completed and any buffered data is returned. A value of zero indicates that interval time-outs are not used. 
+//   A value of MAXDWORD, combined with zero values for both the ReadTotalTimeoutConstant and ReadTotalTimeoutMultiplier members, specifies that the read operation is to return immediately with the characters that have already been received, even if no characters have been received. 
+// 
+//  ReadTotalTimeoutMultiplier 
+//   Specifies the multiplier, in milliseconds, used to calculate the total time-out period for read operations. For each read operation, this value is multiplied by the requested number of bytes to be read. 
+//  ReadTotalTimeoutConstant 
+//   Specifies the constant, in milliseconds, used to calculate the total time-out period for read operations. For each read operation, this value is added to the product of the ReadTotalTimeoutMultiplier member and the requested number of bytes. 
+//   A value of zero for both the ReadTotalTimeoutMultiplier and ReadTotalTimeoutConstant members indicates that total time-outs are not used for read operations. 
+// 
+//  WriteTotalTimeoutMultiplier 
+//   Specifies the multiplier, in milliseconds, used to calculate the total time-out period for write operations. For each write operation, this value is multiplied by the number of bytes to be written. 
+//  WriteTotalTimeoutConstant 
+//   Specifies the constant, in milliseconds, used to calculate the total time-out period for write operations. For each write operation, this value is added to the product of the WriteTotalTimeoutMultiplier member and the number of bytes to be written. 
+//   A value of zero for both the WriteTotalTimeoutMultiplier and WriteTotalTimeoutConstant members indicates that total time-outs are not used for write operations. 
+// 
+// Remarks
+//  If an application sets ReadIntervalTimeout and ReadTotalTimeoutMultiplier to MAXDWORD and sets ReadTotalTimeoutConstant to a value greater than zero and less than MAXDWORD, one of the following occurs when the ReadFile function is called: 
+// 
+//   If there are any characters in the input buffer, ReadFile returns immediately with the characters in the buffer. 
+//   If there are no characters in the input buffer, ReadFile waits until a character arrives and then returns immediately. 
+//   If no character arrives within the time specified by ReadTotalTimeoutConstant, ReadFile times out. 
+BOOL Rs232SetCommunicationTimeoutsWin32(DWORD ReadIntervalTimeout, DWORD ReadTotalTimeoutMultiplier, DWORD ReadTotalTimeoutConstant, DWORD WriteTotalTimeoutMultiplier, DWORD WriteTotalTimeoutConstant)
+{
+	COMMTIMEOUTS	ct;
+	DWORD			ErrorCode;
+
+	if (!GetCommTimeouts(hPortHandle, &ct))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("GetCommTimeouts() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	ct.ReadIntervalTimeout = ReadIntervalTimeout;
+	ct.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant;
+	ct.ReadTotalTimeoutMultiplier = ReadTotalTimeoutMultiplier;
+	ct.WriteTotalTimeoutConstant = WriteTotalTimeoutConstant;
+	ct.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier;
+
+	if (!SetCommTimeouts(hPortHandle, &ct))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("SetCommTimeouts() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+BOOL Rs232ReadByteWin32(BYTE* DataByte)
+{
+	DWORD	BytesRead = 0;
+	DWORD	ErrorCode;
+
+	// If ReadFile() fails then report error
+	if (!ReadFile(hPortHandle, DataByte, 1, &BytesRead, NULL))
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("ReadFile() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	// If ReadFile() succeeds, but BytesRead isn't 1
+	// then a timeout occurred.
+	if (BytesRead != 1)
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+BOOL Rs232WriteByteWin32(BYTE DataByte)
+{
+	DWORD	BytesWritten = 0;
+	BOOL	Success;
+	DWORD	ErrorCode;
+
+	Success = WriteFile(hPortHandle, &DataByte, 1, &BytesWritten, NULL);
+
+	if (!Success || BytesWritten != 1)
+	{
+		ErrorCode = GetLastError();
+
+		_tprintf(TEXT("WriteFile() failed. GetLastError() = %lu.\n"), ErrorCode);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}

freeldr/fdebug/rs232.h

@@ -0,0 +1,46 @@
+/*
+ *  FreeLoader - rs232.h
+ *
+ *  Copyright (C) 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.
+ */
+
+
+#ifndef __RS232_H
+#define __RS232_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+// Function prototypes for RS232 communication under Win32
+//
+//////////////////////////////////////////////////////////////////////////////////////////
+BOOL	Rs232OpenPortWin32(TCHAR* CommPort);
+BOOL	Rs232ClosePortWin32(VOID);
+BOOL	Rs232ConfigurePortWin32(TCHAR* DeviceControlString);
+BOOL	Rs232SetCommunicationTimeoutsWin32(DWORD ReadIntervalTimeout, DWORD ReadTotalTimeoutMultiplier, DWORD ReadTotalTimeoutConstant, DWORD WriteTotalTimeoutMultiplier, DWORD WriteTotalTimeoutConstant);
+BOOL	Rs232ReadByteWin32(BYTE* DataByte);
+BOOL	Rs232WriteByteWin32(BYTE DataByte);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif // !defined(__RS232_H)

freeldr/freeldr/.cvsignore

@@ -0,0 +1 @@
+obj

freeldr/freeldr/CHANGELOG

@@ -0,0 +1,331 @@
+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.
+- Adjusted detection timeouts for PS/2 and RS232 to the minimum
+  allowed by the specifications.
+- Enabled the 'Press any key to boot from CD' message in the ISO 
+  boot code and show it only when some hard disk is present.
+
+Changes in v1.8.20 (21/05/2004) (navaraf)
+
+- Added support for special value "LiveCD" of SystemPath option
+  for loading ReactOS. It uses the known boot drive information
+  as the boot path.
+
+Changes in v1.8.19 (12/20/2003) (ekohl)
+
+- Detect PS/2 Port and Pointer Device (Mouse).
+- Calculate CPU speed.
+- Fixed delay counter overrun.
+
+Changes in v1.8.18 (12/14/2003) (ekohl)
+
+- Detect serial ports and serial pointer devices (Mice/Trackballs)
+
+Changes in v1.8.17 (10/19/2003) (ekohl)
+
+- Ignore case of registry key and value names
+
+Changes in v1.8.16 (10/12/2003) (ekohl)
+
+- Renamed a lot of variables and functions in the registry
+- Fixed buggy cell size calculation
+
+Changes in v1.8.15 (8/29/2003) (chorns)
+
+- Add top-level makefile
+- Add fdebug/.cvsignore
+- Don't use rdel to remove files in tools/Makefile
+- Remove warning in freeldr/mm/meminit.c
+
+Changes in v1.8.14 (8/10/2003) (chorns)
+
+- Clear screen to black when booting ReactOS
+
+Changes in v1.8.13 (6/05/2003) (brianp)
+
+- Added support for booting Linux 2.4.x kernels
+- i386 exception handler now reports FreeLoader version number
+
+Changes in v1.8.12 (5/25/2003) (ekohl)
+
+- Added .inf-file parser
+- SetupLdr loads and uses txtsetup.sif
+- Removed .hiv (text-hive) parser
+
+Changes in v1.8.11 (4/30/2003) (ekohl)
+
+- Added DiskGetExtendedDriveParameters()
+- Moved hardware detection into the arch directory
+- Rewrote/completed harddisk detection
+- Removed PCI and IDE detection
+- Added basic CPU detection
+
+Changes in v1.8.10 (4/27/2003) (chorns)
+
+- Query BIOS for supported disk drives
+
+Changes in v1.8.9 (4/25/2003) (chorns)
+
+- Detect PCI busses
+- Detect IDE controllers and devices
+- Improved RegEnumValue()
+
+Changes in v1.8.8 (4/25/2003) (ekohl)
+
+- Added memmove().
+- Added hardware hive export.
+
+Changes in v1.8.7 (4/22/2003) (brianp)
+
+- Added a file system recognizer to get around problems where
+  the partition id did not match the file system type.
+
+Changes in v1.8.6 (4/14/2003) (brianp)
+
+- Fixed a bug in fathelp.asm where is wasn't adding the hidden sector
+  count before performing a subtraction.
+
+Changes in v1.8.5 (4/10/2003) (ekohl)
+
+- Added support for binary system hive.
+
+Changes in v1.8.4 (4/5/2003) (chorns)
+
+- Added DOS compatible Master Boot Record (MBR)
+
+Changes in v1.8.3 (3/18/2003) (brianp)
+
+- Added _alloca() function because Mingw32 generates code that needs it
+- Defined _mainCRTStartup in fathelp.asm because Mingw32 looks for that symbol
+
+Changes in v1.8.2 (1/24/2003) (ekohl)
+
+- Relaxed check for Int13-Extension support.
+  Some BIOSes have a strange opinion about what is supported. :-/
+
+Changes in v1.8.1 (1/20/2003) (ekohl)
+
+- Fixed the ISO filesystem detection code.
+- Removed IsSetupLdr.
+
+Changes in v1.8 (1/18/2003) (brianp)
+
+- Added F8 options menu
+- Added custom Boot functionality
+- Moved all OS= settings from [FreeLoader] section to [Operating Systems] section.
+- Removed MessageLine= setting. MessageBox= now accepts "\n" as an escape character for newlines.
+- Added descriptions for disk error codes returned by the BIOS.
+- Device names like "fd0" and "hd0" and "hd1" as well as BIOS drive numbers can now be used as BootDrive= settings.
+
+Changes in v1.7.12 (12/05/2002) (brianp)
+
+- Minor tweak to UI code to allow description
+  text to be displayed along with the progress
+  bar.
+
+Changes in v1.7.11 (12/05/2002) (brianp)
+
+- Added memory map count to GetBiosMemoryMap() so that
+  it doesn't just assume the size of the array.
+- Fix so that we use the continuation value that
+  the BIOS returns.
+
+Changes in v1.7.10 (11/24/2002) (brianp)
+
+- Added assembler versions of memcmp() memcpy() memset()
+- Implemented Int386() so that real-mode interrupts can be called from C-code
+- Removed unnecessary call in DbgPrint() macro (freeldr.sys is ~16k smaller now)
+- 64-bit lba sector addressing for disk calls
+- Re-coded biosdisk.S as i386disk.c
+- Re-coded mem.S as i386mem.c
+- Re-coded rtlcode.S as i386rtl.c
+- Cleaned up i386trap.S so that it only saves the registers once.
+- Re-coded biosvid.S as i386vid.c
+- Video fade in/out
+- VESA text modes supported now
+- Offscreen buffering to remove flicker
+- Standardized format of boot sector so that BootPartition is stored right before 0xaa55
+- Prefixed all file system functions with 'Fs'
+
+Changes in v1.7.9 (9/30/2002) (brianp)
+
+- Fix for bug in BiosInt13ReadExtended() (biosdisk.S)
+  by Christophe Bothamy & Mike Lerwill
+
+Changes in v1.7.8 (9/7/2002) (ekohl)
+
+- Added new 'bootcd' target.
+- Removed/disabled debugging code.
+- SetupLdr must not call BiosInt13ExtensionsSupported to check
+  extended int13 capabilities because they are already used to
+  boot a CD and some BIOSes return incorrect results when a CD-ROM
+  drive is checked.
+
+Changes in v1.7.7 (9/5/2002) (ekohl)
+
+- fs/iso.c: Got iso-fs working again.
+- reactos/setupldr.c: Implemented very simple setup loader.
+
+Changes in v1.7.6 (8/31/2002) (ekohl)
+
+- bootsect/isoboot.asm: Reduced read transfer size to ensure that
+  the read buffer for an int13/ah=42h (exended read) does not
+  cross a segment boundary.
+- freeldr.c, bootmgr.c, setupldr.c, makefile: Renamed
+  LoadBootManager() and ReactOSRunSetupLoader() to RunLoader().
+  Either bootmgr.o or setupldr.o is used to build freeldr.sys or
+  setupldr.sys  
+
+Changes in v1.7.5 (8/21/2002) (brianp)
+
+- biosvid.S (BiosVideoDisableBlinkBit): Added code to
+  disable the blink bit in the text mode character
+  attribute byte so that the full range of
+  background colors can be used.
+
+Changes in v1.7.4 (8/20/2002) (brianp)
+
+- Boot sector code now reports to freeldr.sys the partition
+  that it was installed on. This is specified by a byte
+  value in the boot sector code. By default the boot partition
+  is set to zero which indicates the active (bootable)
+  partition, unless the installer sets the value to non-zero.
+  If FreeLoader is installed on a partition other than
+  the active (bootable) partition then the installer must
+  set this byte to that partition number. Otherwise
+  FreeLoader will not be able to find freeldr.ini.
+- i386trap.S: Added debug macros BREAKPOINT(),
+  INSTRUCTION_BREAKPOINTX(), MEMORY_READWRITE_BREAKPOINTX(), &
+  MEMORY_WRITE_BREAKPOINTX().
+- partition.c (DiskGetPartitionEntry): Add the relative offset
+  of the extended partition to the partitions start sector.
+- ext2.c (Ext2ReadBlockPointerList, Ext2CopyIndirectBlockPointers,
+  Ext2CopyDoubleIndirectBlockPointers, Ext2CopyTripleIndirectBlockPointers):
+  Rewrote the block pointer functions so they actually work.
+- ini_init.c (IniFileInitialize, IniOpenIniFile): Looks for freeldr.ini
+  on both the active (bootable) partition and the partition
+  passed in from the boot sector code.
+- meminit.c (MmInitializeMemoryManager, MmFixupSystemMemoryMap,
+  MmGetEndAddressOfAnyMemory, MmGetAddressablePageCountIncludingHoles,
+  MmInitPageLookupTable): Fixed bug that would cause FreeLoader to
+  have an off-by-one error when accessing the last entry in the
+  page lookup table on systems with 4GB of memory (or memory mapped
+  at the end of the address space).
+
+Changes in v1.7.2 (8/7/2002) (brianp)
+
+- Fragment size must be equal to the block size
+
+Changes in v1.7.1 (8/7/2002) (brianp)
+
+- Symbolic links on EXT2/3 are now supported
+
+Changes in v1.7 (8/6/2002) (brianp)
+
+- EXT2/EXT3 file system support.
+- Does not yet support symbolic links or booting from an EXT2/3 partition.
+- Fixed bug in UI code.
+- Added '%%' format specifier to printf()-like functions.
+- Added functions __udivdi3 & __umoddi3 so that 64-bit division is now supported.
+- Changed types BYTE, WORD, DWORD, LONG, ULONG to U8, U16, U32, S32, U32
+  so that you know the size of the variable across different
+  architectures with different sized words & dwords, etc.
+- Types CHAR, UCHAR, PCHAR, PUCHAR, WCHAR, PWCHAR have not been
+  changed yet (I haven't decided exactly how I'm going to handle unicode)
+
+Changes in v1.6.2 (7/28/2002) (brianp)
+
+- Fix for GetFatEntry16 bug (fathelp.asm) by Mike Lerwill
+
+Changes in v1.6.1 (7/22/2002) (brianp)
+
+- Fix for disk caching while doing drive remapping
+
+Changes in v1.6 (7/21/2002) (brianp)
+
+- Added BIOS drive mapping functionality
+
+Changes in v1.5 (7/13/2002)
+
+- If symbols are available then pass them to the OS as multiboot modules
+
+Changes in v1.4 (6/27/2002)
+
+- Added separate configuration for a SETUPLDR version
+
+Changes in v1.3.1 (6/8/2002)
+
+- Implemented MmAllocateMemoryAtAddress()
+- Fixed Linux boot code to go through the memory manager to allocate memory at 1MB
+
+Changes in v1.3 (6/5/2002)
+
+- Added protected mode exception handling in case FreeLoader crashes
+- Reworked memory manager to use all of extended memory
+- Reworked UI code, now supports multiple text-mode resolutions
+
+Changes in v1.2.2 (5/4/2002)
+
+- Fixed memory leak in menu.c
+
+Changes in v1.2.1 (5/3/2002)
+
+- Makefile updates
+- Optimized the Makefile
+- Removed recursive make functionality (builds much faster now)
+- Places all output into one single directory
+- Added automagically generated dependencies
+
+Changes in v1.2 (4/30/2002)
+
+- All Linux kernels are supported (zImage & bzImage, loaded high & low)
+- Initrd support
+- FreeLoader now compiles under Mingw32 instead of just DJGPP, but
+  the Mingw32 linker seems to output a corrupt binary.
+
+Changes in v1.01 (4/28/2002)
+
+- Fixed FAT short file name buffer overflow that was causing
+  some long filenames not to work correctly.
+
+Changes in v1.0 (4/24/2002)
+
+- FreeLoader version 1.0!
+- Supports booting ReactOS
+- Supports booting Linux bzImage kernels
+- No initrd support (yet)
+- No zImage support (yet)
+- No ext2 file system support (yet)
+- Supports FAT & ISO-9660 file systems
+- Forward slashes '/' as well as backslashes '\' can be used
+  for path names in FAT & ISO-9600
+- Fixed bug in LBA code where it was only reading one sector
+  even if you asked for more
+- Fixed bug in FAT code, was also present in ISO-9660 code where
+  it wasn't incrementing the buffer address correctly

freeldr/freeldr/Makefile

@@ -0,0 +1,413 @@
+#
+#  FreeLoader
+#  Copyright (C) 1998-2002  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.
+#
+
+#############################################
+# 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)
+
+BOOTCD_DIR	=	../../bootcd
+
+#############################################
+# COMPILER AND LINKER PROGRAMS
+#
+TOOLSDIR	= $(SRCDIR)/../tools
+
+RM		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rdel
+CP		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rcopy
+MKDIR		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rmkdir
+RMDIR		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rrmdir
+OBJCOPY		= objcopy
+NM   		= nm
+OBJDUMP		= objdump
+DEPTOOL		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)deptool
+HOSTTOOL	= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)hosttype
+TOOLS		= $(DEPTOOL) $(HOSTTOOL)
+
+HOSTTYPE	= $(shell $(HOSTTOOL))
+
+#-----------------------------------------------------------------------------------------------------
+# TEST IF WE ARE IN THE TARGET DIRECTORY
+# IF NOT WE WILL CHANGE TO THE TARGET DIRECTORY AND RUN MAKE FROM THERE
+#-----------------------------------------------------------------------------------------------------
+#ifeq (,$(filter $(CURDIR)/$(OUTPUT_DIR),$(notdir $(CURDIR))))
+ifneq ($(CURDIR), $(SRCDIR)/$(OUTPUT_DIR))
+
+SRCDIR		= $(CURDIR)
+
+.SUFFIXES:
+
+#############################################
+# VARIABLE TO CHANGE TO TARGET DIRECTORY AND INVOKE MAKE FROM THERE
+#
+MAKETARGET	= $(MAKE) --no-print-directory -C $(OUTPUT_DIR) \
+			  -f ../../Makefile SRCDIR=$(CURDIR) $(MAKECMDGOALS)
+
+.PHONY: CHANGE_TO_TARGET
+CHANGE_TO_TARGET setupldr : BUILD_TOOLS $(OBJDIR) $(OBJDIR)/$(TARGET)
+	@echo Calculating source file dependencies...
+	+@$(MAKETARGET)
+
+.PHONY: BUILD_TOOLS
+BUILD_TOOLS:
+	@$(MAKE) --no-print-directory -C $(TOOLSDIR)
+
+$(OBJDIR):
+	@echo Creating directory: $(OBJDIR)
+	@$(MKDIR) $(OBJDIR)
+
+$(OBJDIR)/$(TARGET): $(OBJDIR)
+	@echo Creating directory: $(OBJDIR)/$(TARGET)
+	@$(MKDIR) $(OBJDIR)/$(TARGET)
+
+
+Makefile : ;
+
+% :: CHANGE_TO_TARGET
+
+#############################################
+
+.PHONY : clean
+clean:
+	@$(MAKE) --no-print-directory -C $(TOOLSDIR)
+	@echo Cleaning directory $(OBJDIR)/$(TARGET)
+	@-$(RM) $(OBJDIR)/$(TARGET)/*
+	@echo Removing directory $(OBJDIR)/$(TARGET)
+	@-$(RMDIR) $(OBJDIR)/$(TARGET)
+	@-$(RMDIR) $(OBJDIR)
+	@echo Clean ALL done.
+
+#############################################
+
+.PHONY : bootcd
+bootcd : bootcd_dirs setup_loader boot_loader
+
+.PHONY : bootcd_dirs
+bootcd_dirs:
+	$(MKDIR) $(BOOTCD_DIR)
+	$(MKDIR) $(BOOTCD_DIR)/disk
+	$(MKDIR) $(BOOTCD_DIR)/disk/reactos
+	$(MKDIR) $(BOOTCD_DIR)/disk/install
+	$(MKDIR) $(BOOTCD_DIR)/disk/bootdisk
+	$(MKDIR) $(BOOTCD_DIR)/disk/loader
+
+.PHONY : boot_loader
+boot_loader : $(OBJDIR)/$(TARGET)/freeldr.sys
+	$(CP) $(OBJDIR)/$(TARGET)/freeldr.sys $(BOOTCD_DIR)/disk/loader/freeldr.sys
+	$(CP) ../freeldr.ini $(BOOTCD_DIR)/disk/loader/freeldr.ini
+
+.PHONY : setup_loader
+setup_loader : $(OBJDIR)/$(TARGET)/setupldr.sys
+	$(CP) $(OBJDIR)/$(TARGET)/setupldr.sys $(BOOTCD_DIR)/disk/loader/setupldr.sys
+
+#############################################
+
+#-----------------------------------------------------------------------------------------------------
+# END MAGIC TARGET DIRECTORY CHANGE STUFF
+#-----------------------------------------------------------------------------------------------------
+else
+
+#############################################
+# COMPILER COMMAND LINE OPTIONS
+#
+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
+
+#############################################
+# COMPILER DEFINES
+#
+ifeq ($(DEBUG),yes)
+COMPILER_DEBUG_DEFINES = -DDEBUG
+else
+COMPILER_DEBUG_DEFINES =
+endif
+
+COMPILER_DEFINES = -D__$(TARGET)__ $(COMPILER_DEBUG_DEFINES)
+
+#############################################
+# INCLUDE DIRECTORY OPTIONS
+#
+COMPILER_INCLUDES	=	-I$(SRCDIR)/include
+
+#############################################
+# COMPILER FLAGS
+#
+CFLAGS	=	$(COMPILER_OPTIONS)		\
+			$(COMPILER_DEFINES)		\
+			$(COMPILER_INCLUDES)
+
+#############################################
+# LINKER COMMAND LINE OPTIONS
+#
+#LINKER_OPTIONS = -N -Ttext=0x8000 --oformat=binary -s
+LINKER_OPTIONS = -N -Ttext=0x8000
+
+#############################################
+# LINKER FLAGS
+#
+LFLAGS	=	$(LINKER_OPTIONS)
+
+#############################################
+# NASM FLAGS
+#
+ifeq ($(HOSTTYPE), dos)
+	NASMFLAGS	=	-f coff
+else
+	ifeq ($(HOSTTYPE), win32)
+		NASMFLAGS	=	-f win32
+	else
+		NASMFLAGS	=	-f elf
+	endif
+endif
+
+#############################################
+# LIST ALL THE OBJECT FILE GROUPS
+#
+# 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		\
+			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		\
+				stdlib.o	\
+				string.o	\
+				list.o		\
+				memcmp.o	\
+				memcpy.o	\
+				memmove.o	\
+				memset.o
+
+FS_OBJS		=	fs.o		\
+				fat.o		\
+				iso.o		\
+				ext2.o		\
+				ntfs.o		\
+				fsrec.o
+
+UI_OBJS		=	tui.o		\
+				tuimenu.o	\
+				ui.o		\
+				gui.o
+
+REACTOS_OBJS=	arcname.o	\
+				binhive.o	\
+				registry.o
+
+COMM_OBJS	=	rs232.o
+
+DISK_OBJS	=	disk.o		\
+			partition.o
+
+MM_OBJS		=	mm.o		\
+				meminit.o
+
+CACHE_OBJS	=	cache.o		\
+				blocklist.o
+
+INIFILE_OBJS=	inifile.o	\
+				ini_init.o	\
+				parse.o
+
+INFFILE_OBJS=	inffile.o
+
+VIDEO_OBJS	=	video.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
+# This code was taken from the GCC v3.1 source
+MATH_OBJS	=	libgcc2.o
+
+BASE_OBJS	=	freeldr.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
+
+ROSLDR_OBJS =	reactos.o
+
+SETUPLDR_OBJS=	setupldr.o
+
+COMMON_OBJS	=	$(ARCH_OBJS)		\
+				$(RTL_OBJS)			\
+				$(FS_OBJS)			\
+				$(UI_OBJS)			\
+				$(REACTOS_OBJS)		\
+				$(COMM_OBJS)		\
+				$(DISK_OBJS)		\
+				$(MM_OBJS)			\
+				$(CACHE_OBJS)		\
+				$(VIDEO_OBJS)		\
+				$(MATH_OBJS)		\
+				$(BASE_OBJS)
+
+SPECIAL_OBJS =	$(INIFILE_OBJS)		\
+				$(INFFILE_OBJS)		\
+				$(FREELDR_OBJS)		\
+				$(ROSLDR_OBJS)		\
+				$(SETUPLDR_OBJS)
+				
+
+F_OBJS		=	$(COMMON_OBJS)		\
+				$(INIFILE_OBJS)		\
+				$(ROSLDR_OBJS)		\
+				$(FREELDR_OBJS)
+
+S_OBJS		=	$(COMMON_OBJS)		\
+				$(INIFILE_OBJS)		\
+				$(INFFILE_OBJS)		\
+				$(SETUPLDR_OBJS)
+
+
+#############################################
+# ALL THE OBJECTS
+#
+ALL_OBJS	=	$(COMMON_OBJS)		\
+				$(SPECIAL_OBJS)
+
+
+#############################################
+# SET THE VPATH SO MAKE CAN FIND THE SOURCE FILES
+#
+VPATH		=	$(SRCDIR)/					\
+				$(SRCDIR)/arch/$(TARGET)	\
+				$(SRCDIR)/rtl				\
+				$(SRCDIR)/fs				\
+				$(SRCDIR)/ui				\
+				$(SRCDIR)/reactos			\
+				$(SRCDIR)/comm				\
+				$(SRCDIR)/disk				\
+				$(SRCDIR)/mm				\
+				$(SRCDIR)/cache				\
+				$(SRCDIR)/inifile			\
+				$(SRCDIR)/inffile			\
+				$(SRCDIR)/video				\
+				$(SRCDIR)/math				\
+				$(SRCDIR)/include
+
+#############################################
+
+all : freeldr.sys setupldr.sys
+	@echo Make ALL done.
+
+#############################################
+
+freeldr.sys : $(ALL_OBJS)
+	@echo ===================================================== LINKING $@
+	@$(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
+
+#############################################
+
+setupldr.sys : $(ALL_OBJS)
+	@echo ===================================================== LINKING $@
+	@$(LD) $(LFLAGS) -Map setupldr.map -o setupldr.exe $(S_OBJS)
+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
+
+#############################################
+
+%.o :: %.c
+	@echo ===================================================== Compiling $*
+	@$(CC) $(CFLAGS) -o $@ -c $<
+	@$(DEPTOOL) $*.d
+
+%.o :: %.S
+	@echo ===================================================== Assembling $*
+	@$(CC) $(CFLAGS) -o $@ -c $<
+	@$(DEPTOOL) $*.d
+
+%.o :: %.asm
+	@echo ===================================================== Assembling $*
+	@$(NASM_CMD) $(NASMFLAGS) -o $@ $<
+
+#############################################
+
+# Include the automagically generated dependencies
+-include $(ALL_OBJS:%.o=%.d)
+
+#############################################
+
+endif

freeldr/freeldr/arch/i386/_alloca.S

@@ -0,0 +1,33 @@
+/* stuff needed for libgcc on win32.  */
+
+/*#ifdef L_chkstk*/
+#ifdef WIN32
+
+	.global ___chkstk
+	.global	__alloca
+___chkstk:
+__alloca:
+	pushl  %ecx		/* save temp */
+	movl   %esp,%ecx	/* get sp */
+	addl   $0x8,%ecx	/* and point to return addr */
+
+probe: 	cmpl   $0x1000,%eax	/* > 4k ?*/
+	jb    done		
+
+	subl   $0x1000,%ecx  		/* yes, move pointer down 4k*/
+	orl    $0x0,(%ecx)   		/* probe there */
+	subl   $0x1000,%eax  	 	/* decrement count */
+	jmp    probe           	 	/* and do it again */
+
+done: 	subl   %eax,%ecx	   
+	orl    $0x0,(%ecx)	/* less that 4k, just peek here */
+
+	movl   %esp,%eax
+	movl   %ecx,%esp	/* decrement stack */
+
+	movl   (%eax),%ecx	/* recover saved temp */
+	movl   4(%eax),%eax	/* get return address */
+	jmp    *%eax	
+
+
+#endif

freeldr/freeldr/arch/i386/arch.S

@@ -0,0 +1,469 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+#include <multiboot.h>
+
+
+EXTERN(RealEntryPoint)
+
+	cli
+
+	/* Setup segment registers */
+	xorw	%ax,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+	/* Setup a stack */
+	movw	stack16,%sp
+
+	sti
+
+	/* Init pmode */
+	call	switch_to_prot
+
+	.code32
+
+	/* Store the boot drive */
+	movb	%dl,(_BootDrive)
+
+	/* Store the boot partition */
+	movb	%dh,(_BootPartition)
+
+	/* GO! */
+	xorl	%eax,%eax
+	pushl	%eax
+	call	_BootMain
+
+	call	switch_to_real
+	.code16
+
+	int	$0x19
+
+	/* We should never get here */
+stop:
+	jmp	stop
+	nop
+	nop
+
+/*
+ * Switches the processor to protected mode
+ * it destroys eax
+ */
+EXTERN(switch_to_prot)
+
+	.code16
+
+	cli		/* None of these */
+
+	/* We don't know what values are currently */
+	/* in the segment registers. So we are */
+	/* going to reload them with sane values. */
+	/* Of course CS has to already be valid. */
+	/* We are currently in real-mode so we */
+	/* need real-mode segment values. */
+	movw	$0x0000,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+
+	/* Get the return address off the stack */
+	popw	(code32ret)
+
+	/* Save 16-bit stack pointer */
+	movw	%sp,stack16
+
+	/* Load the GDT */
+	lgdt	gdtptr
+	/* Load the IDT */
+	lidt	i386idtptr
+
+	/* Enable Protected Mode */
+	mov	%cr0,%eax
+	orl	$CR0_PE_SET,%eax
+	mov	%eax,%cr0
+
+	/* Clear prefetch queue & correct CS */
+	ljmp	$PMODE_CS, $inpmode
+
+
+	.code32
+
+inpmode:
+	/* Setup segment selectors */
+	movw	$PMODE_DS,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+	movl	stack32,%esp
+
+	/* Put the return address back onto the stack */
+	pushl	(code32ret)
+
+	/* Now return in p-mode! */
+	ret
+
+/*
+ * Switches the processor back to real mode
+ * it destroys eax
+ */
+EXTERN(switch_to_real)
+
+	.code32
+
+	/* We don't know what values are currently */
+	/* in the segment registers. So we are */
+	/* going to reload them with sane values. */
+	/* Of course CS has to already be valid. */
+	/* We are currently in protected-mode so we */
+	/* need protected-mode segment values. */
+	movw	$PMODE_DS,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+
+	/* Get the return address off the stack */
+	popl	(code16ret)
+
+	/* Save 32-bit stack pointer */
+	movl	%esp,stack32
+
+	/* jmp to 16-bit segment to set the limit correctly */
+	ljmp	$RMODE_CS, $switch_to_real16
+
+switch_to_real16:
+	.code16
+
+	/* Restore segment registers to correct limit */
+	movw	$RMODE_DS,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+
+	/* Disable Protected Mode */
+	mov	%cr0,%eax
+	andl	$CR0_PE_CLR,%eax
+	mov	%eax,%cr0
+
+	/* Clear prefetch queue & correct CS */
+	ljmp	$0, $inrmode
+
+inrmode:
+	movw	%cs,%ax
+	movw	%ax,%ds
+	movw	%ax,%es
+	movw	%ax,%fs
+	movw	%ax,%gs
+	movw	%ax,%ss
+
+	/* Clear out the high 16-bits of ESP */
+	/* This is needed because I have one */
+	/* machine that hangs when booted to dos if */
+	/* anything other than 0x0000 is in the high */
+	/* 16-bits of ESP. Even though real-mode */
+	/* code should only use SP and not ESP. */
+	xorl	%esp,%esp
+
+	movw	stack16,%sp
+
+	/* Put the return address back onto the stack */
+	pushw	(code16ret)
+
+	/* Load IDTR with real mode value */
+	lidt	rmode_idtptr
+
+	sti		/* These are ok now */
+
+	/* Now return in r-mode! */
+	ret
+
+
+	/*
+	 * Needed for enabling the a20 address line
+	 */
+	.code16
+empty_8042:
+	.word	0x00eb,0x00eb            // jmp $+2, jmp $+2
+	inb	$0x64,%al
+	testb	$0x02,%al
+	jnz	empty_8042
+	ret
+
+	/*
+	 * Enable the A20 address line (to allow access to over 1mb)
+	 */
+EXTERN(_EnableA20)
+	.code32
+
+	pushal
+
+	call	switch_to_real
+	.code16
+
+	call	empty_8042
+	movb	$0xD1,%al                // command write
+	outb	%al,$0x64
+	call	empty_8042
+	mov	$0xDF,%al                // A20 on
+	out	%al,$0x60
+	call	empty_8042
+	call	switch_to_prot
+	.code32
+
+	popal
+
+	ret
+
+	/*
+	 * Disable the A20 address line
+	 */
+EXTERN(_DisableA20)
+	.code32
+
+	pushal
+
+	call	switch_to_real
+	.code16
+
+	call	empty_8042
+	movb	$0xD1,%al                // command write
+	outb	%al,$0x64
+	call	empty_8042
+	mov	$0xDD,%al                // A20 off
+	out	%al,$0x60
+	call	empty_8042
+	call	switch_to_prot
+	.code32
+
+	popal
+
+	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:
+	.word	STACK16ADDR
+
+	/* 32-bit stack pointer */
+stack32:
+	.long	STACK32ADDR
+
+	/* 16-bit return address */
+code16ret:
+	.long	0
+
+	/* 32-bit return address */
+code32ret:
+	.long	0
+
+
+	.p2align	2	/* force 4-byte alignment */
+gdt:
+	/* NULL Descriptor */
+	.word	0x0000
+	.word	0x0000
+	.word	0x0000
+	.word	0x0000
+
+	/* 32-bit flat CS */
+	.word	0xFFFF
+	.word	0x0000
+	.word	0x9A00
+	.word	0x00CF
+
+	/* 32-bit flat DS */
+	.word	0xFFFF
+	.word	0x0000
+	.word	0x9200
+	.word	0x00CF
+
+	/* 16-bit real mode CS */
+	.word	0xFFFF
+	.word	0x0000
+	.word	0x9E00
+	.word	0x0000
+
+	/* 16-bit real mode DS */
+	.word	0xFFFF
+	.word	0x0000
+	.word	0x9200
+	.word	0x0000
+
+/* GDT table pointer */
+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 */
+	.long	0			/* Base Address */
+
+EXTERN(_BootDrive)
+	.long	0
+
+EXTERN(_BootPartition)
+	.long	0

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/boot.S

@@ -0,0 +1,62 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+
+
+EXTERN(_ChainLoadBiosBootSectorCode)
+	.code32
+
+	call	switch_to_real
+	.code16
+
+	/* Set the boot drive */
+	movb	(_BootDrive),%dl
+
+	/* Load segment registers */
+	cli
+	movw	$0x0000,%bx
+	movw	%bx,%ds
+	movw	%bx,%es
+	movw	%bx,%fs
+	movw	%bx,%gs
+	movw	%bx,%ss
+	movw	$0x7C00,%sp
+
+	ljmpl	$0x0000,$0x7C00
+
+EXTERN(_SoftReboot)
+	.code32
+
+	call	switch_to_real
+	.code16
+
+	movw	$0x40,%ax
+	movw	%ax,%ds
+	movw	$0x72,%si
+
+	// Set the word at location 40:72 to 1234h
+	movw	$0x1234,(%si)
+
+	// and jump to location FFFF:0 in ROM
+	ljmpl	$0xFFFF,$0x0000

freeldr/freeldr/arch/i386/drvmap.S

@@ -0,0 +1,132 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+
+
+EXTERN(_DriveMapInt13HandlerStart)
+Int13Handler:
+
+	pushw	%bp
+	movw	%sp,%bp
+	pushw	%ax
+	pushw	%cx
+	pushw	%si
+
+	cld
+
+	/* Get callers flags from stack */
+	movw	0x06(%bp),%ax
+	movw	%ax,%cs:(CallersFlags - Int13Handler)
+
+	/* Save the drive number they passed in */
+	movb	%dl,%cs:(PassedInDriveNumber - Int13Handler)
+
+	/* Now we need to perform the mapping */
+	xorw	%cx,%cx
+	movw	$(Int13HandlerMapCount - Int13Handler),%si
+	/* Get the count of drives in the map list */
+	movb	%cs:(%si),%cl
+	incw	%si
+
+	/* If the map list is empty then just call the old int 13h handler */
+	cmpb	$0,%cl
+	jz		CallOldInt13Handler
+
+GetMappedDriveNumberLoop:
+
+	/* Get the next drive number in the list */
+	lodsw	%cs:(%si),%ax
+	/* Check to see if it's the one they are calling int 13h for */
+	cmpb	%al,%dl
+	/* If not get the next one */
+	jne		GetMappedDriveNumberLoopNext
+
+	/* If we get here then we have found a mapped drive */
+	/* Send new drive number on to the old int 13h handler */
+	movb	%ah,%dl
+	/* Call BIOS Int 13 Handler */
+	jmp		CallOldInt13Handler
+
+GetMappedDriveNumberLoopNext:
+	loop	GetMappedDriveNumberLoop
+
+CallOldInt13Handler:
+	/* Restore the registers we changed off the stack */
+	popw	%si
+	popw	%cx
+	popw	%ax
+
+	/* Put flags onto stack */
+	pushw	%cs:(CallersFlags - Int13Handler)
+
+	/* Call old int 13h handler with new drive number */
+	.byte	0x9a /* lcall */
+EXTERN(_DriveMapOldInt13HandlerAddress)
+	.word	0
+	.word	0
+
+	/* Update the callers flags with the values the BIOS returned */
+	pushw	%ax
+	pushf
+	popw	%ax
+	movw	%ax,0x06(%bp)
+	popw	%ax
+	/* Restore the callers drive number */
+	movb	%cs:(PassedInDriveNumber - Int13Handler),%dl
+
+	popw	%bp
+
+	iret
+
+CallersFlags:
+	.word	0
+
+PassedInDriveNumber:
+	.byte	0
+
+EXTERN(_DriveMapInt13HandlerMapList)
+Int13HandlerMapCount:
+	.byte	0
+
+Int13HandlerDrive1:
+	.byte	0
+Int13HandlerDriveNew1:
+	.byte	0
+
+Int13HandlerDrive2:
+	.byte	0
+Int13HandlerDriveNew2:
+	.byte	0
+
+Int13HandlerDrive3:
+	.byte	0
+Int13HandlerDriveNew3:
+	.byte	0
+
+Int13HandlerDrive4:
+	.byte	0
+Int13HandlerDriveNew4:
+	.byte	0
+
+EXTERN(_DriveMapInt13HandlerEnd)

freeldr/freeldr/arch/i386/fathelp.asm

@@ -0,0 +1,233 @@
+; FATHELP.ASM
+; FAT12/16 Boot Sector Helper Code
+; Copyright (c) 1998, 2001, 2002, 2003 Brian Palmer
+
+
+
+;org 8000h
+
+segment .text
+
+bits 16
+
+
+BootSectorStackTop		equ		0x7bf2
+DataAreaStartHigh		equ		0x2
+DataAreaStartLow		equ		0x4
+BiosCHSDriveSizeHigh	equ		0x6
+BiosCHSDriveSizeLow		equ		0x8
+BiosCHSDriveSize		equ		0x8
+ReadSectorsOffset		equ		0xa
+ReadClusterOffset		equ		0xc
+PutCharsOffset			equ		0xe
+
+OEMName					equ		3
+BytesPerSector			equ		11
+SectsPerCluster			equ		13
+ReservedSectors			equ		14
+NumberOfFats			equ		16
+MaxRootEntries			equ		17
+TotalSectors			equ		19
+MediaDescriptor			equ		21
+SectorsPerFat			equ		22
+SectorsPerTrack			equ		24
+NumberOfHeads			equ		26
+HiddenSectors			equ		28
+TotalSectorsBig			equ		32
+BootDrive				equ		36
+Reserved				equ		37
+ExtendSig				equ		38
+SerialNumber			equ		39
+VolumeLabel				equ		43
+FileSystem				equ		54
+
+BootPartition			equ		0x7dfd
+        
+
+; This code will be stored in the first 512 bytes
+; of freeldr.sys. The first 3 bytes will be a jmp
+; instruction to skip past the FAT helper code
+; that is stored in the rest of the 512 bytes.
+;
+; This code is loaded at 0000:8000 so we have to
+; encode a jmp instruction to jump to 0000:8200
+
+global _mainCRTStartup	; For Mingw32 builds where the linker looks for this symbol
+_mainCRTStartup:
+global start
+start:
+        db	0xe9
+		db	0xfd
+		db	0x01
+
+; Now starts the extra boot code that we will store
+; in the first 512 bytes of freeldr.sys. This code
+; allows the FAT12/16 bootsector to navigate the
+; FAT table so that we can still load freeldr.sys
+; even if it is fragmented.
+
+
+FatHelperEntryPoint:
+
+		push ax							; First save AX - the start cluster of freeldr.sys
+
+
+		; Display "Loading FreeLoader..." message
+        mov  esi,msgLoading				; Loading message
+        call [bp-PutCharsOffset]		; Display it
+
+
+		call ReadFatIntoMemory
+
+		pop  ax							; Restore AX (start cluster)
+		; AX has start cluster of freeldr.sys
+
+        mov  bx,800h
+        mov  es,bx
+
+LoadFile:
+		push ax
+		call IsFat12
+		pop  ax
+		jnc  LoadFile2
+		cmp  ax,0ff8h		    ; Check to see if this is the last cluster in the chain
+		jmp  LoadFile3
+LoadFile2:
+		cmp  ax,0fff8h
+LoadFile3:
+		jae	 LoadFile_Done		; If so continue, if not then read then next one
+		push ax
+        xor  bx,bx              ; Load ROSLDR starting at 0000:8000h
+		push es
+		call [bp-ReadClusterOffset]
+		pop  es
+
+		xor  bx,bx
+        mov  bl,BYTE [BYTE bp+SectsPerCluster]
+		shl  bx,5							; BX = BX * 512 / 16
+		mov  ax,es							; Increment the load address by
+		add  ax,bx							; The size of a cluster
+		mov  es,ax
+
+		call IsFat12
+		pop  ax
+		push es
+		jnc  LoadFile4
+		call GetFatEntry12					; Get the next entry
+		jmp  LoadFile5
+LoadFile4:
+		call GetFatEntry16
+LoadFile5:
+		pop  es
+
+        jmp  LoadFile						; Load the next cluster (if any)
+
+LoadFile_Done:
+        mov  dl,BYTE [BYTE bp+BootDrive]	; Load the boot drive into DL
+		mov  dh,[BootPartition]				; Load the boot partition into DH
+        push WORD 0x0000
+        push WORD 0x8000					; We will do a far return to 0000:8000h
+        retf								; Transfer control to ROSLDR
+
+
+; Reads the entire FAT into memory at 7000:0000
+ReadFatIntoMemory:
+        mov   ax,WORD [BYTE bp+HiddenSectors] 
+        mov   dx,WORD [BYTE bp+HiddenSectors+2]
+		add   ax,WORD [BYTE bp+ReservedSectors]
+		adc   dx,byte 0
+		mov   cx,WORD [BYTE bp+SectorsPerFat]
+		mov   bx,7000h
+		mov   es,bx
+		xor   bx,bx
+		call  [bp-ReadSectorsOffset]
+		ret
+
+
+; Returns the FAT entry for a given cluster number for 16-bit FAT
+; On entry AX has cluster number
+; On return AX has FAT entry for that cluster
+GetFatEntry16:
+
+		mov   cx,2						; AX = AX * 2 (since FAT16 entries are 2 bytes)
+		mul   cx
+		shl   dx,12
+
+        mov   bx,7000h
+		add   bx,dx
+        mov   es,bx
+		mov   bx,ax						; Restore FAT entry offset
+		mov   ax,WORD [es:bx]	    	; Get FAT entry
+
+		ret
+
+
+; Returns the FAT entry for a given cluster number for 12-bit FAT
+; On entry AX has cluster number
+; On return AX has FAT entry for that cluster
+GetFatEntry12:
+
+		push  ax
+		mov   cx,ax
+		shr   ax,1
+		add   ax,cx						; AX = AX * 1.5 (AX = AX + (AX / 2)) (since FAT12 entries are 12 bits)
+
+        mov   bx,7000h
+        mov   es,bx
+		mov   bx,ax						; Put FAT entry offset into BX
+		mov   ax,WORD [es:bx]	    	; Get FAT entry
+		pop   cx						; Get cluster number from stack
+		and   cx,1
+		jz    UseLow12Bits
+		and   ax,0fff0h
+		shr   ax,4
+		jmp   GetFatEntry12_Done
+
+UseLow12Bits:
+		and   ax,0fffh
+
+GetFatEntry12_Done:
+
+		ret
+
+
+; Returns CF = 1 if this is a FAT12 file system
+; Otherwise CF = 0 for FAT16
+IsFat12:
+
+		mov   ebx,DWORD [BYTE bp-DataAreaStartLow]
+        ; EBX now has the number of the starting sector of the data area
+		; starting from the beginning of the disk, so subtrace hidden sectors
+		sub   ebx,DWORD [BYTE bp+HiddenSectors]
+
+
+		xor   eax,eax
+		mov   ax,WORD [BYTE bp+TotalSectors]
+		cmp   ax,byte 0
+		jnz   IsFat12_2
+		mov   eax,DWORD [BYTE bp+TotalSectorsBig]
+
+		; EAX now contains the number of sectors on the volume
+
+IsFat12_2:
+		sub   eax,ebx				; Subtract data area start sector
+		xor   edx,edx				; from total sectors of volume
+
+		; EDX:EAX now contains the number of data sectors on the volume
+		movzx ebx,BYTE [BYTE bp+SectsPerCluster]
+		div   ebx
+		; EAX now has the number of clusters on the volume
+		stc
+		cmp   eax,4085
+		jb    IsFat12_Done
+		clc
+
+IsFat12_Done:
+		ret
+
+
+
+msgLoading	db 'Loading FreeLoader...',0dh,0ah,0
+
+			times 510-($-$$) db 0	; Pad to 510 bytes
+			dw 0aa55h				; BootSector signature

freeldr/freeldr/arch/i386/hardware.h

@@ -0,0 +1,200 @@
+/*
+ *  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_HARDWARE_H_
+#define __I386_HARDWARE_H_
+
+#ifndef __REGISTRY_H
+#include "../../reactos/registry.h"
+#endif
+
+typedef enum
+{
+  InterfaceTypeUndefined = -1,
+  Internal,
+  Isa,
+  Eisa,
+  MicroChannel,
+  TurboChannel,
+  PCIBus,
+  VMEBus,
+  NuBus,
+  PCMCIABus,
+  CBus,
+  MPIBus,
+  MPSABus,
+  ProcessorInternal,
+  InternalPowerBus,
+  PNPISABus,
+  MaximumInterfaceType
+} INTERFACE_TYPE, *PINTERFACE_TYPE;
+
+
+typedef enum _CM_RESOURCE_TYPE
+{
+  CmResourceTypeNull = 0,
+  CmResourceTypePort,
+  CmResourceTypeInterrupt,
+  CmResourceTypeMemory,
+  CmResourceTypeDma,
+  CmResourceTypeDeviceSpecific,
+  CmResourceTypeMaximum
+} CM_RESOURCE_TYPE;
+
+
+typedef enum _CM_SHARE_DISPOSITION
+{
+  CmResourceShareUndetermined = 0,
+  CmResourceShareDeviceExclusive,
+  CmResourceShareDriverExclusive,
+  CmResourceShareShared
+} CM_SHARE_DISPOSITION;
+
+
+typedef U64 PHYSICAL_ADDRESS;
+
+
+typedef struct
+{
+  U8 Type;
+  U8 ShareDisposition;
+  U16 Flags;
+  union
+    {
+      struct
+	{
+	  PHYSICAL_ADDRESS Start;
+	  U32 Length;
+	} __attribute__((packed)) Port;
+      struct
+	{
+	  U32 Level;
+	  U32 Vector;
+	  U32 Affinity;
+	} __attribute__((packed)) Interrupt;
+      struct
+	{
+	  PHYSICAL_ADDRESS Start;
+	  U32 Length;
+	} __attribute__((packed)) Memory;
+      struct
+	{
+	  U32 Channel;
+	  U32 Port;
+	  U32 Reserved1;
+	} __attribute__((packed)) Dma;
+      struct
+	{
+	  U32 DataSize;
+	  U32 Reserved1;
+	  U32 Reserved2;
+	} __attribute__((packed)) DeviceSpecificData;
+    } __attribute__((packed)) u;
+} __attribute__((packed)) CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
+
+
+/* CM_PARTIAL_RESOURCE_DESCRIPTOR.Flags */
+#define CM_RESOURCE_PORT_MEMORY               0x0000
+#define CM_RESOURCE_PORT_IO                   0x0001
+
+#define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0x0000
+#define CM_RESOURCE_INTERRUPT_LATCHED         0x0001
+
+
+typedef struct
+{
+  U16 Version;
+  U16 Revision;
+  U32 Count;
+  CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
+} __attribute__((packed))CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
+
+
+typedef struct
+{
+  INTERFACE_TYPE InterfaceType;
+  U32 BusNumber;
+  CM_PARTIAL_RESOURCE_LIST PartialResourceList;
+} __attribute__((packed)) CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
+
+
+typedef struct _CM_COMPONENT_INFORMATION
+{
+  U32 Flags;
+  U32 Version;
+  U32 Key;
+  U32 Affinity;
+} __attribute__((packed)) CM_COMPONENT_INFORMATION, *PCM_COMPONENT_INFORMATION;
+
+
+/* CM_COMPONENT_INFORMATION.Flags */
+#define Failed      0x00000001
+#define ReadOnly    0x00000002
+#define Removable   0x00000004
+#define ConsoleIn   0x00000008
+#define ConsoleOut  0x00000010
+#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,
+			     U32 Flags,
+			     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,
+	      U32 *eax,
+	      U32 *ebx,
+	      U32 *ecx,
+	      U32 *edx);
+U64 RDTSC(VOID);
+
+/* i386pnp.S */
+U32 PnpBiosSupported(VOID);
+U32 PnpBiosGetDeviceNodeCount(U32 *NodeSize,
+			      U32 *NodeCount);
+U32 PnpBiosGetDeviceNode(U8 *NodeId,
+			 U8 *NodeBuffer);
+
+#endif /* __I386_HARDWARE_H_ */
+
+/* EOF */

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

@@ -0,0 +1,635 @@
+/*
+ *  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.
+ */
+
+#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"
+
+
+#define MP_FP_SIGNATURE 0x5F504D5F	/* "_MP_" */
+#define MP_CT_SIGNATURE 0x504D4350	/* "PCMP" */
+
+
+typedef struct _MP_FLOATING_POINT_TABLE
+{
+  U32 Signature;			/* "_MP_" */
+  U32 PhysicalAddressPointer;
+  U8  Length;
+  U8  SpecRev;
+  U8  Checksum;
+  U8  FeatureByte[5];
+} PACKED MP_FLOATING_POINT_TABLE, *PMP_FLOATING_POINT_TABLE;
+
+
+typedef struct _MPS_CONFIG_TABLE_HEADER
+{
+  U32 Signature;			/* "PCMP" */
+  U16 BaseTableLength;
+  U8  SpecRev;
+  U8  Checksum;
+  U8  OemIdString[8];
+  U8  ProductIdString[12];
+  U32 OemTablePointer;
+  U16 OemTableLength;
+  U16 EntryCount;
+  U32 AddressOfLocalAPIC;
+  U16 ExtendedTableLength;
+  U8  ExtendedTableChecksum;
+  U8  Reserved;
+} PACKED MP_CONFIGURATION_TABLE, *PMP_CONFIGURATION_TABLE;
+
+
+typedef struct _MP_PROCESSOR_ENTRY
+{
+  U8  EntryType;
+  U8  LocalApicId;
+  U8  LocalApicVersion;
+  U8  CpuFlags;
+  U32 CpuSignature;
+  U32 FeatureFlags;
+  U32 Reserved1;
+  U32 Reserved2;
+} PACKED MP_PROCESSOR_ENTRY, *PMP_PROCESSOR_ENTRY;
+
+
+/* FUNCTIONS ****************************************************************/
+
+static U32
+GetCpuSpeed(VOID)
+{
+  U64 Timestamp1;
+  U64 Timestamp2;
+  U64 Diff;
+
+  /* Read TSC (Time Stamp Counter) */
+  Timestamp1 = RDTSC();
+
+  /* Wait for 0.1 seconds (= 100 milliseconds = 100000 microseconds)*/
+  KeStallExecutionProcessor(100000);
+
+  /* Read TSC (Time Stamp Counter) again */
+  Timestamp2 = RDTSC();
+
+  /* Calculate elapsed time (check for counter overrun) */
+  if (Timestamp2 > Timestamp1)
+    {
+      Diff = Timestamp2 - Timestamp1;
+    }
+  else
+    {
+      Diff = Timestamp2 + (((U64)-1) - Timestamp1);
+    }
+
+  return (U32)(Diff / 100000);
+}
+
+
+static VOID
+DetectCPU(HKEY CpuKey,
+	  HKEY FpuKey)
+{
+  char VendorIdentifier[13];
+  char Identifier[64];
+  U32 FeatureSet;
+  HKEY CpuInstKey;
+  HKEY FpuInstKey;
+  U32 eax = 0;
+  U32 ebx = 0;
+  U32 ecx = 0;
+  U32 edx = 0;
+  U32 *Ptr;
+  S32 Error;
+  BOOL SupportTSC = FALSE;
+  U32 CpuSpeed;
+
+
+  /* Create the CPU instance key */
+  Error = RegCreateKey(CpuKey,
+		       "0",
+		       &CpuInstKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  /* Create the FPU instance key */
+  Error = RegCreateKey(FpuKey,
+		       "0",
+		       &FpuInstKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  eax = CpuidSupported();
+  if (eax & 1)
+    {
+      DbgPrint((DPRINT_HWDETECT, "CPUID supported\n"));
+
+      /* Get vendor identifier */
+      GetCpuid(0, &eax, &ebx, &ecx, &edx);
+      VendorIdentifier[12] = 0;
+      Ptr = (U32*)&VendorIdentifier[0];
+      *Ptr = ebx;
+      Ptr++;
+      *Ptr = edx;
+      Ptr++;
+      *Ptr = ecx;
+
+      /* Get Identifier */
+      GetCpuid(1, &eax, &ebx, &ecx, &edx);
+      sprintf(Identifier,
+	      "x86 Family %u Model %u Stepping %u",
+	      (unsigned int)((eax >> 8) & 0x0F),
+	      (unsigned int)((eax >> 4) & 0x0F),
+	      (unsigned int)(eax & 0x0F));
+      FeatureSet = edx;
+      if (((eax >> 8) & 0x0F) >= 5)
+        SupportTSC = TRUE;
+    }
+  else
+    {
+      DbgPrint((DPRINT_HWDETECT, "CPUID not supported\n"));
+
+      strcpy(VendorIdentifier, "Unknown");
+      sprintf(Identifier,
+	      "x86 Family %u Model %u Stepping %u",
+	      (unsigned int)((eax >> 8) & 0x0F),
+	      (unsigned int)((eax >> 4) & 0x0F),
+	      (unsigned int)(eax & 0x0F));
+      FeatureSet = 0;
+    }
+
+  /* Set 'Conmponent Information' value (CPU and FPU) */
+  SetComponentInformation(CpuInstKey, 0, 0, 1);
+  SetComponentInformation(FpuInstKey, 0, 0, 1);
+
+  /* Set 'FeatureSet' value (CPU only) */
+  DbgPrint((DPRINT_HWDETECT, "FeatureSet: %x\n", FeatureSet));
+
+  Error = RegSetValue(CpuInstKey,
+		      "FeatureSet",
+		      REG_DWORD,
+		      (PU8)&FeatureSet,
+		      sizeof(U32));
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* Set 'Identifier' value (CPU and FPU) */
+  DbgPrint((DPRINT_HWDETECT, "Identifier: %s\n", Identifier));
+
+  Error = RegSetValue(CpuInstKey,
+		      "Identifier",
+		      REG_SZ,
+		      (PU8)Identifier,
+		      strlen(Identifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  Error = RegSetValue(FpuInstKey,
+		      "Identifier",
+		      REG_SZ,
+		      (PU8)Identifier,
+		      strlen(Identifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* Set 'VendorIdentifier' value (CPU only) */
+  DbgPrint((DPRINT_HWDETECT, "Vendor Identifier: %s\n", VendorIdentifier));
+
+  Error = RegSetValue(CpuInstKey,
+		      "VendorIdentifier",
+		      REG_SZ,
+		      (PU8)VendorIdentifier,
+		      strlen(VendorIdentifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* FIXME: Set 'Update Signature' value (CPU only) */
+
+  /* FIXME: Set 'Update Status' value (CPU only) */
+
+  /* Set '~MHz' value (CPU only) */
+  if (SupportTSC)
+    {
+      CpuSpeed = GetCpuSpeed();
+
+      Error = RegSetValue(CpuInstKey,
+			  "~MHz",
+			  REG_DWORD,
+			  (PU8)&CpuSpeed,
+			  sizeof(U32));
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	}
+    }
+}
+
+
+static VOID
+SetMpsProcessor(HKEY CpuKey,
+		HKEY FpuKey,
+		PMP_PROCESSOR_ENTRY CpuEntry)
+{
+  char VendorIdentifier[13];
+  char Identifier[64];
+  char Buffer[8];
+  U32 FeatureSet;
+  HKEY CpuInstKey;
+  HKEY FpuInstKey;
+  U32 eax = 0;
+  U32 ebx = 0;
+  U32 ecx = 0;
+  U32 edx = 0;
+  U32 *Ptr;
+  S32 Error;
+  U32 CpuSpeed;
+
+  /* Get processor instance number */
+  sprintf(Buffer, "%u", CpuEntry->LocalApicId);
+
+  /* Create the CPU instance key */
+  Error = RegCreateKey(CpuKey,
+		       Buffer,
+		       &CpuInstKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  /* Create the FPU instance key */
+  Error = RegCreateKey(FpuKey,
+		       Buffer,
+		       &FpuInstKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  /* Get 'VendorIdentifier' */
+  GetCpuid(0, &eax, &ebx, &ecx, &edx);
+  VendorIdentifier[12] = 0;
+  Ptr = (U32*)&VendorIdentifier[0];
+  *Ptr = ebx;
+  Ptr++;
+  *Ptr = edx;
+  Ptr++;
+  *Ptr = ecx;
+
+  /* Get 'Identifier' */
+  sprintf(Identifier,
+	  "x86 Family %u Model %u Stepping %u",
+	  (U32)((CpuEntry->CpuSignature >> 8) & 0x0F),
+	  (U32)((CpuEntry->CpuSignature >> 4) & 0x0F),
+	  (U32)(CpuEntry->CpuSignature & 0x0F));
+
+  /* Get FeatureSet */
+  FeatureSet = CpuEntry->FeatureFlags;
+
+  /* Set 'Configuration Data' value (CPU and FPU) */
+  SetComponentInformation(CpuInstKey,
+			  0,
+			  CpuEntry->LocalApicId,
+			  1 << CpuEntry->LocalApicId);
+
+  SetComponentInformation(FpuInstKey,
+			  0,
+			  CpuEntry->LocalApicId,
+			  1 << CpuEntry->LocalApicId);
+
+  /* Set 'FeatureSet' value (CPU only) */
+  DbgPrint((DPRINT_HWDETECT, "FeatureSet: %x\n", FeatureSet));
+
+  Error = RegSetValue(CpuInstKey,
+		      "FeatureSet",
+		      REG_DWORD,
+		      (PU8)&FeatureSet,
+		      sizeof(U32));
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* Set 'Identifier' value (CPU and FPU) */
+  DbgPrint((DPRINT_HWDETECT, "Identifier: %s\n", Identifier));
+
+  Error = RegSetValue(CpuInstKey,
+		      "Identifier",
+		      REG_SZ,
+		      (PU8)Identifier,
+		      strlen(Identifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  Error = RegSetValue(FpuInstKey,
+		      "Identifier",
+		      REG_SZ,
+		      (PU8)Identifier,
+		      strlen(Identifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* Set 'VendorIdentifier' value (CPU only) */
+  DbgPrint((DPRINT_HWDETECT, "Vendor Identifier: %s\n", VendorIdentifier));
+
+  Error = RegSetValue(CpuInstKey,
+		      "VendorIdentifier",
+		      REG_SZ,
+		      (PU8)VendorIdentifier,
+		      strlen(VendorIdentifier) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+    }
+
+  /* FIXME: Set 'Update Signature' value (CPU only) */
+
+  /* FIXME: Set 'Update Status' value (CPU only) */
+
+  /* Set '~MHz' value (CPU only) */
+  if (((CpuEntry->CpuSignature >> 8) & 0x0F) >= 5)
+    {
+      CpuSpeed = GetCpuSpeed();
+
+      Error = RegSetValue(CpuInstKey,
+			  "~MHz",
+			  REG_DWORD,
+			  (PU8)&CpuSpeed,
+			  sizeof(U32));
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	}
+    }
+}
+
+
+static PMP_FLOATING_POINT_TABLE
+GetMpFloatingPointTable(VOID)
+{
+  PMP_FLOATING_POINT_TABLE FpTable;
+  char *Ptr;
+  U8 Sum;
+  U32 Length;
+  U32 i;
+
+  FpTable = (PMP_FLOATING_POINT_TABLE)0xF0000;
+  while ((U32)FpTable < 0x100000)
+    {
+      if (FpTable->Signature == MP_FP_SIGNATURE)
+	{
+	  Length = FpTable->Length * 0x10;
+	  Ptr = (char *)FpTable;
+	  Sum = 0;
+	  for (i = 0; i < Length; i++)
+	    {
+	      Sum += Ptr[i];
+	    }
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Checksum: %u\n",
+		    Sum));
+
+	  if (Sum != 0)
+	    {
+	      DbgPrint((DPRINT_HWDETECT,
+			"Invalid MP floating point checksum: %u\n",
+			Sum));
+	      return NULL;
+	    }
+
+	  return FpTable;
+	}
+
+      FpTable = (PMP_FLOATING_POINT_TABLE)((U32)FpTable + 0x10);
+    }
+
+  return NULL;
+}
+
+
+static PMP_CONFIGURATION_TABLE
+GetMpConfigurationTable(PMP_FLOATING_POINT_TABLE FpTable)
+{
+  PMP_CONFIGURATION_TABLE ConfigTable;
+  char *Ptr;
+  U8 Sum;
+  U32 Length;
+  U32 i;
+
+  if (FpTable->FeatureByte[0] != 0 ||
+      FpTable->PhysicalAddressPointer == 0)
+    return NULL;
+
+  ConfigTable = (PMP_CONFIGURATION_TABLE)FpTable->PhysicalAddressPointer;
+  if (ConfigTable->Signature != MP_CT_SIGNATURE)
+    return NULL;
+
+  DbgPrint((DPRINT_HWDETECT, 
+	    "MP Configuration Table at: %x\n",
+	    (U32)ConfigTable));
+
+  /* Calculate base table checksum */
+  Length = ConfigTable->BaseTableLength;
+  Ptr = (char *)ConfigTable;
+  Sum = 0;
+  for (i = 0; i < Length; i++)
+    {
+      Sum += Ptr[i];
+    }
+  DbgPrint((DPRINT_HWDETECT,
+	    "MP Configuration Table base checksum: %u\n",
+	    Sum));
+
+  if (Sum != 0)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"Invalid MP Configuration Table base checksum: %u\n",
+		Sum));
+      return NULL;
+    }
+
+  if (ConfigTable->ExtendedTableLength != 0)
+    {
+      /* FIXME: Check extended table */
+    }
+
+  return ConfigTable;
+}
+
+
+static BOOL
+DetectMps(HKEY CpuKey,
+	  HKEY FpuKey)
+{
+  PMP_FLOATING_POINT_TABLE FpTable;
+  PMP_CONFIGURATION_TABLE ConfigTable;
+  PMP_PROCESSOR_ENTRY CpuEntry;
+  char *Ptr;
+  U32 Offset;
+
+  /* Get floating point table */
+  FpTable = GetMpFloatingPointTable();
+  if (FpTable == NULL)
+    return FALSE;
+
+  DbgPrint((DPRINT_HWDETECT,
+	    "MP Floating Point Table at: %x\n",
+	    (U32)FpTable));
+
+  if (FpTable->FeatureByte[0] == 0)
+    {
+      /* Get configuration table */
+      ConfigTable = GetMpConfigurationTable(FpTable);
+      if (ConfigTable == NULL)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Failed to find the MP Configuration Table\n"));
+	  return FALSE;
+	}
+
+      Offset = sizeof(MP_CONFIGURATION_TABLE);
+      while (Offset < ConfigTable->BaseTableLength)
+	{
+	  Ptr = (char*)((U32)ConfigTable + Offset);
+
+	  switch (*Ptr)
+	    {
+	      case 0:
+		CpuEntry = (PMP_PROCESSOR_ENTRY)Ptr;
+
+		DbgPrint((DPRINT_HWDETECT, "Processor Entry\n"));
+		DbgPrint((DPRINT_HWDETECT, 
+			  "APIC Id %u  APIC Version %u  Flags %x  Signature %x  Feature %x\n",
+			  CpuEntry->LocalApicId,
+			  CpuEntry->LocalApicVersion,
+			  CpuEntry->CpuFlags,
+			  CpuEntry->CpuSignature,
+			  CpuEntry->FeatureFlags));
+		DbgPrint((DPRINT_HWDETECT,
+			  "Processor %u: x86 Family %u Model %u Stepping %u\n",
+			  CpuEntry->LocalApicId,
+			  (U32)((CpuEntry->CpuSignature >> 8) & 0x0F),
+			  (U32)((CpuEntry->CpuSignature >> 4) & 0x0F),
+			  (U32)(CpuEntry->CpuSignature & 0x0F)));
+
+		SetMpsProcessor(CpuKey, FpuKey, CpuEntry);
+		Offset += 0x14;
+		break;
+
+	      case 1:
+		DbgPrint((DPRINT_HWDETECT, "Bus Entry\n"));
+		Offset += 0x08;
+		break;
+
+	      case 2:
+		DbgPrint((DPRINT_HWDETECT, "I/0 APIC Entry\n"));
+		Offset += 0x08;
+		break;
+
+	      case 3:
+		DbgPrint((DPRINT_HWDETECT, "I/0 Interrupt Assignment Entry\n"));
+		Offset += 0x08;
+		break;
+
+	      case 4:
+		DbgPrint((DPRINT_HWDETECT, "Local Interrupt Assignment Entry\n"));
+		Offset += 0x08;
+		break;
+
+	      default:
+		DbgPrint((DPRINT_HWDETECT, "Unknown Entry %u\n",(U32)*Ptr));
+		return FALSE;
+	    }
+	}
+    }
+  else
+    {
+      DbgPrint((DPRINT_HWDETECT,
+	       "Unsupported MPS configuration: %x\n",
+	       FpTable->FeatureByte[0]));
+
+      /* FIXME: Identify default configurations */
+
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+
+
+VOID
+DetectCPUs(HKEY SystemKey)
+{
+  HKEY CpuKey;
+  HKEY FpuKey;
+  S32 Error;
+
+  /* Create the 'CentralProcessor' key */
+  Error = RegCreateKey(SystemKey,
+		       "CentralProcessor",
+		       &CpuKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  /* Create the 'FloatingPointProcessor' key */
+  Error = RegCreateKey(SystemKey,
+		       "FloatingPointProcessor",
+		       &FpuKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+      return;
+    }
+
+  /* Detect CPUs */
+  if (!DetectMps(CpuKey, FpuKey))
+    {
+      DetectCPU(CpuKey, FpuKey);
+    }
+}
+
+/* EOF */

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

@@ -0,0 +1,131 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 2003  Eric Kohl  <ekohl@rz-online.de>
+ *
+ *  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+
+#include <arch.h>
+
+/*
+ * U32 CpuidSupported(VOID);
+ *
+ * RETURNS:
+ *    0x00000001: CPU supports the CPUID instruction
+ *    0x00000300: Found 80386 CPU
+ *    0x00000400: Found 80486 CPU without CPUID support
+ */
+
+EXTERN(_CpuidSupported)
+	.code32
+
+	pushl	%ecx			/* save ECX */
+
+	pushfl				/* push original EFLAGS */
+	popl	%eax			/* get original EFLAGS */
+	movl	%eax,%ecx		/* save original EFLAGS */
+	xorl	$0x40000,%eax		/* flip AC bit in EFLAGS */
+	pushl	%eax			/* save new EFLAGS value on stack */
+	popfl				/* replace current EFLAGS value */
+
+	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 */
+
+	pushl	%ecx
+	popfl				/* restore AC bit in EFLAGS first */
+
+	movl	%ecx,%eax		/* get original 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 */
+	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 */
+
+	movl	$1,%eax			/* CPUID supported */
+
+NoCpuid:
+	pushl	%ecx
+	popfl				/* restore EFLAGS */
+	popl	%ecx			/* retore ECX */
+
+	ret
+
+
+/*
+ * VOID GetCpuid(U32 Level, U32 *eax, U32 *ebx, U32 *ecx, U32 *edx);
+ */
+
+EXTERN(_GetCpuid)
+	.code32
+
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushl	%eax
+	pushl	%ebx
+	pushl	%ecx
+	pushl	%edx
+	pushl	%esi
+
+	movl	0x08(%ebp),%eax
+
+	cpuid
+
+	movl	0x0C(%ebp),%esi
+	movl	%eax,(%esi)
+
+	movl	0x10(%ebp),%esi
+	movl	%ebx,(%esi)
+
+	movl	0x14(%ebp),%esi
+	movl	%ecx,(%esi)
+
+	movl	0x18(%ebp),%esi
+	movl	%edx,(%esi)
+
+	popl	%esi
+	popl	%edx
+	popl	%ecx
+	popl	%ebx
+	popl	%eax
+
+	movl	%ebp,%esp
+	popl	%ebp
+	ret
+
+
+/*
+ * U64 RDTSC(VOID);
+ */
+
+EXTERN(_RDTSC)
+	.code32
+	rdtsc
+	ret
+
+/* EOF */

freeldr/freeldr/arch/i386/i386disk.c

@@ -0,0 +1,175 @@
+/*
+ *  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"
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __i386__
+
+BOOL DiskResetController(U32 DriveNumber)
+{
+	REGS	RegsIn;
+	REGS	RegsOut;
+
+	DbgPrint((DPRINT_DISK, "DiskResetController(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);
+}
+
+BOOL DiskInt13ExtensionsSupported(U32 DriveNumber)
+{
+	REGS	RegsIn;
+	REGS	RegsOut;
+
+	DbgPrint((DPRINT_DISK, "DiskInt13ExtensionsSupported()\n"));
+
+	// 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)
+		return FALSE;
+	}
+
+	if (RegsOut.w.bx != 0xAA55)
+	{
+		// BX = AA55h if installed
+		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
+		return FALSE;
+	}
+#endif
+
+	// Use this relaxed check instead
+	if (RegsOut.w.cx == 0x0000)
+	{
+		// CX = API subset support bitmap
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+VOID DiskStopFloppyMotor(VOID)
+{
+	WRITE_PORT_UCHAR((PUCHAR)0x3F2, 0);
+}
+
+BOOL DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSize)
+{
+	REGS	RegsIn;
+	REGS	RegsOut;
+	PU16	Ptr = (PU16)(BIOSCALLBUFFER);
+
+	DbgPrint((DPRINT_DISK, "DiskGetExtendedDriveParameters()\n"));
+
+	// Initialize transfer buffer
+	*Ptr = BufferSize;
+
+	// BIOS Int 13h, function 48h - Get drive parameters
+	// AH = 48h
+	// DL = drive (bit 7 set for hard disk)
+	// DS:SI = result buffer
+	// Return:
+	// CF set on error
+	// AH = status (07h)
+	// CF clear if successful
+	// AH = 00h
+	// DS:SI -> result buffer
+	RegsIn.b.ah = 0x48;
+	RegsIn.b.dl = DriveNumber;
+	RegsIn.x.ds = BIOSCALLBUFSEGMENT;	// DS:SI -> result buffer
+	RegsIn.w.si = BIOSCALLBUFOFFSET;
+
+	// Get drive parameters
+	Int386(0x13, &RegsIn, &RegsOut);
+
+	if (!INT386_SUCCESS(RegsOut))
+	{
+		return FALSE;
+	}
+
+	memcpy(Buffer, Ptr, BufferSize);
+
+	return TRUE;
+}
+
+#endif // defined __i386__

freeldr/freeldr/arch/i386/i386idt.S

@@ -0,0 +1,224 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+
+
+	.p2align	2	/* force 4-byte alignment */
+EXTERN(i386idt)
+	/* Exception 0 - Divide By Zero */
+	.word	i386DivideByZero			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Flags, Zero Byte */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 1 - Debug Exception */
+	.word	i386DebugException			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 2 - NMI */
+	.word	i386NMIException			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 3 - Breakpoint (INT 3) */
+	.word	i386Breakpoint				/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 4 - Overflow (INTO with EFLAGS[OF] set) */
+	.word	i386Overflow				/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 5 - Bound Exception */
+	.word	i386BoundException			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 6 - Invalid Opcode */
+	.word	i386InvalidOpcode			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 7 - FPU Not Available */
+	.word	i386FPUNotAvailable			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 8 - Double Fault */
+	.word	i386DoubleFault				/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 9 - Coprocessor Segment Overrun */
+	.word	i386CoprocessorSegment		/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 10 (0x0A) - Invalid TSS */
+	.word	i386InvalidTSS				/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 11 (0x0B) - Segment Not Present */
+	.word	i386SegmentNotPresent		/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 12 (0x0C) - Stack Exception */
+	.word	i386StackException			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 13 (0x0D) - General Protection Fault */
+	.word	i386GeneralProtectionFault	/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 14 (0x0E) - Page Fault */
+	.word	i386PageFault				/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 15 (0x0F) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 16 (0x10) - Coprocessor Error */
+	.word	i386CoprocessorError		/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 17 (0x11) - Alignment Check */
+	.word	i386AlignmentCheck			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 18 (0x12) - Machine Check */
+	.word	i386MachineCheck			/* Offset 0 - 15 */
+	.word	0x0008						/* Selector */
+	.word	0x8e00						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 19 (0x13) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 20 (0x14) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 21 (0x15) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 22 (0x16) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 23 (0x17) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 24 (0x18) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 25 (0x19) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 26 (0x1A) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 27 (0x1B) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 28 (0x1C) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 29 (0x1D) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 30 (0x1E) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+	/* Exception 31 (0x1F) - Reserved */
+	.word	0x0000						/* Offset 0 - 15 */
+	.word	0x0000						/* Selector */
+	.word	0x0000						/* Zero byte, flags */
+	.word	0x0000						/* Offset 16 - 31 */
+
+/* IDT table pointer */
+EXTERN(i386idtptr)
+	.word	(i386idtptr-i386idt)		/* Limit */
+	.long	i386idt						/* Base Address */

freeldr/freeldr/arch/i386/i386pnp.S

@@ -0,0 +1,257 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 2003  Eric Kohl  <ekohl@rz-online.de>
+ *
+ *  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+
+#include <arch.h>
+
+
+/*
+ * U32 PnpBiosSupported(VOID);
+ *
+ * RETURNS:
+ */
+_pnp_bios_entry_point:
+	.long	0
+_pnp_bios_data_segment:
+	.word	0
+
+EXTERN(_PnpBiosSupported)
+	.code32
+
+	pushl	%edi
+	pushl	%esi
+	pushl	%ecx
+	pushl	%edx
+
+	xorl	%edi,%edi
+
+	/* init esi */
+	movl	$0xF0000,%esi
+
+pnp_again:
+	movl	(%esi),%eax
+	cmp		$0x506E5024,%eax			/* "$PnP" */
+	je		pnp_found
+
+	cmp		$0xFFFF0,%esi
+	je		pnp_not_found
+
+pnp_add:
+	addl	$0x10,%esi
+	jmp		pnp_again
+
+pnp_found:
+	/* first calculate the checksum */
+	pushl	%esi
+
+	pushl	$0x21
+	popl	%ecx
+	xorl	%edx, %edx
+
+pnp_loop:
+	lodsb
+	addb	%al,%dl
+	loopl	pnp_loop
+
+	testb	%dl, %dl
+	popl	%esi
+	jnz		pnp_add
+
+	movl	%esi,%edi
+
+	/* Calculate the bios entry point (far pointer) */
+	xorl	%eax,%eax
+	movw	0x0F(%esi),%ax
+	shll	$16,%eax
+	movw	0x0D(%esi),%ax
+	movl	%eax,_pnp_bios_entry_point
+
+	/* Store bios data segment */
+	movw	0x1B(%esi),%ax
+	movw	%ax,_pnp_bios_data_segment
+
+pnp_not_found:
+	movl	%edi,%eax
+
+	popl	%edx
+	popl	%ecx
+	popl	%esi
+	popl	%edi
+
+	ret
+
+
+/*
+ * U32 PnpBiosGetDeviceNodeCount(U32 *NodeSize, U32 *NodeCount);
+ *
+ * RETURNS:
+ */
+_pnp_result:
+	.long	0
+_pnp_node_size:
+	.word	0
+_pnp_node_count:
+	.word	0
+
+EXTERN(_PnpBiosGetDeviceNodeCount)
+	.code32
+
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushal
+	push	%es
+
+	call	switch_to_real
+	.code16
+
+	movw	_pnp_bios_data_segment,%ax
+	pushw	%ax
+
+	pushw	%cs
+	movw	$(_pnp_node_size),%ax
+	pushw	%ax
+
+	pushw	%cs
+	movw	$(_pnp_node_count),%ax
+	pushw	%ax
+
+	pushw	$0
+
+	lcall	*_pnp_bios_entry_point
+	addw	$12,%sp
+
+	movzwl	%ax,%ecx
+	movl	%ecx,_pnp_result
+
+	
+	call	switch_to_prot
+	.code32
+
+	movl	0x08(%ebp),%esi
+	movw	_pnp_node_size,%ax
+	movzwl	%ax,%ecx
+	movl	%ecx, (%esi)
+
+	movl	0x0C(%ebp),%esi
+	movw	_pnp_node_count,%ax
+	movzwl	%ax,%ecx
+	movl	%eax, (%esi)
+
+	pop		%es
+	popal
+
+	movl	%ebp,%esp
+	popl	%ebp
+
+	movl	_pnp_result,%eax
+
+	ret
+
+
+/*
+ * U32 PnpBiosGetDeviceNode(U8 *NodeId, U8 *NodeBuffer);
+ *
+ * RETURNS:
+ */
+_pnp_buffer_segment:
+	.word	0
+_pnp_buffer_offset:
+	.word	0
+
+_pnp_node_number:
+	.byte	0
+
+EXTERN(_PnpBiosGetDeviceNode)
+	.code32
+
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushal
+	push	%es
+
+	/* get current node number */
+	movl	0x08(%ebp),%esi
+	movb	(%esi),%al
+	movb	%al,_pnp_node_number
+
+	/* convert pointer to node buffer to segment/offset */ 
+	movl	0x0C(%ebp),%eax
+	shrl	$4,%eax
+	andl	$0xf000,%eax
+	movw	%ax,_pnp_buffer_segment	
+	movl	0x0C(%ebp),%eax
+	andl	$0xffff,%eax
+	movw	%ax,_pnp_buffer_offset	
+
+	call	switch_to_real
+	.code16
+
+	/* push bios segment */
+	movw	_pnp_bios_data_segment,%ax
+	pushw	%ax
+
+	/* push control flag */	
+	pushw	$0x0001
+
+	/* push pointer to node buffer (segment/offset) */
+	movw	_pnp_buffer_segment,%ax
+	pushw	%ax
+	movw	_pnp_buffer_offset,%ax
+	pushw	%ax
+
+	/* push pointer to node number (segment/offset) */
+	pushw	%cs
+	movw	$(_pnp_node_number),%ax
+	pushw	%ax
+
+	/* push function number */
+	pushw	$1
+
+	/* call entry point */
+	lcall	*_pnp_bios_entry_point
+	addw	$14,%sp
+
+	movzwl	%ax,%ecx
+	movl	%ecx,_pnp_result
+
+	call	switch_to_prot
+	.code32
+
+	/* update node number */
+	movl	0x08(%ebp),%esi
+	movb	_pnp_node_number,%al
+	movb	%al,(%esi)
+
+	pop		%es
+	popal
+
+	movl	%ebp,%esp
+	popl	%ebp
+
+	movl	_pnp_result,%eax
+
+	ret
+
+/* EOF */

freeldr/freeldr/arch/i386/i386rtl.c

@@ -0,0 +1,90 @@
+/*
+ *  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 <rtl.h>
+#include <portio.h>
+
+void beep(void)
+{
+	sound(700);
+	delay(200);
+	sound(0);
+}
+
+void delay(unsigned msec)
+{
+	REGS		Regs;
+	unsigned	usec;
+	unsigned	msec_this;
+
+	// Int 15h AH=86h
+	// BIOS - WAIT (AT,PS)
+	//
+	// AH = 86h
+	// CX:DX = interval in microseconds
+	// Return:
+	// CF clear if successful (wait interval elapsed)
+	// CF set on error or AH=83h wait already in progress
+	// AH = status (see #00496)
+
+	// Note: The resolution of the wait period is 977 microseconds on
+	// many systems because many BIOSes use the 1/1024 second fast
+	// interrupt from the AT real-time clock chip which is available on INT 70;
+	// because newer BIOSes may have much more precise timers available, it is
+	// not possible to use this function accurately for very short delays unless
+	// the precise behavior of the BIOS is known (or found through testing) 
+
+	while (msec)
+	{
+		msec_this = msec;
+		
+		if (msec_this > 4000)
+		{
+			msec_this = 4000;
+		}
+
+		usec = msec_this * 1000;
+
+		Regs.b.ah = 0x86;
+		Regs.w.cx = usec >> 16;
+		Regs.w.dx = usec & 0xffff;
+		Int386(0x15, &Regs, &Regs);
+
+		msec -= msec_this;
+	}
+}
+
+void sound(int freq)
+{
+	int scale;
+
+	if (freq == 0)
+	{
+		WRITE_PORT_UCHAR((PUCHAR)0x61, READ_PORT_UCHAR((PUCHAR)0x61) & ~3);
+		return;
+	}
+
+	scale = 1193046 / freq;
+	WRITE_PORT_UCHAR((PUCHAR)0x43, 0xb6);
+	WRITE_PORT_UCHAR((PUCHAR)0x42, scale & 0xff);
+	WRITE_PORT_UCHAR((PUCHAR)0x42, scale >> 8);
+	WRITE_PORT_UCHAR((PUCHAR)0x61, READ_PORT_UCHAR((PUCHAR)0x61) | 3);
+}

freeldr/freeldr/arch/i386/i386trap.S

@@ -0,0 +1,942 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+#include <version.h>
+
+#define SCREEN_ATTR 0x1f			/* Bright white on blue background */
+
+.macro SAVE_CPU_REGS
+	movl	%eax,i386_EAX
+	movl	%ebx,i386_EBX
+	movl	%ecx,i386_ECX
+	movl	%edx,i386_EDX
+	movl	%esp,i386_ESP
+	movl	%ebp,i386_EBP
+	movl	%esi,i386_ESI
+	movl	%edi,i386_EDI
+	movw	%ds,%ax
+	movw	%ax,i386_DS
+	movw	%es,%ax
+	movw	%ax,i386_ES
+	movw	%fs,%ax
+	movw	%ax,i386_FS
+	movw	%gs,%ax
+	movw	%ax,i386_GS
+	movw	%ss,%ax
+	movw	%ax,i386_SS
+	popl	%eax
+	movl	%eax,i386_EIP
+	popl	%eax
+	movw	%ax,i386_CS
+	popl	%eax
+	movl	%eax,i386_EFLAGS
+	movl	%cr0,%eax
+	movl	%eax,i386_CR0
+	//movl	%cr1,%eax
+	//movl	%eax,i386_CR1
+	movl	%cr2,%eax
+	movl	%eax,i386_CR2
+	movl	%cr3,%eax
+	movl	%eax,i386_CR3
+	movl	%dr0,%eax
+	movl	%eax,i386_DR0
+	movl	%dr1,%eax
+	movl	%eax,i386_DR1
+	movl	%dr2,%eax
+	movl	%eax,i386_DR2
+	movl	%dr3,%eax
+	movl	%eax,i386_DR3
+	movl	%dr6,%eax
+	movl	%eax,i386_DR6
+	movl	%dr7,%eax
+	movl	%eax,i386_DR7
+	sgdt	i386_GDTR
+	sidt	i386_IDTR
+	sldt	i386_LDTR
+	str		i386_TR
+.endm
+
+
+
+i386ExceptionHandlerText:
+	.ascii "An error occured in FreeLoader\n"
+	.ascii VERSION
+	.ascii "\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"
+i386DebugExceptionText:
+	.asciz "Exception 01: DEBUG EXCEPTION\n\n"
+i386NMIExceptionText:
+	.asciz "Exception 02: NON-MASKABLE INTERRUPT EXCEPTION\n\n"
+i386BreakpointText:
+	.asciz "Exception 03: BREAKPOINT (INT 3)\n\n"
+i386OverflowText:
+	.asciz "Exception 04: OVERFLOW\n\n"
+i386BoundExceptionText:
+	.asciz "Exception 05: BOUND EXCEPTION\n\n"
+i386InvalidOpcodeText:
+	.asciz "Exception 06: INVALID OPCODE\n\n"
+i386FPUNotAvailableText:
+	.asciz "Exception 07: FPU NOT AVAILABLE\n\n"
+i386DoubleFaultText:
+	.asciz "Exception 08: DOUBLE FAULT\n\n"
+i386CoprocessorSegmentText:
+	.asciz "Exception 09: COPROCESSOR SEGMENT OVERRUN\n\n"
+i386InvalidTSSText:
+	.asciz "Exception 0A: INVALID TSS\n\n"
+i386SegmentNotPresentText:
+	.asciz "Exception 0B: SEGMENT NOT PRESENT\n\n"
+i386StackExceptionText:
+	.asciz "Exception 0C: STACK EXCEPTION\n\n"
+i386GeneralProtectionFaultText:
+	.asciz "Exception 0D: GENERAL PROTECTION FAULT\n\n"
+i386PageFaultText:
+	.asciz "Exception 0E: PAGE FAULT\n\n"
+i386CoprocessorErrorText:
+	.asciz "Exception 10: COPROCESSOR ERROR\n\n"
+i386AlignmentCheckText:
+	.asciz "Exception 11: ALIGNMENT CHECK\n\n"
+i386MachineCheckText:
+	.asciz "Exception 12: MACHINE CHECK\n\n"
+
+i386_EAX_Text:
+	.asciz "EAX: "
+i386_EBX_Text:
+	.asciz "EBX: "
+i386_ECX_Text:
+	.asciz "ECX: "
+i386_EDX_Text:
+	.asciz "EDX: "
+i386_ESP_Text:
+	.asciz "        ESP: "
+i386_EBP_Text:
+	.asciz "        EBP: "
+i386_ESI_Text:
+	.asciz "        ESI: "
+i386_EDI_Text:
+	.asciz "        EDI: "
+i386_CS_Text:
+	.asciz "CS: "
+i386_DS_Text:
+	.asciz "DS: "
+i386_ES_Text:
+	.asciz "ES: "
+i386_FS_Text:
+	.asciz "FS: "
+i386_GS_Text:
+	.asciz "GS: "
+i386_SS_Text:
+	.asciz "SS: "
+i386_EFLAGS_Text:
+	.asciz "        EFLAGS: "
+i386_EIP_Text:
+	.asciz "        EIP: "
+i386_ERROR_CODE_Text:
+	.asciz "        ERROR CODE: "
+i386_CR0_Text:
+	.asciz "        CR0: "
+i386_CR1_Text:
+	.asciz "        CR1: "
+i386_CR2_Text:
+	.asciz "        CR2: "
+i386_CR3_Text:
+	.asciz "        CR3: "
+i386_DR0_Text:
+	.asciz "        DR0: "
+i386_DR1_Text:
+	.asciz "        DR1: "
+i386_DR2_Text:
+	.asciz "        DR2: "
+i386_DR3_Text:
+	.asciz "        DR3: "
+i386_DR6_Text:
+	.asciz "        DR6: "
+i386_DR7_Text:
+	.asciz "        DR7: "
+i386_GDTR_Text:
+	.asciz "        GDTR Base: "
+i386_IDTR_Text:
+	.asciz "        IDTR Base: "
+i386_Limit_Text:
+	.asciz " Limit: "
+i386_LDTR_Text:
+	.asciz "        LDTR: "
+i386_TR_Text:
+	.asciz " TR: "
+
+i386FramesText:
+	.asciz "Frames:\n"
+
+/* Set by each exception handler to the address of the description text */
+i386ExceptionDescriptionText:
+	.long	0
+
+/* Used to store the contents of all the registers when an exception occurs */
+i386_EAX:
+	.long	0
+i386_EBX:
+	.long	0
+i386_ECX:
+	.long	0
+i386_EDX:
+	.long	0
+i386_ESP:
+	.long	0
+i386_EBP:
+	.long	0
+i386_ESI:
+	.long	0
+i386_EDI:
+	.long	0
+i386_CS:
+	.word	0
+i386_DS:
+	.word	0
+i386_ES:
+	.word	0
+i386_FS:
+	.word	0
+i386_GS:
+	.word	0
+i386_SS:
+	.word	0
+i386_EFLAGS:
+	.long	0
+i386_EIP:
+	.long	0
+i386_ERROR_CODE:
+	.long	0
+i386_CR0:
+	.long	0
+i386_CR1:
+	.long	0
+i386_CR2:
+	.long	0
+i386_CR3:
+	.long	0
+i386_DR0:
+	.long	0
+i386_DR1:
+	.long	0
+i386_DR2:
+	.long	0
+i386_DR3:
+	.long	0
+i386_DR6:
+	.long	0
+i386_DR7:
+	.long	0
+i386_GDTR:
+	.word	0
+	.long	0
+i386_IDTR:
+	.word	0
+	.long	0
+i386_LDTR:
+	.word	0
+i386_TR:
+	.word	0
+
+/* Used to store the current X and Y position on the screen */
+i386_ScreenPosX:
+	.long	0
+i386_ScreenPosY:
+	.long	0
+
+/************************************************************************/
+i386CommonExceptionHandler:
+	.code32
+
+	SAVE_CPU_REGS
+
+	pushl	$SCREEN_ATTR
+	call	_MachVideoClearScreen
+	add	$4,%esp
+
+	movl	$i386ExceptionHandlerText,%esi
+	call	i386PrintText
+
+	movl	i386ExceptionDescriptionText,%esi
+	call	i386PrintText
+
+	movl	$i386_EAX_Text,%esi
+	call	i386PrintText
+	movl	i386_EAX,%eax
+	call	i386PrintHexDword					// Display EAX
+	movl	$i386_ESP_Text,%esi
+	call	i386PrintText
+	movl	i386_ESP,%eax
+	call	i386PrintHexDword					// Display ESP
+	movl	$i386_CR0_Text,%esi
+	call	i386PrintText
+	movl	i386_CR0,%eax
+	call	i386PrintHexDword					// Display CR0
+	movl	$i386_DR0_Text,%esi
+	call	i386PrintText
+	movl	i386_DR0,%eax
+	call	i386PrintHexDword					// Display DR0
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_EBX_Text,%esi
+	call	i386PrintText
+	movl	i386_EBX,%eax
+	call	i386PrintHexDword					// Display EBX
+	movl	$i386_EBP_Text,%esi
+	call	i386PrintText
+	movl	i386_EBP,%eax
+	call	i386PrintHexDword					// Display EBP
+	movl	$i386_CR1_Text,%esi
+	call	i386PrintText
+	movl	i386_CR1,%eax
+	call	i386PrintHexDword					// Display CR1
+	movl	$i386_DR1_Text,%esi
+	call	i386PrintText
+	movl	i386_DR1,%eax
+	call	i386PrintHexDword					// Display DR1
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_ECX_Text,%esi
+	call	i386PrintText
+	movl	i386_ECX,%eax
+	call	i386PrintHexDword					// Display ECX
+	movl	$i386_ESI_Text,%esi
+	call	i386PrintText
+	movl	i386_ESI,%eax
+	call	i386PrintHexDword					// Display ESI
+	movl	$i386_CR2_Text,%esi
+	call	i386PrintText
+	movl	i386_CR2,%eax
+	call	i386PrintHexDword					// Display CR2
+	movl	$i386_DR2_Text,%esi
+	call	i386PrintText
+	movl	i386_DR2,%eax
+	call	i386PrintHexDword					// Display DR2
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_EDX_Text,%esi
+	call	i386PrintText
+	movl	i386_EDX,%eax
+	call	i386PrintHexDword					// Display EDX
+	movl	$i386_EDI_Text,%esi
+	call	i386PrintText
+	movl	i386_EDI,%eax
+	call	i386PrintHexDword					// Display EDI
+	movl	$i386_CR3_Text,%esi
+	call	i386PrintText
+	movl	i386_CR3,%eax
+	call	i386PrintHexDword					// Display CR3
+	movl	$i386_DR3_Text,%esi
+	call	i386PrintText
+	movl	i386_DR3,%eax
+	call	i386PrintHexDword					// Display DR3
+	incl	i386_ScreenPosY
+	movl	$55,i386_ScreenPosX
+	movl	$i386_DR6_Text,%esi
+	call	i386PrintText
+	movl	i386_DR6,%eax
+	call	i386PrintHexDword					// Display DR6
+	incl	i386_ScreenPosY
+	movl	$55,i386_ScreenPosX
+	movl	$i386_DR7_Text,%esi
+	call	i386PrintText
+	movl	i386_DR7,%eax
+	call	i386PrintHexDword					// Display DR7
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	incl	i386_ScreenPosY
+	movl	$i386_CS_Text,%esi
+	call	i386PrintText
+	movw	i386_CS,%ax
+	call	i386PrintHexWord					// Display CS
+	movl	$i386_EIP_Text,%esi
+	call	i386PrintText
+	movl	i386_EIP,%eax
+	call	i386PrintHexDword					// Display EIP
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_DS_Text,%esi
+	call	i386PrintText
+	movw	i386_DS,%ax
+	call	i386PrintHexWord					// Display DS
+	movl	$i386_ERROR_CODE_Text,%esi
+	call	i386PrintText
+	movl	i386_ERROR_CODE,%eax
+	call	i386PrintHexDword					// Display ERROR CODE
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_ES_Text,%esi
+	call	i386PrintText
+	movw	i386_ES,%ax
+	call	i386PrintHexWord					// Display ES
+	movl	$i386_EFLAGS_Text,%esi
+	call	i386PrintText
+	movl	i386_EFLAGS,%eax
+	call	i386PrintHexDword					// Display EFLAGS
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_FS_Text,%esi
+	call	i386PrintText
+	movw	i386_FS,%ax
+	call	i386PrintHexWord					// Display FS
+	movl	$i386_GDTR_Text,%esi
+	call	i386PrintText
+	movl	i386_GDTR+2,%eax
+	call	i386PrintHexDword					// Display GDTR Base
+	movl	$i386_Limit_Text,%esi
+	call	i386PrintText
+	movw	i386_GDTR,%ax
+	call	i386PrintHexWord					// Display GDTR Limit
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_GS_Text,%esi
+	call	i386PrintText
+	movw	i386_GS,%ax
+	call	i386PrintHexWord					// Display GS
+	movl	$i386_IDTR_Text,%esi
+	call	i386PrintText
+	movl	i386_IDTR+2,%eax
+	call	i386PrintHexDword					// Display IDTR Base
+	movl	$i386_Limit_Text,%esi
+	call	i386PrintText
+	movw	i386_IDTR,%ax
+	call	i386PrintHexWord					// Display IDTR Limit
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	movl	$i386_SS_Text,%esi
+	call	i386PrintText
+	movw	i386_SS,%ax
+	call	i386PrintHexWord					// Display SS
+	movl	$i386_LDTR_Text,%esi
+	call	i386PrintText
+	movw	i386_LDTR,%ax
+	call	i386PrintHexWord					// Display LDTR
+	movl	$i386_TR_Text,%esi
+	call	i386PrintText
+	movw	i386_TR,%ax
+	call	i386PrintHexWord					// Display TR
+	movl	$0,i386_ScreenPosX
+	incl	i386_ScreenPosY
+	incl	i386_ScreenPosY
+	call	i386PrintFrames						// Display frames
+	incl	i386_ScreenPosY
+	incl	i386_ScreenPosY
+
+	cli
+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
+
+/************************************************************************/
+/* AL = Char to display                                                 */
+/************************************************************************/
+i386PrintChar:
+	.code32
+
+	pushl	i386_ScreenPosY
+	pushl	i386_ScreenPosX
+	pushl	$SCREEN_ATTR
+	andl	$0xff,%eax
+	pushl	%eax
+	call	_MachVideoPutChar
+	addl	$16,%esp
+
+	ret
+
+/************************************************************************/
+/* ESI = Address of text to display                                     */
+/************************************************************************/
+i386PrintText:
+	.code32
+
+i386PrintTextLoop:
+	lodsb
+
+	// Check for end of string char
+	cmp	$0,%al
+	je	i386PrintTextDone
+
+	// Check for newline char
+	cmp	$0x0a,%al
+	jne	i386PrintTextLoop2
+	incl	i386_ScreenPosY
+	movl	$0,i386_ScreenPosX
+	jmp	i386PrintTextLoop
+
+i386PrintTextLoop2:
+	call	i386PrintChar
+	incl	i386_ScreenPosX
+
+	jmp	i386PrintTextLoop
+
+i386PrintTextDone:
+	
+	ret
+
+/************************************************************************/
+/* Prints the value in EAX on the screen in hex                         */
+/************************************************************************/
+i386PrintHexDword:
+	.code32
+
+	call	i386PrintHex1
+
+i386PrintHex1:
+	call	i386PrintHex2
+i386PrintHex2:
+	call	i386PrintHex3
+i386PrintHex3:
+	movb	$4,%cl
+	rol		%cl,%eax
+	push	%eax
+	andb	$0x0f,%al
+	movl	$i386PrintHexTable,%ebx
+	xlat	/*$i386PrintHexTable*/
+	call	i386PrintChar
+	incl	i386_ScreenPosX
+	pop		%eax
+
+	ret
+
+i386PrintHexTable:
+	.ascii	"0123456789ABCDEF"
+
+/************************************************************************/
+/* Prints the value in AX on the screen in hex                         */
+/************************************************************************/
+i386PrintHexWord:
+	.code32
+
+	call	i386PrintHexWord1
+i386PrintHexWord1:
+	call	i386PrintHexWord2
+i386PrintHexWord2:
+	movb	$4,%cl
+	rol		%cl,%ax
+	push	%eax
+	andb	$0x0f,%al
+	movl	$i386PrintHexTable,%ebx
+	xlat	/*$i386PrintHexTable*/
+	call	i386PrintChar
+	incl	i386_ScreenPosX
+	pop	%eax
+
+	ret
+
+/************************************************************************/
+/* Prints the value in AL on the screen in hex                         */
+/************************************************************************/
+i386PrintHexByte:
+	.code32
+
+	call	i386PrintHexByte1
+i386PrintHexByte1:
+	movb	$4,%cl
+	rol		%cl,%al
+	push	%eax
+	andb	$0x0f,%al
+	movl	$i386PrintHexTable,%ebx
+	xlat	/*$i386PrintHexTable*/
+	call	i386PrintChar
+	incl	i386_ScreenPosX
+	pop		%eax
+
+	ret
+
+/************************************************************************/
+EXTERN(i386DivideByZero)
+	.code32
+
+	movl	$i386DivideByZeroText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386DebugException)
+	.code32
+
+	movl	$i386DebugExceptionText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386NMIException)
+	.code32
+
+	movl	$i386NMIExceptionText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386Breakpoint)
+	.code32
+
+	movl	$i386BreakpointText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386Overflow)
+	.code32
+
+	movl	$i386OverflowText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386BoundException)
+	.code32
+
+	movl	$i386BoundExceptionText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386InvalidOpcode)
+	.code32
+
+	movl	$i386InvalidOpcodeText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386FPUNotAvailable)
+	.code32
+
+	movl	$i386FPUNotAvailableText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386DoubleFault)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386DoubleFaultText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386CoprocessorSegment)
+	.code32
+
+	movl	$i386CoprocessorSegmentText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386InvalidTSS)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386InvalidTSSText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386SegmentNotPresent)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386SegmentNotPresentText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386StackException)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386StackExceptionText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386GeneralProtectionFault)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386GeneralProtectionFaultText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386PageFault)
+	.code32
+
+	popl	%eax
+	movl	%eax,i386_ERROR_CODE
+
+	movl	$i386PageFaultText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386CoprocessorError)
+	.code32
+
+	movl	$i386CoprocessorErrorText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386AlignmentCheck)
+	.code32
+
+	movl	$i386AlignmentCheckText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************/
+EXTERN(i386MachineCheck)
+	.code32
+
+	movl	$i386MachineCheckText,i386ExceptionDescriptionText
+	jmp		i386CommonExceptionHandler
+
+/************************************************************************
+ * DEBUGGING SUPPORT FUNCTIONS
+ ************************************************************************/
+EXTERN(_INSTRUCTION_BREAKPOINT1)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr0
+	movl	%dr7,%eax
+	andl	$0xfff0ffff,%eax
+	orl		$0x00000303,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_READWRITE_BREAKPOINT1)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr0
+	movl	%dr7,%eax
+	andl	$0xfff0ffff,%eax
+	orl		$0x00030303,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_WRITE_BREAKPOINT1)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr0
+	movl	%dr7,%eax
+	andl	$0xfff0ffff,%eax
+	orl		$0x00010303,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_INSTRUCTION_BREAKPOINT2)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr1
+	movl	%dr7,%eax
+	andl	$0xff0fffff,%eax
+	orl		$0x0000030c,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_READWRITE_BREAKPOINT2)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr1
+	movl	%dr7,%eax
+	andl	$0xff0fffff,%eax
+	orl		$0x0030030c,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_WRITE_BREAKPOINT2)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr1
+	movl	%dr7,%eax
+	andl	$0xff0fffff,%eax
+	orl		$0x0010030c,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_INSTRUCTION_BREAKPOINT3)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr2
+	movl	%dr7,%eax
+	andl	$0xf0ffffff,%eax
+	orl		$0x00000330,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_READWRITE_BREAKPOINT3)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr2
+	movl	%dr7,%eax
+	andl	$0xf0ffffff,%eax
+	orl		$0x03000330,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_WRITE_BREAKPOINT3)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr2
+	movl	%dr7,%eax
+	andl	$0xf0ffffff,%eax
+	orl		$0x01000330,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_INSTRUCTION_BREAKPOINT4)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr3
+	movl	%dr7,%eax
+	andl	$0x0fffffff,%eax
+	orl		$0x000003c0,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_READWRITE_BREAKPOINT4)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr3
+	movl	%dr7,%eax
+	andl	$0x0fffffff,%eax
+	orl		$0x300003c0,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret
+
+EXTERN(_MEMORY_WRITE_BREAKPOINT4)
+	.code32
+
+	pushl	%eax
+
+	movl	8(%esp),%eax
+
+	movl	%eax,%dr3
+	movl	%dr7,%eax
+	andl	$0x0fffffff,%eax
+	orl		$0x100003c0,%eax
+	movl	%eax,%dr7
+
+	popl	%eax
+
+	ret

freeldr/freeldr/arch/i386/i386vid.c

@@ -0,0 +1,251 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
+ *  Portions from Linux video.S - Display adapter & video mode setup, version 2.13 (14-May-99)
+ *  Copyright (C) 1995 -- 1999 Martin Mares <mj@ucw.cz>
+ *  Based on the original setup.S code (C) Linus Torvalds and Mats Anderson
+ *
+ *  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 <video.h>
+#include <portio.h>
+#include <rtl.h>
+#include <debug.h>
+
+typedef struct
+{
+	U8	Signature[4];				// (ret) signature ("VESA")
+									// (call) VESA 2.0 request signature ("VBE2"), required to receive
+									// version 2.0 info
+	U16	VesaVersion;				// VESA version number (one-digit minor version -- 0102h = v1.2)
+	U32 OemNamePtr;					// pointer to OEM name
+									// "761295520" for ATI
+	U32	Capabilities;				// capabilities flags (see #00078)
+	U32	SupportedModeListPtr;		// pointer to list of supported VESA and OEM video modes
+									// (list of words terminated with FFFFh)
+	U16	TotalVideoMemory;			// total amount of video memory in 64K blocks
+
+	// ---VBE v1.x ---
+	//U8	Reserved[236];
+
+	// ---VBE v2.0 ---
+	U16	OemSoftwareVersion;			// OEM software version (BCD, high byte = major, low byte = minor)
+	U32	VendorNamePtr;				// pointer to vendor name
+	U32	ProductNamePtr;				// pointer to product name
+	U32	ProductRevisionStringPtr;	// pointer to product revision string
+	U16	VBE_AF_Version;				// (if capabilities bit 3 set) VBE/AF version (BCD)
+									// 0100h for v1.0P
+	U32	AcceleratedModeListPtr;		// (if capabilities bit 3 set) pointer to list of supported
+									// accelerated video modes (list of words terminated with FFFFh)
+	U8	Reserved[216];				// reserved for VBE implementation
+	U8	ScratchPad[256];			// OEM scratchpad (for OEM strings, etc.)
+} PACKED VESA_SVGA_INFO, *PVESA_SVGA_INFO;
+
+// Bitfields for VESA capabilities:
+//
+// Bit(s)  Description     (Table 00078)
+// 0      DAC can be switched into 8-bit mode
+// 1      non-VGA controller
+// 2      programmed DAC with blank bit (i.e. only during blanking interval)
+// 3      (VBE v3.0) controller supports hardware stereoscopic signalling
+// 3      controller supports VBE/AF v1.0P extensions
+// 4      (VBE v3.0) if bit 3 set:
+// =0 stereo signalling via external VESA stereo connector
+// =1 stereo signalling via VESA EVC connector
+// 4      (VBE/AF v1.0P) must call EnableDirectAccess to access framebuffer
+// 5      (VBE/AF v1.0P) controller supports hardware mouse cursor
+// 6      (VBE/AF v1.0P) controller supports hardware clipping
+// 7      (VBE/AF v1.0P) controller supports transparent BitBLT
+// 8-31   reserved (0)
+
+// Notes: The list of supported video modes is stored in the reserved
+// portion of the SuperVGA information record by some implementations,
+// and it may thus be necessary to either copy the mode list or use a
+// different buffer for all subsequent VESA calls. Not all of the video
+// modes in the list of mode numbers may be supported, e.g. if they require
+// more memory than currently installed or are not supported by the
+// attached monitor. Check any mode you intend to use through AX=4F01h first..
+// The 1.1 VESA document specifies 242 reserved bytes at the end, so the
+// buffer should be 262 bytes to ensure that it is not overrun; for v2.0,
+// the buffer should be 512 bytes. The S3 specific video modes will most
+// likely follow the FFFFh terminator at the end of the standard modes.
+// A search must then be made to find them, FFFFh will also terminate this
+// second list. In some cases, only a "stub" VBE may be present, supporting
+// 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 BiosSetVideoFont8x16(VOID)
+{
+	REGS	Regs;
+
+	// Int 10h AX=1114h
+	// VIDEO - TEXT-MODE CHARGEN - LOAD ROM 8x16 CHARACTER SET (VGA)
+	//
+	// AX = 1114h
+	// BL = block to load
+	// Return:
+	// Nothing
+	Regs.w.ax = 0x1114;
+	Regs.b.bl = 0;
+	Int386(0x10, &Regs, &Regs);
+}
+
+VOID VideoSetTextCursorPosition(U32 X, U32 Y)
+{
+}
+
+U32 VideoGetTextCursorPositionX(VOID)
+{
+	REGS	Regs;
+
+	// Int 10h AH=03h
+	// VIDEO - GET CURSOR POSITION AND SIZE
+	//
+	// AH = 03h
+	// BH = page number
+	// 0-3 in modes 2&3
+	// 0-7 in modes 0&1
+	// 0 in graphics modes
+	// Return:
+	// AX = 0000h (Phoenix BIOS)
+	// CH = start scan line
+	// CL = end scan line
+	// DH = row (00h is top)
+	// DL = column (00h is left)
+	Regs.b.ah = 0x03;
+	Regs.b.bh = 0x00;
+	Int386(0x10, &Regs, &Regs);
+
+	return Regs.b.dl;
+}
+
+U32 VideoGetTextCursorPositionY(VOID)
+{
+	REGS	Regs;
+
+	// Int 10h AH=03h
+	// VIDEO - GET CURSOR POSITION AND SIZE
+	//
+	// AH = 03h
+	// BH = page number
+	// 0-3 in modes 2&3
+	// 0-7 in modes 0&1
+	// 0 in graphics modes
+	// Return:
+	// AX = 0000h (Phoenix BIOS)
+	// CH = start scan line
+	// CL = end scan line
+	// DH = row (00h is top)
+	// DL = column (00h is left)
+	Regs.b.ah = 0x03;
+	Regs.b.bh = 0x00;
+	Int386(0x10, &Regs, &Regs);
+
+	return Regs.b.dh;
+}
+
+U16 BiosIsVesaSupported(VOID)
+{
+	REGS			Regs;
+	PVESA_SVGA_INFO	SvgaInfo = (PVESA_SVGA_INFO)BIOSCALLBUFFER;
+#ifdef DEBUG
+	//U16*			VideoModes;
+	//U16			Index;
+#endif // defined DEBUG
+
+	DbgPrint((DPRINT_UI, "BiosIsVesaSupported()\n"));
+
+	RtlZeroMemory(SvgaInfo, sizeof(VESA_SVGA_INFO));
+
+	// Make sure we receive version 2.0 info
+	SvgaInfo->Signature[0] = 'V';
+	SvgaInfo->Signature[1] = 'B';
+	SvgaInfo->Signature[2] = 'E';
+	SvgaInfo->Signature[3] = '2';
+
+	// Int 10h AX=4F00h
+	// VESA SuperVGA BIOS (VBE) - GET SuperVGA INFORMATION
+	//
+	// AX = 4F00h
+	// ES:DI -> buffer for SuperVGA information (see #00077)
+	// Return:
+	// AL = 4Fh if function supported
+	// AH = status
+	//   00h successful
+	// ES:DI buffer filled
+	//   01h failed
+	//   ---VBE v2.0---
+	//   02h function not supported by current hardware configuration
+	//   03h function invalid in current video mode
+	//
+	// Determine whether VESA BIOS extensions are present and the
+	// capabilities supported by the display adapter
+	//
+	// Installation check;VESA SuperVGA
+	Regs.w.ax = 0x4F00;
+	Regs.w.es = BIOSCALLBUFSEGMENT;
+	Regs.w.di = BIOSCALLBUFOFFSET;
+	Int386(0x10, &Regs, &Regs);
+
+	DbgPrint((DPRINT_UI, "AL = 0x%x\n", Regs.b.al));
+	DbgPrint((DPRINT_UI, "AH = 0x%x\n", Regs.b.ah));
+
+	if (Regs.w.ax != 0x004F)
+	{
+		DbgPrint((DPRINT_UI, "Failed.\n"));
+		return 0x0000;
+	}
+
+#ifdef DEBUG
+	DbgPrint((DPRINT_UI, "Supported.\n"));
+	DbgPrint((DPRINT_UI, "SvgaInfo->Signature[4] = %c%c%c%c\n", SvgaInfo->Signature[0], SvgaInfo->Signature[1], SvgaInfo->Signature[2], SvgaInfo->Signature[3]));
+	DbgPrint((DPRINT_UI, "SvgaInfo->VesaVersion = v%d.%d\n", ((SvgaInfo->VesaVersion >> 8) & 0xFF), (SvgaInfo->VesaVersion & 0xFF)));
+	DbgPrint((DPRINT_UI, "SvgaInfo->OemNamePtr = 0x%x\n", SvgaInfo->OemNamePtr));
+	DbgPrint((DPRINT_UI, "SvgaInfo->Capabilities = 0x%x\n", SvgaInfo->Capabilities));
+	DbgPrint((DPRINT_UI, "SvgaInfo->VideoMemory = %dK\n", SvgaInfo->TotalVideoMemory * 64));
+	DbgPrint((DPRINT_UI, "---VBE v2.0 ---\n"));
+	DbgPrint((DPRINT_UI, "SvgaInfo->OemSoftwareVersion = v%d.%d\n", ((SvgaInfo->OemSoftwareVersion >> 8) & 0x0F) + (((SvgaInfo->OemSoftwareVersion >> 12) & 0x0F) * 10), (SvgaInfo->OemSoftwareVersion & 0x0F) + (((SvgaInfo->OemSoftwareVersion >> 4) & 0x0F) * 10)));
+	DbgPrint((DPRINT_UI, "SvgaInfo->VendorNamePtr = 0x%x\n", SvgaInfo->VendorNamePtr));
+	DbgPrint((DPRINT_UI, "SvgaInfo->ProductNamePtr = 0x%x\n", SvgaInfo->ProductNamePtr));
+	DbgPrint((DPRINT_UI, "SvgaInfo->ProductRevisionStringPtr = 0x%x\n", SvgaInfo->ProductRevisionStringPtr));
+	DbgPrint((DPRINT_UI, "SvgaInfo->VBE/AF Version = 0x%x (BCD WORD)\n", SvgaInfo->VBE_AF_Version));
+
+	//DbgPrint((DPRINT_UI, "\nSupported VESA and OEM video modes:\n"));
+	//VideoModes = (U16*)SvgaInfo->SupportedModeListPtr;
+	//for (Index=0; VideoModes[Index]!=0xFFFF; Index++)
+	//{
+	//	DbgPrint((DPRINT_UI, "Mode %d: 0x%x\n", Index, VideoModes[Index]));
+	//}
+
+	//if (SvgaInfo->VesaVersion >= 0x0200)
+	//{
+	//	DbgPrint((DPRINT_UI, "\nSupported accelerated video modes (VESA v2.0):\n"));
+	//	VideoModes = (U16*)SvgaInfo->AcceleratedModeListPtr;
+	//	for (Index=0; VideoModes[Index]!=0xFFFF; Index++)
+	//	{
+	//		DbgPrint((DPRINT_UI, "Mode %d: 0x%x\n", Index, VideoModes[Index]));
+	//	}
+	//}
+
+	DbgPrint((DPRINT_UI, "\n"));
+	//getch();
+#endif // defined DEBUG
+
+	return SvgaInfo->VesaVersion;
+}

freeldr/freeldr/arch/i386/int386.S

@@ -0,0 +1,155 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+
+
+Int386_REGS:
+
+Int386_eax:
+	.long 0
+Int386_ebx:
+	.long 0
+Int386_ecx:
+	.long 0
+Int386_edx:
+	.long 0
+
+Int386_esi:
+	.long 0
+Int386_edi:
+	.long 0
+
+Int386_ds:
+	.word 0
+Int386_es:
+	.word 0
+Int386_fs:
+	.word 0
+Int386_gs:
+	.word 0
+
+Int386_eflags:
+	.long 0
+
+Int386_vector:
+	.long 0
+Int386_regsin:
+	.long 0
+Int386_regsout:
+	.long 0
+
+/*
+ * int Int386(int ivec, REGS* in, REGS* out);
+ */
+EXTERN(_Int386)
+	.code32
+
+	/* Get the function parameters */
+	movl	0x04(%esp),%eax
+	movl	%eax,Int386_vector
+	movb	%al,Int386_vector_opcode
+	movl	0x08(%esp),%eax
+	movl	%eax,Int386_regsin
+	movl	0x0c(%esp),%eax
+	movl	%eax,Int386_regsout
+
+	pushal
+
+	/* Copy the input regs to our variables */
+	movl	$Int386_REGS,%edi
+	movl	Int386_regsin,%esi
+	movl	$0x24,%ecx
+	rep
+	movsb
+
+	call	switch_to_real
+	.code16
+
+	/* Setup the registers */
+	movw	%cs:Int386_ds,%ax
+	movw	%ax,%ds					/* DS register */
+	movw	%cs:Int386_es,%ax
+	movw	%ax,%es					/* ES register */
+	movw	%cs:Int386_fs,%ax
+	movw	%ax,%fs					/* FS register */
+	movw	%cs:Int386_gs,%ax
+	movw	%ax,%gs					/* GS register */
+
+	movl	%cs:Int386_eax,%eax		/* EAX register */
+	movl	%cs:Int386_ebx,%ebx		/* EBX register */
+	movl	%cs:Int386_ecx,%ecx		/* ECX register */
+	movl	%cs:Int386_edx,%edx		/* EDX register */
+
+	movl	%cs:Int386_esi,%esi		/* ESI register */
+	movl	%cs:Int386_edi,%edi		/* EDI register */
+
+	/* Do not set the flags register */
+	/* only return its value in regsout */
+	//pushl	Int386_eflags
+	//popfl							/* EFLAGS register */
+
+	/* Call the interrupt vector */
+	/*int		Int386_vector*/
+Int386_int_opcode:
+	.byte	0xcd
+Int386_vector_opcode:
+	.byte	0x00
+
+	/* Save the registers */
+	movl	%eax,%cs:Int386_eax		/* EAX register */
+	movl	%ebx,%cs:Int386_ebx		/* EBX register */
+	movl	%ecx,%cs:Int386_ecx		/* ECX register */
+	movl	%edx,%cs:Int386_edx		/* EDX register */
+
+	movl	%esi,%cs:Int386_esi		/* ESI register */
+	movl	%edi,%cs:Int386_edi		/* EDI register */
+
+	movw	%ds,%ax					/* DS register */
+	movw	%ax,%cs:Int386_ds
+	movw	%es,%ax					/* ES register */
+	movw	%ax,%cs:Int386_es
+	movw	%fs,%ax					/* FS register */
+	movw	%ax,%cs:Int386_fs
+	movw	%gs,%ax					/* GS register */
+	movw	%ax,%cs:Int386_gs
+
+	pushf
+	popw	%cs:Int386_eflags		/* EFLAGS register */
+
+	call	switch_to_prot
+	.code32
+
+	/* Copy the variables to the output regs */
+	movl	$Int386_REGS,%esi
+	movl	Int386_regsout,%edi
+	movl	$0x24,%ecx
+	rep
+	movsb
+
+	popal
+
+	/* Get return value */
+	movl	Int386_eax,%eax
+
+	ret

freeldr/freeldr/arch/i386/linux.S

@@ -0,0 +1,81 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+
+
+	.code32
+EXTERN(_BootNewLinuxKernel)
+	call	switch_to_real
+	.code16
+
+	/* Set the boot drive */
+	movb	(_BootDrive),%dl
+
+	/* Load segment registers */
+	cli
+	movw	$0x9000,%bx
+	movw	%bx,%ds
+	movw	%bx,%es
+	movw	%bx,%fs
+	movw	%bx,%gs
+	movw	%bx,%ss
+	movw	$0x9000,%sp
+
+	ljmpl	$0x9020,$0x0000
+
+
+	.code32
+/*
+ *  VOID BootOldLinuxKernel(ULONG KernelSize);
+ */
+EXTERN(_BootOldLinuxKernel)
+
+	/* First we have to copy the kernel down from 0x100000 to 0x10000 */
+	/* The reason we can overwrite low memory is because this code */
+	/* executes between 0000:8000 and 0000:FFFF. That leaves space for */
+	/* 32k of code before we start interfering with Linux kernel address space. */
+
+	/* Get KernelSize in ECX and move the kernel down */
+	movl	0x04(%esp),%ecx
+	movl	$0x100000,%esi
+	movl	$0x10000,%edi
+	rep movsb
+
+	call	switch_to_real
+	.code16
+
+	/* Set the boot drive */
+	movb	(_BootDrive),%dl
+
+	/* Load segment registers */
+	cli
+	movw	$0x9000,%bx
+	movw	%bx,%ds
+	movw	%bx,%es
+	movw	%bx,%fs
+	movw	%bx,%gs
+	movw	%bx,%ss
+	movw	$0x9000,%sp
+
+	ljmpl	$0x9020,$0x0000

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

@@ -0,0 +1,153 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2002  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.
+ */
+
+	.text
+	.code16
+
+#define ASM
+#include <arch.h>
+#include <multiboot.h>
+
+	/*
+	 * Here we assume the kernel is loaded at 1mb
+	 * This boots the kernel
+	 */
+	.code32
+EXTERN(_boot_reactos)
+	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.
+	 */
+EXTERN(_multi_boot)
+
+	cli
+
+	/*
+	 * Load the absolute address of the multiboot information structure
+	 */
+	movl	$_mb_info,%ebx
+
+	/*
+	 * Initalize eflags
+	 */
+	pushl	$0
+	popfl	
+
+	/*
+	 * Load the multiboot magic value into eax
+	 */	
+	movl	$0x2badb002,%eax
+
+	/*
+	 * Jump to start of 32 bit code at 0xc0000000 + 0x1000
+	 */
+
+	pushl	$KERNEL_CS
+	pushl	_mb_entry_addr
+	lretl
+
+
+EXTERN(_mb_header)
+_mb_magic:
+	.long	0		// unsigned long magic;
+_mb_flags:
+  	.long	0		// unsigned long flags;
+_mb_checksum:
+  	.long	0		// unsigned long checksum;
+_mb_header_addr:
+  	.long	0		// unsigned long header_addr;
+_mb_load_addr:
+  	.long	0		// unsigned long load_addr;
+_mb_load_end_addr:
+  	.long	0		// unsigned long load_end_addr;
+_mb_bss_end_addr:
+  	.long	0		// unsigned long bss_end_addr;
+_mb_entry_addr:
+  	.long	0		// unsigned long entry_addr;
+
+	//
+	// Boot information structure
+	//
+
+EXTERN(_mb_info)
+_multiboot_flags:
+	.long	0
+_multiboot_mem_lower:
+	.long	0
+_multiboot_mem_upper:
+	.long	0
+_multiboot_boot_device:
+	.long	0
+_multiboot_cmdline:	
+	.long	0
+_multiboot_mods_count:
+	.long	0
+_multiboot_mods_addr:
+	.long	0
+_multiboot_syms:
+	.rept	12
+	.byte	0
+	.endr
+_multiboot_mmap_length:
+	.long	0
+_multiboot_mmap_addr:
+	.long	0
+_multiboot_drives_count:
+	.long	0
+_multiboot_drives_addr:
+	.long	0
+_multiboot_config_table:
+	.long	0
+_multiboot_boot_loader_name:
+	.long	0
+_multiboot_apm_table:
+	.long	0
+
+EXTERN(_multiboot_modules)
+	.rept	(64 * /*multiboot_module_size*/ 16)
+	.byte	0
+	.endr
+EXTERN(_multiboot_module_strings)
+	.rept	(64*256)
+	.byte	0
+	.endr
+
+EXTERN(_multiboot_memory_map_descriptor_size)
+	.long	0
+
+EXTERN(_multiboot_memory_map)
+	.rept	(32 * /*sizeof(memory_map_t)*/24)
+	.byte	0
+	.endr
+
+EXTERN(_multiboot_kernel_cmdline)
+	.rept	255
+	.byte	0
+	.endr

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/portio.c

@@ -0,0 +1,183 @@
+/* $Id: portio.c,v 1.1 2003/01/19 01:03:58 bpalmer Exp $
+ *
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/hal/x86/portio.c
+ * PURPOSE:         Port I/O functions
+ * PROGRAMMER:      Eric Kohl (ekohl@abo.rhein-zeitung.de)
+ * UPDATE HISTORY:
+ *                  Created 18/10/99
+ */
+
+//#include <ddk/ntddk.h>
+#include <freeldr.h>
+
+
+/* FUNCTIONS ****************************************************************/
+
+/*
+ * This file contains the definitions for the x86 IO instructions
+ * inb/inw/inl/outb/outw/outl and the "string versions" of the same
+ * (insb/insw/insl/outsb/outsw/outsl). You can also use "pausing"
+ * versions of the single-IO instructions (inb_p/inw_p/..).
+ *
+ * This file is not meant to be obfuscating: it's just complicated
+ * to (a) handle it all in a way that makes gcc able to optimize it
+ * as well as possible and (b) trying to avoid writing the same thing
+ * over and over again with slight variations and possibly making a
+ * mistake somewhere.
+ */
+
+/*
+ * Thanks to James van Artsdalen for a better timing-fix than
+ * the two short jumps: using outb's to a nonexistent port seems
+ * to guarantee better timings even on fast machines.
+ *
+ * On the other hand, I'd like to be sure of a non-existent port:
+ * I feel a bit unsafe about using 0x80 (should be safe, though)
+ *
+ *		Linus
+ */
+
+#ifdef SLOW_IO_BY_JUMPING
+#define __SLOW_DOWN_IO __asm__ __volatile__("jmp 1f\n1:\tjmp 1f\n1:")
+#else
+#define __SLOW_DOWN_IO __asm__ __volatile__("outb %al,$0x80")
+#endif
+
+#ifdef REALLY_SLOW_IO
+#define SLOW_DOWN_IO { __SLOW_DOWN_IO; __SLOW_DOWN_IO; __SLOW_DOWN_IO; __SLOW_DOWN_IO; }
+#else
+#define SLOW_DOWN_IO __SLOW_DOWN_IO
+#endif
+
+VOID /*STDCALL*/
+READ_PORT_BUFFER_UCHAR (PUCHAR Port,
+                        PUCHAR Buffer,
+                        U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; insb\n\t" 
+			 : "=D" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+VOID /*STDCALL*/
+READ_PORT_BUFFER_USHORT (U16* Port,
+                         U16* Buffer,
+                         U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; insw"
+			 : "=D" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+VOID /*STDCALL*/
+READ_PORT_BUFFER_ULONG (U32* Port,
+                        U32* Buffer,
+                        U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; insl"
+			 : "=D" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+UCHAR /*STDCALL*/
+READ_PORT_UCHAR (PUCHAR Port)
+{
+   UCHAR Value;
+   
+   __asm__("inb %w1, %0\n\t"
+	   : "=a" (Value)
+	   : "d" (Port));
+   SLOW_DOWN_IO;
+   return(Value);
+}
+
+U16 /*STDCALL*/
+READ_PORT_USHORT (U16* Port)
+{
+   U16 Value;
+   
+   __asm__("inw %w1, %0\n\t"
+	   : "=a" (Value)
+	   : "d" (Port));
+   SLOW_DOWN_IO;
+   return(Value);
+}
+
+U32 /*STDCALL*/
+READ_PORT_ULONG (U32* Port)
+{
+   U32 Value;
+   
+   __asm__("inl %w1, %0\n\t"
+	   : "=a" (Value)
+	   : "d" (Port));
+   SLOW_DOWN_IO;
+   return(Value);
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_BUFFER_UCHAR (PUCHAR Port,
+                         PUCHAR Buffer,
+                         U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; outsb" 
+			 : "=S" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_BUFFER_USHORT (U16* Port,
+                          U16* Buffer,
+                          U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; outsw"
+			 : "=S" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_BUFFER_ULONG (U32* Port,
+                         U32* Buffer,
+                         U32 Count)
+{
+   __asm__ __volatile__ ("cld ; rep ; outsl" 
+			 : "=S" (Buffer), "=c" (Count) 
+			 : "d" (Port),"0" (Buffer),"1" (Count));
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_UCHAR (PUCHAR Port,
+                  UCHAR Value)
+{
+   __asm__("outb %0, %w1\n\t"
+	   : 
+	   : "a" (Value),
+	     "d" (Port));
+   SLOW_DOWN_IO;
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_USHORT (U16* Port,
+                   U16 Value)
+{
+   __asm__("outw %0, %w1\n\t"
+	   : 
+	   : "a" (Value),
+	     "d" (Port));
+   SLOW_DOWN_IO;
+}
+
+VOID /*STDCALL*/
+WRITE_PORT_ULONG (U32* Port,
+                  U32 Value)
+{
+   __asm__("outl %0, %w1\n\t"
+	   : 
+	   : "a" (Value),
+	     "d" (Port));
+   SLOW_DOWN_IO;
+}
+
+/* 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

@@ -0,0 +1,239 @@
+/*
+ *  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 <rtl.h>
+#include <fs.h>
+#include <reactos.h>
+#include <ui.h>
+#include <arch.h>
+#include <miscboot.h>
+#include <linux.h>
+#include <mm.h>
+#include <inifile.h>
+#include <debug.h>
+#include <options.h>
+#include <oslist.h>
+#include <video.h>
+#include <bootmgr.h>
+#include <drivemap.h>
+#include <keycodes.h>
+#include <cmdline.h>
+#include <machine.h>
+
+VOID RunLoader(VOID)
+{
+	UCHAR	SettingName[80];
+	UCHAR	SettingValue[80];
+	U32		SectionId;
+	U32		OperatingSystemCount;
+	PUCHAR	*OperatingSystemSectionNames;
+	PUCHAR	*OperatingSystemDisplayNames;
+	U32		DefaultOperatingSystem;
+	S32		TimeOut;
+	U32		SelectedOperatingSystem;
+
+	if (!IniFileInitialize())
+	{
+		printf("Press any key to reboot.\n");
+		MachConsGetCh();
+		return;
+	}
+
+	if (!IniOpenSection("FreeLoader", &SectionId))
+	{
+		printf("Section [FreeLoader] not found in freeldr.ini.\n");
+		MachConsGetCh();
+		return;
+	}
+	TimeOut = GetTimeOut();
+
+	if (!UiInitialize(TimeOut))
+	{
+		printf("Press any key to reboot.\n");
+		MachConsGetCh();
+		return;
+	}
+	
+
+	if (!InitOperatingSystemList(&OperatingSystemSectionNames, &OperatingSystemDisplayNames, &OperatingSystemCount))
+	{
+		UiMessageBox("Press ENTER to reboot.\n");
+		goto reboot;
+	}
+	
+	if (OperatingSystemCount == 0)
+	{
+		UiMessageBox("There were no operating systems listed in freeldr.ini.\nPress ENTER to reboot.");
+		goto reboot;
+	}
+
+	DefaultOperatingSystem = GetDefaultOperatingSystem(OperatingSystemSectionNames, OperatingSystemCount);
+	
+	//
+	// Find all the message box settings and run them
+	//
+	UiShowMessageBoxesInSection("FreeLoader");
+
+	for (;;)
+	{
+	
+		/* If Timeout is 0, don't even bother loading any gui */
+		if (!UserInterfaceUp) {
+			goto NoGui;
+		}
+		
+		// Redraw the backdrop
+		UiDrawBackdrop();
+
+		// Show the operating system list menu
+		if (!UiDisplayMenu(OperatingSystemDisplayNames, OperatingSystemCount, DefaultOperatingSystem, TimeOut, &SelectedOperatingSystem, FALSE, MainBootMenuKeyPressFilter))
+		{
+			UiMessageBox("Press ENTER to reboot.\n");
+			goto reboot;
+		}
+		
+NoGui:
+		TimeOut = -1;
+		DefaultOperatingSystem = SelectedOperatingSystem;
+
+		// Try to open the operating system section in the .ini file
+		if (!IniOpenSection(OperatingSystemSectionNames[SelectedOperatingSystem], &SectionId))
+		{
+			sprintf(SettingName, "Section [%s] not found in freeldr.ini.\n", OperatingSystemSectionNames[SelectedOperatingSystem]);
+			UiMessageBox(SettingName);
+			continue;
+		}
+
+		// Try to read the boot type
+		if (!IniReadSettingByName(SectionId, "BootType", SettingValue, 80))
+		{
+			sprintf(SettingName, "BootType= line not found in section [%s] in freeldr.ini.\n", OperatingSystemSectionNames[SelectedOperatingSystem]);
+			UiMessageBox(SettingName);
+			continue;
+		}
+
+		// Install the drive mapper according to this sections drive mappings
+		DriveMapMapDrivesInSection(OperatingSystemSectionNames[SelectedOperatingSystem]);
+		if (stricmp(SettingValue, "ReactOS") == 0)
+		{
+			LoadAndBootReactOS(OperatingSystemSectionNames[SelectedOperatingSystem]);
+		}
+		else if (stricmp(SettingValue, "Linux") == 0)
+		{
+			LoadAndBootLinux(OperatingSystemSectionNames[SelectedOperatingSystem], OperatingSystemDisplayNames[SelectedOperatingSystem]);
+		}
+		else if (stricmp(SettingValue, "BootSector") == 0)
+		{
+			LoadAndBootBootSector(OperatingSystemSectionNames[SelectedOperatingSystem]);
+		}
+		else if (stricmp(SettingValue, "Partition") == 0)
+		{
+			LoadAndBootPartition(OperatingSystemSectionNames[SelectedOperatingSystem]);
+		}
+		else if (stricmp(SettingValue, "Drive") == 0)
+		{
+			LoadAndBootDrive(OperatingSystemSectionNames[SelectedOperatingSystem]);
+		}
+	}
+
+	
+reboot:
+	UiUnInitialize("Rebooting...");
+	return;
+}
+
+U32	 GetDefaultOperatingSystem(PUCHAR OperatingSystemList[], U32	 OperatingSystemCount)
+{
+	UCHAR	DefaultOSText[80];
+	char*	DefaultOSName;
+	U32	SectionId;
+	U32	DefaultOS = 0;
+	U32	Idx;
+
+	if (!IniOpenSection("FreeLoader", &SectionId))
+	{
+		return 0;
+	}
+
+	DefaultOSName = CmdLineGetDefaultOS();
+	if (NULL == DefaultOSName)
+	{
+		if (IniReadSettingByName(SectionId, "DefaultOS", DefaultOSText, 80))
+		{
+			DefaultOSName = DefaultOSText;
+		}
+	}
+
+	if (NULL != DefaultOSName)
+	{
+		for (Idx=0; Idx<OperatingSystemCount; Idx++)
+		{
+			if (stricmp(DefaultOSName, OperatingSystemList[Idx]) == 0)
+			{
+				DefaultOS = Idx;
+				break;
+			}
+		}
+	}
+
+	return DefaultOS;
+}
+
+S32 GetTimeOut(VOID)
+{
+	UCHAR	TimeOutText[20];
+	S32		TimeOut;
+	U32		SectionId;
+
+	TimeOut = CmdLineGetTimeOut();
+	if (0 <= TimeOut)
+	{
+		return TimeOut;
+	}
+
+	if (!IniOpenSection("FreeLoader", &SectionId))
+	{
+		return -1;
+	}
+
+	if (IniReadSettingByName(SectionId, "TimeOut", TimeOutText, 20))
+	{
+		TimeOut = atoi(TimeOutText);
+	}
+	else
+	{
+		TimeOut = -1;
+	}
+
+	return TimeOut;
+}
+
+BOOL MainBootMenuKeyPressFilter(U32 KeyPress)
+{
+	if (KeyPress == KEY_F8)
+	{
+		DoOptionsMenu();
+
+		return TRUE;
+	}
+
+	// We didn't handle the key
+	return FALSE;
+}

freeldr/freeldr/cache/blocklist.c

@@ -0,0 +1,260 @@
+/*
+ *  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 "cm.h"
+#include <mm.h>
+#include <disk.h>
+#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
+// in cache memory if it isn't already there
+PCACHE_BLOCK CacheInternalGetBlockPointer(PCACHE_DRIVE CacheDrive, U32 BlockNumber)
+{
+	PCACHE_BLOCK	CacheBlock = NULL;
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalGetBlockPointer() BlockNumber = %d\n", BlockNumber));
+
+	CacheBlock = CacheInternalFindBlock(CacheDrive, BlockNumber);
+
+	if (CacheBlock != NULL)
+	{
+		DbgPrint((DPRINT_CACHE, "Cache hit! BlockNumber: %d CacheBlock->BlockNumber: %d\n", BlockNumber, CacheBlock->BlockNumber));
+
+		return CacheBlock;
+	}
+
+	DbgPrint((DPRINT_CACHE, "Cache miss! BlockNumber: %d\n", BlockNumber));
+
+	CacheBlock = CacheInternalAddBlockToCache(CacheDrive, BlockNumber);
+
+	// Optimize the block list so it has a LRU structure
+	CacheInternalOptimizeBlockList(CacheDrive, CacheBlock);
+
+	return CacheBlock;
+}
+
+PCACHE_BLOCK CacheInternalFindBlock(PCACHE_DRIVE CacheDrive, U32 BlockNumber)
+{
+	PCACHE_BLOCK	CacheBlock = NULL;
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalFindBlock() BlockNumber = %d\n", BlockNumber));
+
+	//
+	// Make sure the block list has entries before I start searching it.
+	//
+	if (!RtlListIsEmpty((PLIST_ITEM)CacheDrive->CacheBlockHead))
+	{
+		//
+		// Search the list and find the BIOS drive number
+		//
+		CacheBlock = CacheDrive->CacheBlockHead;
+
+		while (CacheBlock != NULL)
+		{
+			//
+			// We found the block, so return it
+			//
+			if (CacheBlock->BlockNumber == BlockNumber)
+			{
+				//
+				// Increment the blocks access count
+				//
+				CacheBlock->AccessCount++;
+
+				return CacheBlock;
+			}
+
+			CacheBlock = (PCACHE_BLOCK)RtlListGetNext((PLIST_ITEM)CacheBlock);
+		}
+	}
+	
+	return NULL;
+}
+
+PCACHE_BLOCK CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, U32 BlockNumber)
+{
+	PCACHE_BLOCK	CacheBlock = NULL;
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalAddBlockToCache() BlockNumber = %d\n", BlockNumber));
+
+	// Check the size of the cache so we don't exceed our limits
+	CacheInternalCheckCacheSizeLimits(CacheDrive);
+
+	// We will need to add the block to the
+	// drive's list of cached blocks. So allocate
+	// the block memory.
+	CacheBlock = MmAllocateMemory(sizeof(CACHE_BLOCK));
+	if (CacheBlock == NULL)
+	{
+		return NULL;
+	}
+
+	// Now initialize the structure and
+	// allocate room for the block data
+	RtlZeroMemory(CacheBlock, sizeof(CACHE_BLOCK));
+	CacheBlock->BlockNumber = BlockNumber;
+	CacheBlock->BlockData = MmAllocateMemory(CacheDrive->BlockSize * CacheDrive->BytesPerSector);
+	if (CacheBlock->BlockData ==NULL)
+	{
+		MmFreeMemory(CacheBlock);
+		return NULL;
+	}
+
+	// Now try to read in the block
+	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->BytesPerSector);
+
+	// Add it to our list of blocks managed by the cache
+	if (CacheDrive->CacheBlockHead == NULL)
+	{
+		CacheDrive->CacheBlockHead = CacheBlock;
+	}
+	else
+	{
+		RtlListInsertTail((PLIST_ITEM)CacheDrive->CacheBlockHead, (PLIST_ITEM)CacheBlock);
+	}
+
+	// Update the cache data
+	CacheBlockCount++;
+	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
+
+	CacheInternalDumpBlockList(CacheDrive);
+
+	return CacheBlock;
+}
+
+BOOL CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive)
+{
+	PCACHE_BLOCK	CacheBlockToFree;
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalFreeBlock()\n"));
+
+	// Get a pointer to the last item in the block list
+	// that isn't forced to be in the cache and remove
+	// it from the list
+	CacheBlockToFree = (PCACHE_BLOCK)RtlListGetTail((PLIST_ITEM)CacheDrive->CacheBlockHead);
+	while (CacheBlockToFree != NULL && CacheBlockToFree->LockedInCache == TRUE)
+	{
+		CacheBlockToFree = (PCACHE_BLOCK)RtlListGetPrevious((PLIST_ITEM)CacheBlockToFree);
+	}
+
+	// No blocks left in cache that can be freed
+	// so just return
+	if (CacheBlockToFree == NULL)
+	{
+		return FALSE;
+	}
+
+	//
+	// If we are freeing the head of the list then update it's pointer
+	//
+	if (CacheBlockToFree == CacheDrive->CacheBlockHead)
+	{
+		CacheDrive->CacheBlockHead = (PCACHE_BLOCK)RtlListGetNext((PLIST_ITEM)CacheBlockToFree);
+	}
+
+	RtlListRemoveEntry((PLIST_ITEM)CacheBlockToFree);
+
+	// Free the block memory and the block structure
+	MmFreeMemory(CacheBlockToFree->BlockData);
+	MmFreeMemory(CacheBlockToFree);
+
+	// Update the cache data
+	CacheBlockCount--;
+	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
+
+	return TRUE;
+}
+
+VOID CacheInternalCheckCacheSizeLimits(PCACHE_DRIVE CacheDrive)
+{
+	U32		NewCacheSize;
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalCheckCacheSizeLimits()\n"));
+
+	// Calculate the size of the cache if we added a block
+	NewCacheSize = (CacheBlockCount + 1) * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
+
+	// Check the new size against the cache size limit
+	if (NewCacheSize > CacheSizeLimit)
+	{
+		CacheInternalFreeBlock(CacheDrive);
+		CacheInternalDumpBlockList(CacheDrive);
+	}
+}
+
+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, "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));
+	DbgPrint((DPRINT_CACHE, "CacheBlockCount: %d.\n", CacheBlockCount));
+	DbgPrint((DPRINT_CACHE, "Dumping %d cache blocks.\n", RtlListCountEntries((PLIST_ITEM)CacheDrive->CacheBlockHead)));
+
+	CacheBlock = CacheDrive->CacheBlockHead;
+	while (CacheBlock != NULL)
+	{
+		DbgPrint((DPRINT_CACHE, "Cache Block: CacheBlock: 0x%x\n", CacheBlock));
+		DbgPrint((DPRINT_CACHE, "Cache Block: Block Number: %d\n", CacheBlock->BlockNumber));
+		DbgPrint((DPRINT_CACHE, "Cache Block: Access Count: %d\n", CacheBlock->AccessCount));
+		DbgPrint((DPRINT_CACHE, "Cache Block: Block Data: 0x%x\n", CacheBlock->BlockData));
+		DbgPrint((DPRINT_CACHE, "Cache Block: Locked In Cache: %d\n", CacheBlock->LockedInCache));
+
+		if (CacheBlock->BlockData == NULL)
+		{
+			BugCheck((DPRINT_CACHE, "What the heck?!?\n"));
+		}
+
+		CacheBlock = (PCACHE_BLOCK)RtlListGetNext((PLIST_ITEM)CacheBlock);
+	}
+}
+
+VOID CacheInternalOptimizeBlockList(PCACHE_DRIVE CacheDrive, PCACHE_BLOCK CacheBlock)
+{
+
+	DbgPrint((DPRINT_CACHE, "CacheInternalOptimizeBlockList()\n"));
+
+	// Don't do this if this block is already at the head of the list
+	if (CacheBlock != CacheDrive->CacheBlockHead)
+	{
+		// Remove this item from the block list
+		RtlListRemoveEntry((PLIST_ITEM)CacheBlock);
+
+		// Re-insert it at the head of the list
+		RtlListInsertHead((PLIST_ITEM)CacheDrive->CacheBlockHead, (PLIST_ITEM)CacheBlock);
+
+		// Update the head pointer
+		CacheDrive->CacheBlockHead = CacheBlock;
+	}
+}

freeldr/freeldr/cache/cache.c

@@ -0,0 +1,325 @@
+/*
+ *  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 "cm.h"
+#include <mm.h>
+#include <disk.h>
+#include <machine.h>
+#include <rtl.h>
+#include <debug.h>
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// Internal data
+//
+///////////////////////////////////////////////////////////////////////////////////////
+CACHE_DRIVE		CacheManagerDrive;
+BOOL			CacheManagerInitialized = FALSE;
+BOOL			CacheManagerDataInvalid = FALSE;
+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
+	// drive, in which case we'll invalidate the cache
+	if ((CacheManagerInitialized == TRUE) &&
+		(DriveNumber == CacheManagerDrive.DriveNumber) &&
+		(DriveNumber >= 0x80) &&
+		(CacheManagerDataInvalid != TRUE))
+	{
+		return TRUE;
+	}
+
+	CacheManagerDataInvalid = FALSE;
+
+	//
+	// If we have already been initialized then free
+	// the old data
+	//
+	if (CacheManagerInitialized)
+	{
+		CacheManagerInitialized = FALSE;
+
+		DbgPrint((DPRINT_CACHE, "CacheBlockCount: %d\n", CacheBlockCount));
+		DbgPrint((DPRINT_CACHE, "CacheSizeLimit: %d\n", CacheSizeLimit));
+		DbgPrint((DPRINT_CACHE, "CacheSizeCurrent: %d\n", CacheSizeCurrent));
+		//
+		// Loop through and free the cache blocks
+		//
+		while (CacheManagerDrive.CacheBlockHead != NULL)
+		{
+			NextCacheBlock = (PCACHE_BLOCK)RtlListGetNext((PLIST_ITEM)CacheManagerDrive.CacheBlockHead);
+
+			MmFreeMemory(CacheManagerDrive.CacheBlockHead->BlockData);
+			MmFreeMemory(CacheManagerDrive.CacheBlockHead);
+
+			CacheManagerDrive.CacheBlockHead = NextCacheBlock;
+		}
+	}
+
+	// Initialize the structure
+	RtlZeroMemory(&CacheManagerDrive, sizeof(CACHE_DRIVE));
+	CacheManagerDrive.DriveNumber = DriveNumber;
+	if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry))
+	{
+		return FALSE;
+	}
+	CacheManagerDrive.BytesPerSector = DriveGeometry.BytesPerSector;
+
+	// Get the number of sectors in each cache block
+	CacheManagerDrive.BlockSize = MachDiskGetCacheableBlockCount(DriveNumber);
+
+	CacheBlockCount = 0;
+	CacheSizeLimit = GetSystemMemorySize() / 8;
+	CacheSizeCurrent = 0;
+	if (CacheSizeLimit < (64 * 1024))
+	{
+		CacheSizeLimit = (64 * 1024);
+	}
+
+	CacheManagerInitialized = TRUE;
+
+	DbgPrint((DPRINT_CACHE, "Initializing BIOS drive 0x%x.\n", DriveNumber));
+	DbgPrint((DPRINT_CACHE, "BytesPerSector: %d.\n", CacheManagerDrive.BytesPerSector));
+	DbgPrint((DPRINT_CACHE, "BlockSize: %d.\n", CacheManagerDrive.BlockSize));
+	DbgPrint((DPRINT_CACHE, "CacheSizeLimit: %d.\n", CacheSizeLimit));
+
+	return TRUE;
+}
+
+VOID CacheInvalidateCacheData(VOID)
+{
+	CacheManagerDataInvalid = TRUE;
+}
+
+BOOL CacheReadDiskSectors(U32 DiskNumber, U32 StartSector, U32 SectorCount, PVOID Buffer)
+{
+	PCACHE_BLOCK	CacheBlock;
+	U32				StartBlock;
+	U32				SectorOffsetInStartBlock;
+	U32				CopyLengthInStartBlock;
+	U32				EndBlock;
+	U32				SectorOffsetInEndBlock;
+	U32				BlockCount;
+	U32				Idx;
+
+	DbgPrint((DPRINT_CACHE, "CacheReadDiskSectors() DiskNumber: 0x%x StartSector: %d SectorCount: %d Buffer: 0x%x\n", DiskNumber, StartSector, SectorCount, Buffer));
+
+	// If we aren't initialized yet then they can't do this
+	if (CacheManagerInitialized == FALSE)
+	{
+		return FALSE;
+	}
+
+	//
+	// Caculate which blocks we must cache
+	//
+	StartBlock = StartSector / CacheManagerDrive.BlockSize;
+	SectorOffsetInStartBlock = StartSector % CacheManagerDrive.BlockSize;
+	CopyLengthInStartBlock = (SectorCount > (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock)) ? (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock) : SectorCount;
+	EndBlock = (StartSector + (SectorCount - 1)) / CacheManagerDrive.BlockSize;
+	SectorOffsetInEndBlock = (StartSector + SectorCount) % CacheManagerDrive.BlockSize;
+	BlockCount = (EndBlock - StartBlock) + 1;
+	DbgPrint((DPRINT_CACHE, "StartBlock: %d SectorOffsetInStartBlock: %d CopyLengthInStartBlock: %d EndBlock: %d SectorOffsetInEndBlock: %d BlockCount: %d\n", StartBlock, SectorOffsetInStartBlock, CopyLengthInStartBlock, EndBlock, SectorOffsetInEndBlock, BlockCount));
+
+	//
+	// Read the first block into the buffer
+	//
+	if (BlockCount > 0)
+	{
+		//
+		// Get cache block pointer (this forces the disk sectors into the cache memory)
+		//
+		CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, StartBlock);
+		if (CacheBlock == NULL)
+		{
+			return FALSE;
+		}
+
+		//
+		// Copy the portion requested into the buffer
+		//
+		RtlCopyMemory(Buffer,
+			(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.BytesPerSector);
+
+		//
+		// Update the block count
+		//
+		BlockCount--;
+	}
+
+	//
+	// Loop through the middle blocks and read them into the buffer
+	//
+	for (Idx=StartBlock+1; BlockCount>1; Idx++)
+	{
+		//
+		// Get cache block pointer (this forces the disk sectors into the cache memory)
+		//
+		CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, Idx);
+		if (CacheBlock == NULL)
+		{
+			return FALSE;
+		}
+
+		//
+		// Copy the portion requested into the buffer
+		//
+		RtlCopyMemory(Buffer,
+			CacheBlock->BlockData,
+			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.BytesPerSector;
+
+		//
+		// Update the block count
+		//
+		BlockCount--;
+	}
+
+	//
+	// Read the last block into the buffer
+	//
+	if (BlockCount > 0)
+	{
+		//
+		// Get cache block pointer (this forces the disk sectors into the cache memory)
+		//
+		CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, EndBlock);
+		if (CacheBlock == NULL)
+		{
+			return FALSE;
+		}
+
+		//
+		// Copy the portion requested into the buffer
+		//
+		RtlCopyMemory(Buffer,
+			CacheBlock->BlockData,
+			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.BytesPerSector;
+
+		//
+		// Update the block count
+		//
+		BlockCount--;
+	}
+
+	return TRUE;
+}
+
+BOOL CacheForceDiskSectorsIntoCache(U32 DiskNumber, U32 StartSector, U32 SectorCount)
+{
+	PCACHE_BLOCK	CacheBlock;
+	U32				StartBlock;
+	U32				EndBlock;
+	U32				BlockCount;
+	U32				Idx;
+
+	DbgPrint((DPRINT_CACHE, "CacheForceDiskSectorsIntoCache() DiskNumber: 0x%x StartSector: %d SectorCount: %d\n", DiskNumber, StartSector, SectorCount));
+
+	// If we aren't initialized yet then they can't do this
+	if (CacheManagerInitialized == FALSE)
+	{
+		return FALSE;
+	}
+
+	//
+	// Caculate which blocks we must cache
+	//
+	StartBlock = StartSector / CacheManagerDrive.BlockSize;
+	EndBlock = (StartSector + SectorCount) / CacheManagerDrive.BlockSize;
+	BlockCount = (EndBlock - StartBlock) + 1;
+
+	//
+	// Loop through and cache them
+	//
+	for (Idx=StartBlock; Idx<(StartBlock+BlockCount); Idx++)
+	{
+		//
+		// Get cache block pointer (this forces the disk sectors into the cache memory)
+		//
+		CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, Idx);
+		if (CacheBlock == NULL)
+		{
+			return FALSE;
+		}
+
+		//
+		// Lock the sectors into the cache
+		//
+		CacheBlock->LockedInCache = TRUE;
+	}
+
+	return TRUE;
+}
+
+BOOL CacheReleaseMemory(U32 MinimumAmountToRelease)
+{
+	U32				AmountReleased;
+
+	DbgPrint((DPRINT_CACHE, "CacheReleaseMemory() MinimumAmountToRelease = %d\n", MinimumAmountToRelease));
+
+	// If we aren't initialized yet then they can't do this
+	if (CacheManagerInitialized == FALSE)
+	{
+		return FALSE;
+	}
+
+	// Loop through and try to free the requested amount of memory
+	for (AmountReleased=0; AmountReleased<MinimumAmountToRelease; )
+	{
+		// Try to free a block
+		// If this fails then break out of the loop
+		if (!CacheInternalFreeBlock(&CacheManagerDrive))
+		{
+			break;
+		}
+
+		// It succeeded so increment the amount of memory we have freed
+		AmountReleased += CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector;
+	}
+
+	// Return status
+	return (AmountReleased >= MinimumAmountToRelease);
+}

freeldr/freeldr/cache/cm.h

@@ -0,0 +1,92 @@
+/*
+ *  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 <rtl.h>
+#include <disk.h>
+
+#ifndef __CM_H
+#define __CM_H
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// This structure describes a cached block element. The disk is divided up into
+// cache blocks. For disks which LBA is not supported each block is the size of
+// one track. This will force the cache manager to make track sized reads, and
+// therefore maximizes throughput. For disks which support LBA the block size
+// is 64k because they have no cylinder, head, or sector boundaries.
+//
+///////////////////////////////////////////////////////////////////////////////////////
+typedef struct
+{
+	LIST_ITEM	ListEntry;					// Doubly linked list synchronization member
+
+	U32			BlockNumber;				// Track index for CHS, 64k block index for LBA
+	BOOL		LockedInCache;				// Indicates that this block is locked in cache memory
+	U32			AccessCount;				// Access count for this block
+
+	PVOID		BlockData;					// Pointer to block data
+
+} CACHE_BLOCK, *PCACHE_BLOCK;
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// This structure describes a cached drive. It contains the BIOS drive number
+// and indicates whether or not LBA is supported. If LBA is not supported then
+// the drive's geometry is described here.
+//
+///////////////////////////////////////////////////////////////////////////////////////
+typedef struct
+{
+	U32			DriveNumber;
+	U32			BytesPerSector;
+
+	U32			BlockSize;			// Block size (in sectors)
+	PCACHE_BLOCK		CacheBlockHead;
+
+} CACHE_DRIVE, *PCACHE_DRIVE;
+
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// Internal data
+//
+///////////////////////////////////////////////////////////////////////////////////////
+extern	CACHE_DRIVE		CacheManagerDrive;
+extern	BOOL			CacheManagerInitialized;
+extern	U32				CacheBlockCount;
+extern	U32				CacheSizeLimit;
+extern	U32				CacheSizeCurrent;
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// Internal functions
+//
+///////////////////////////////////////////////////////////////////////////////////////
+PCACHE_BLOCK	CacheInternalGetBlockPointer(PCACHE_DRIVE CacheDrive, U32 BlockNumber);				// Returns a pointer to a CACHE_BLOCK structure given a block number
+PCACHE_BLOCK	CacheInternalFindBlock(PCACHE_DRIVE CacheDrive, U32 BlockNumber);					// Searches the block list for a particular block
+PCACHE_BLOCK	CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, U32 BlockNumber);				// Adds a block to the cache's block list
+BOOL			CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive);									// Removes a block from the cache's block list & frees the memory
+VOID			CacheInternalCheckCacheSizeLimits(PCACHE_DRIVE CacheDrive);							// Checks the cache size limits to see if we can add a new block, if not calls CacheInternalFreeBlock()
+VOID			CacheInternalDumpBlockList(PCACHE_DRIVE CacheDrive);								// Dumps the list of cached blocks to the debug output port
+VOID			CacheInternalOptimizeBlockList(PCACHE_DRIVE CacheDrive, PCACHE_BLOCK CacheBlock);	// Moves the specified block to the head of the list
+
+
+#endif // defined __CM_H

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/comm/rs232.c

@@ -0,0 +1,277 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 2001  Brian Palmer  <brianp@sginet.com>
+ *  Copyright (C) 2001  Eric Kohl
+ *  Copyright (C) 2001  Emanuele Aliberti
+ *
+ *  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 <comm.h>
+#include <portio.h>
+
+
+/* MACROS *******************************************************************/
+
+#define DEFAULT_BAUD_RATE    19200
+
+#define   SER_RBR(x)   ((x)+0)
+#define   SER_THR(x)   ((x)+0)
+#define   SER_DLL(x)   ((x)+0)
+#define   SER_IER(x)   ((x)+1)
+#define   SER_DLM(x)   ((x)+1)
+#define   SER_IIR(x)   ((x)+2)
+#define   SER_LCR(x)   ((x)+3)
+#define     SR_LCR_CS5 0x00
+#define     SR_LCR_CS6 0x01
+#define     SR_LCR_CS7 0x02
+#define     SR_LCR_CS8 0x03
+#define     SR_LCR_ST1 0x00
+#define     SR_LCR_ST2 0x04
+#define     SR_LCR_PNO 0x00
+#define     SR_LCR_POD 0x08
+#define     SR_LCR_PEV 0x18
+#define     SR_LCR_PMK 0x28
+#define     SR_LCR_PSP 0x38
+#define     SR_LCR_BRK 0x40
+#define     SR_LCR_DLAB 0x80
+#define   SER_MCR(x)   ((x)+4)
+#define     SR_MCR_DTR 0x01
+#define     SR_MCR_RTS 0x02
+#define   SER_LSR(x)   ((x)+5)
+#define     SR_LSR_DR  0x01
+#define     SR_LSR_TBE 0x20
+#define   SER_MSR(x)   ((x)+6)
+#define     SR_MSR_CTS 0x10
+#define     SR_MSR_DSR 0x20
+#define   SER_SCR(x)   ((x)+7)
+
+/* STATIC VARIABLES *********************************************************/
+
+static U32 Rs232ComPort = 0;
+static U32 Rs232BaudRate = 0;
+static PUCHAR Rs232PortBase = (PUCHAR)0;
+
+/* The com port must only be initialized once! */
+static BOOLEAN PortInitialized = FALSE;
+
+/* STATIC FUNCTIONS *********************************************************/
+
+static BOOL Rs232DoesComPortExist(PUCHAR BaseAddress)
+{
+        BOOLEAN found;
+        U8 mcr;
+        U8 msr;
+
+        found = FALSE;
+
+        /* save Modem Control Register (MCR) */
+        mcr = READ_PORT_UCHAR (SER_MCR(BaseAddress));
+
+        /* enable loop mode (set Bit 4 of the MCR) */
+        WRITE_PORT_UCHAR (SER_MCR(BaseAddress), 0x10);
+
+        /* clear all modem output bits */
+        WRITE_PORT_UCHAR (SER_MCR(BaseAddress), 0x10);
+
+        /* read the Modem Status Register */
+        msr = READ_PORT_UCHAR (SER_MSR(BaseAddress));
+
+        /*
+         * the upper nibble of the MSR (modem output bits) must be
+         * equal to the lower nibble of the MCR (modem input bits)
+         */
+        if ((msr & 0xF0) == 0x00)
+        {
+                /* set all modem output bits */
+                WRITE_PORT_UCHAR (SER_MCR(BaseAddress), 0x1F);
+
+                /* read the Modem Status Register */
+                msr = READ_PORT_UCHAR (SER_MSR(BaseAddress));
+
+                /*
+                 * the upper nibble of the MSR (modem output bits) must be
+                 * equal to the lower nibble of the MCR (modem input bits)
+                 */
+                if ((msr & 0xF0) == 0xF0)
+                        found = TRUE;
+        }
+
+        /* restore MCR */
+        WRITE_PORT_UCHAR (SER_MCR(BaseAddress), mcr);
+
+        return (found);
+}
+
+/* FUNCTIONS *********************************************************/
+
+BOOL Rs232PortInitialize(U32 ComPort, U32 BaudRate)
+{
+        U32 BaseArray[5] = {0, 0x3F8, 0x2F8, 0x3E8, 0x2E8};
+        //char buffer[80];
+        U32 divisor;
+        U8 lcr;
+
+        if (PortInitialized == FALSE)
+        {
+                if (BaudRate != 0)
+                {
+                        Rs232BaudRate = BaudRate;
+                }
+                else
+                {
+                        Rs232BaudRate = DEFAULT_BAUD_RATE;
+                }
+
+                if (ComPort == 0)
+                {
+                        if (Rs232DoesComPortExist ((PUCHAR)BaseArray[2]))
+                        {
+                                Rs232PortBase = (PUCHAR)BaseArray[2];
+                                Rs232ComPort = 2;
+/*#ifndef NDEBUG
+                                sprintf (buffer,
+                                         "\nSerial port COM%ld found at 0x%lx\n",
+                                         ComPort,
+                                         (U32)PortBase);
+                                HalDisplayString (buffer);
+#endif*/ /* NDEBUG */
+                        }
+                        else if (Rs232DoesComPortExist ((PUCHAR)BaseArray[1]))
+                        {
+                                Rs232PortBase = (PUCHAR)BaseArray[1];
+                                Rs232ComPort = 1;
+/*#ifndef NDEBUG
+                                sprintf (buffer,
+                                         "\nSerial port COM%ld found at 0x%lx\n",
+                                         ComPort,
+                                         (U32)PortBase);
+                                HalDisplayString (buffer);
+#endif*/ /* NDEBUG */
+                        }
+                        else
+                        {
+                                /*sprintf (buffer,
+                                         "\nKernel Debugger: No COM port found!!!\n\n");
+                                HalDisplayString (buffer);*/
+                                return FALSE;
+                        }
+                }
+                else
+                {
+                        if (Rs232DoesComPortExist ((PUCHAR)BaseArray[ComPort]))
+                        {
+                                Rs232PortBase = (PUCHAR)BaseArray[ComPort];
+                                Rs232ComPort = ComPort;
+/*#ifndef NDEBUG
+                                sprintf (buffer,
+                                         "\nSerial port COM%ld found at 0x%lx\n",
+                                         ComPort,
+                                         (U32)PortBase);
+                                HalDisplayString (buffer);
+#endif*/ /* NDEBUG */
+                        }
+                        else
+                        {
+                                /*sprintf (buffer,
+                                         "\nKernel Debugger: No serial port found!!!\n\n");
+                                HalDisplayString (buffer);*/
+                                return FALSE;
+                        }
+                }
+
+                PortInitialized = TRUE;
+        }
+
+        /*
+         * set baud rate and data format (8N1)
+         */
+
+        /*  turn on DTR and RTS  */
+        WRITE_PORT_UCHAR (SER_MCR(Rs232PortBase), SR_MCR_DTR | SR_MCR_RTS);
+
+        /* set DLAB */
+        lcr = READ_PORT_UCHAR (SER_LCR(Rs232PortBase)) | SR_LCR_DLAB;
+        WRITE_PORT_UCHAR (SER_LCR(Rs232PortBase), lcr);
+
+        /* set baud rate */
+        divisor = 115200 / BaudRate;
+        WRITE_PORT_UCHAR (SER_DLL(Rs232PortBase), divisor & 0xff);
+        WRITE_PORT_UCHAR (SER_DLM(Rs232PortBase), (divisor >> 8) & 0xff);
+
+        /* reset DLAB and set 8N1 format */
+        WRITE_PORT_UCHAR (SER_LCR(Rs232PortBase),
+                          SR_LCR_CS8 | SR_LCR_ST1 | SR_LCR_PNO);
+
+        /* read junk out of the RBR */
+        lcr = READ_PORT_UCHAR (SER_RBR(Rs232PortBase));
+
+        /*
+         * set global info
+         */
+        //KdComPortInUse = (U32)PortBase;
+
+        /*
+         * print message to blue screen
+         */
+        /*sprintf (buffer,
+                 "\nKernel Debugger: COM%ld (Port 0x%lx) BaudRate %ld\n\n",
+                 ComPort,
+                 (U32)PortBase,
+                 BaudRate);
+
+        HalDisplayString (buffer);*/
+
+        return TRUE;
+}
+
+BOOL Rs232PortGetByte(PUCHAR ByteRecieved)
+{
+	if (PortInitialized == FALSE)
+		return FALSE;
+
+	if ((READ_PORT_UCHAR (SER_LSR(Rs232PortBase)) & SR_LSR_DR))
+	{
+		*ByteRecieved = READ_PORT_UCHAR (SER_RBR(Rs232PortBase));
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL Rs232PortPollByte(PUCHAR ByteRecieved)
+{
+	if (PortInitialized == FALSE)
+		return FALSE;
+
+	while ((READ_PORT_UCHAR (SER_LSR(Rs232PortBase)) & SR_LSR_DR) == 0)
+		;
+
+	*ByteRecieved = READ_PORT_UCHAR (SER_RBR(Rs232PortBase));
+
+	return TRUE;
+}
+
+VOID Rs232PortPutByte(UCHAR ByteToSend)
+{
+	if (PortInitialized == FALSE)
+		return;
+
+	while ((READ_PORT_UCHAR (SER_LSR(Rs232PortBase)) & SR_LSR_TBE) == 0)
+		;
+
+	WRITE_PORT_UCHAR (SER_THR(Rs232PortBase), ByteToSend);
+}

freeldr/freeldr/custom.c

@@ -0,0 +1,411 @@
+/*
+ *  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 <rtl.h>
+#include <ui.h>
+#include <options.h>
+#include <miscboot.h>
+#include <debug.h>
+#include <disk.h>
+#include <arch.h>
+#include <inifile.h>
+#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";
+UCHAR	BootPartitionPrompt[] = "Enter the boot partition.\n\nEnter 0 for the active (bootable) partition.";
+UCHAR	BootSectorFilePrompt[] = "Enter the boot sector file path.\n\nExamples:\n\\BOOTSECT.DOS\n/boot/bootsect.dos";
+UCHAR	LinuxKernelPrompt[] = "Enter the Linux kernel image path.\n\nExamples:\n/vmlinuz\n/boot/vmlinuz-2.4.18";
+UCHAR	LinuxInitrdPrompt[] = "Enter the initrd image path.\n\nExamples:\n/initrd.gz\n/boot/root.img.gz\n\nLeave blank for no initial ram disk.";
+UCHAR	LinuxCommandLinePrompt[] = "Enter the Linux kernel command line.\n\nExamples:\nroot=/dev/hda1\nroot=/dev/fd0 read-only\nroot=/dev/sdb1 init=/sbin/init";
+UCHAR	ReactOSSystemPathPrompt[] = "Enter the path to your ReactOS system directory.\n\nExamples:\n\\REACTOS\n\\ROS";
+UCHAR	ReactOSOptionsPrompt[] = "Enter the options you want passed to the kernel.\n\nExamples:\n/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200\n/FASTDETECT /SOS /NOGUIBOOT\n/BASEVIDEO /MAXMEM=64\n/KERNEL=NTKRNLMP.EXE /HAL=HALMPS.DLL";
+
+UCHAR	CustomBootPrompt[] = "Press ENTER to boot your custom boot setup.";
+
+VOID OptionMenuCustomBoot(VOID)
+{
+	PUCHAR	CustomBootMenuList[] = { "Disk", "Partition", "Boot Sector File", "ReactOS", "Linux" };
+	U32		CustomBootMenuCount = sizeof(CustomBootMenuList) / sizeof(CustomBootMenuList[0]);
+	U32		SelectedMenuItem;
+
+	if (!UiDisplayMenu(CustomBootMenuList, CustomBootMenuCount, 0, -1, &SelectedMenuItem, TRUE, NULL))
+	{
+		// The user pressed ESC
+		return;
+	}
+
+	switch (SelectedMenuItem)
+	{
+	case 0: // Disk
+		OptionMenuCustomBootDisk();
+		break;
+	case 1: // Partition
+		OptionMenuCustomBootPartition();
+		break;
+	case 2: // Boot Sector File
+		OptionMenuCustomBootBootSectorFile();
+		break;
+	case 3: // ReactOS
+		OptionMenuCustomBootReactOS();
+		break;
+	case 4: // Linux
+		OptionMenuCustomBootLinux();
+		break;
+	}
+}
+
+VOID OptionMenuCustomBootDisk(VOID)
+{
+	UCHAR	SectionName[100];
+	UCHAR	BootDriveString[20];
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
+
+	RtlZeroMemory(SectionName, sizeof(SectionName));
+	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
+
+	if (!UiEditBox(BootDrivePrompt, BootDriveString, 20))
+	{
+		return;
+	}
+
+	// Generate a unique section name
+	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))
+	{
+		return;
+	}
+
+	// Add the BootType
+	if (!IniAddSettingValueToSection(SectionId, "BootType", "Drive"))
+	{
+		return;
+	}
+
+	// Add the BootDrive
+	if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootDriveString))
+	{
+		return;
+	}
+
+	UiMessageBox(CustomBootPrompt);
+
+	LoadAndBootDrive(SectionName);
+}
+
+VOID OptionMenuCustomBootPartition(VOID)
+{
+	UCHAR	SectionName[100];
+	UCHAR	BootDriveString[20];
+	UCHAR	BootPartitionString[20];
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
+
+	RtlZeroMemory(SectionName, sizeof(SectionName));
+	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
+	RtlZeroMemory(BootPartitionString, sizeof(BootPartitionString));
+
+	if (!UiEditBox(BootDrivePrompt, BootDriveString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(BootPartitionPrompt, BootPartitionString, 20))
+	{
+		return;
+	}
+
+	// Generate a unique section name
+	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))
+	{
+		return;
+	}
+
+	// Add the BootType
+	if (!IniAddSettingValueToSection(SectionId, "BootType", "Partition"))
+	{
+		return;
+	}
+
+	// Add the BootDrive
+	if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootDriveString))
+	{
+		return;
+	}
+
+	// Add the BootPartition
+	if (!IniAddSettingValueToSection(SectionId, "BootPartition", BootPartitionString))
+	{
+		return;
+	}
+
+	UiMessageBox(CustomBootPrompt);
+
+	LoadAndBootPartition(SectionName);
+}
+
+VOID OptionMenuCustomBootBootSectorFile(VOID)
+{
+	UCHAR	SectionName[100];
+	UCHAR	BootDriveString[20];
+	UCHAR	BootPartitionString[20];
+	UCHAR	BootSectorFileString[200];
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
+
+	RtlZeroMemory(SectionName, sizeof(SectionName));
+	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
+	RtlZeroMemory(BootPartitionString, sizeof(BootPartitionString));
+	RtlZeroMemory(BootSectorFileString, sizeof(BootSectorFileString));
+
+	if (!UiEditBox(BootDrivePrompt, BootDriveString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(BootPartitionPrompt, BootPartitionString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(BootSectorFilePrompt, BootSectorFileString, 200))
+	{
+		return;
+	}
+
+	// Generate a unique section name
+	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))
+	{
+		return;
+	}
+
+	// Add the BootType
+	if (!IniAddSettingValueToSection(SectionId, "BootType", "BootSector"))
+	{
+		return;
+	}
+
+	// Add the BootDrive
+	if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootDriveString))
+	{
+		return;
+	}
+
+	// Add the BootPartition
+	if (!IniAddSettingValueToSection(SectionId, "BootPartition", BootPartitionString))
+	{
+		return;
+	}
+
+	// Add the BootSectorFile
+	if (!IniAddSettingValueToSection(SectionId, "BootSectorFile", BootSectorFileString))
+	{
+		return;
+	}
+
+	UiMessageBox(CustomBootPrompt);
+
+	LoadAndBootBootSector(SectionName);
+}
+
+VOID OptionMenuCustomBootReactOS(VOID)
+{
+	UCHAR	SectionName[100];
+	UCHAR	BootDriveString[20];
+	UCHAR	BootPartitionString[20];
+	UCHAR	ReactOSSystemPath[200];
+	UCHAR	ReactOSARCPath[200];
+	UCHAR	ReactOSOptions[200];
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
+
+	RtlZeroMemory(SectionName, sizeof(SectionName));
+	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
+	RtlZeroMemory(BootPartitionString, sizeof(BootPartitionString));
+	RtlZeroMemory(ReactOSSystemPath, sizeof(ReactOSSystemPath));
+	RtlZeroMemory(ReactOSOptions, sizeof(ReactOSOptions));
+
+	if (!UiEditBox(BootDrivePrompt, BootDriveString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(BootPartitionPrompt, BootPartitionString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(ReactOSSystemPathPrompt, ReactOSSystemPath, 200))
+	{
+		return;
+	}
+
+	if (!UiEditBox(ReactOSOptionsPrompt, ReactOSOptions, 200))
+	{
+		return;
+	}
+
+	// Generate a unique section name
+	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))
+	{
+		return;
+	}
+
+	// Add the BootType
+	if (!IniAddSettingValueToSection(SectionId, "BootType", "ReactOS"))
+	{
+		return;
+	}
+
+	// Construct the ReactOS ARC system path
+	ConstructArcPath(ReactOSARCPath, ReactOSSystemPath, DriveMapGetBiosDriveNumber(BootDriveString), atoi(BootPartitionString));
+
+	// Add the system path
+	if (!IniAddSettingValueToSection(SectionId, "SystemPath", ReactOSARCPath))
+	{
+		return;
+	}
+
+	// Add the CommandLine
+	if (!IniAddSettingValueToSection(SectionId, "Options", ReactOSOptions))
+	{
+		return;
+	}
+
+	UiMessageBox(CustomBootPrompt);
+
+	LoadAndBootReactOS(SectionName);
+}
+
+VOID OptionMenuCustomBootLinux(VOID)
+{
+	UCHAR	SectionName[100];
+	UCHAR	BootDriveString[20];
+	UCHAR	BootPartitionString[20];
+	UCHAR	LinuxKernelString[200];
+	UCHAR	LinuxInitrdString[200];
+	UCHAR	LinuxCommandLineString[200];
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
+
+	RtlZeroMemory(SectionName, sizeof(SectionName));
+	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
+	RtlZeroMemory(BootPartitionString, sizeof(BootPartitionString));
+	RtlZeroMemory(LinuxKernelString, sizeof(LinuxKernelString));
+	RtlZeroMemory(LinuxInitrdString, sizeof(LinuxInitrdString));
+	RtlZeroMemory(LinuxCommandLineString, sizeof(LinuxCommandLineString));
+
+	if (!UiEditBox(BootDrivePrompt, BootDriveString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(BootPartitionPrompt, BootPartitionString, 20))
+	{
+		return;
+	}
+
+	if (!UiEditBox(LinuxKernelPrompt, LinuxKernelString, 200))
+	{
+		return;
+	}
+
+	if (!UiEditBox(LinuxInitrdPrompt, LinuxInitrdString, 200))
+	{
+		return;
+	}
+
+	if (!UiEditBox(LinuxCommandLinePrompt, LinuxCommandLineString, 200))
+	{
+		return;
+	}
+
+	// Generate a unique section name
+	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))
+	{
+		return;
+	}
+
+	// Add the BootType
+	if (!IniAddSettingValueToSection(SectionId, "BootType", "Linux"))
+	{
+		return;
+	}
+
+	// Add the BootDrive
+	if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootDriveString))
+	{
+		return;
+	}
+
+	// Add the BootPartition
+	if (!IniAddSettingValueToSection(SectionId, "BootPartition", BootPartitionString))
+	{
+		return;
+	}
+
+	// Add the Kernel
+	if (!IniAddSettingValueToSection(SectionId, "Kernel", LinuxKernelString))
+	{
+		return;
+	}
+
+	// Add the Initrd
+	if (strlen(LinuxInitrdString) > 0)
+	{
+		if (!IniAddSettingValueToSection(SectionId, "Initrd", LinuxInitrdString))
+		{
+			return;
+		}
+	}
+
+	// Add the CommandLine
+	if (!IniAddSettingValueToSection(SectionId, "CommandLine", LinuxCommandLineString))
+	{
+		return;
+	}
+
+	UiMessageBox(CustomBootPrompt);
+
+	LoadAndBootLinux(SectionName, "Custom Linux Setup");
+}

freeldr/freeldr/debug.c

@@ -0,0 +1,411 @@
+/*
+ *  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 <debug.h>
+#include <rtl.h>
+#include <comm.h>
+#include <portio.h>
+#include <machine.h>
+
+#ifdef DEBUG
+
+//#define DEBUG_ALL
+//#define DEBUG_INIFILE
+//#define DEBUG_REACTOS
+//#define DEBUG_CUSTOM
+#define DEBUG_NONE
+
+#if defined (DEBUG_ALL)
+U32		DebugPrintMask = DPRINT_WARNING | DPRINT_MEMORY | DPRINT_FILESYSTEM |
+						DPRINT_UI | DPRINT_DISK | DPRINT_CACHE | DPRINT_REACTOS |
+						DPRINT_LINUX;
+#elif defined (DEBUG_INIFILE)
+U32		DebugPrintMask = DPRINT_INIFILE;
+#elif defined (DEBUG_REACTOS)
+U32		DebugPrintMask = DPRINT_REACTOS | DPRINT_REGISTRY;
+#elif defined (DEBUG_CUSTOM)
+U32		DebugPrintMask = DPRINT_WARNING|DPRINT_FILESYSTEM|DPRINT_MEMORY|DPRINT_LINUX;
+#else //#elif defined (DEBUG_NONE)
+U32		DebugPrintMask = 0;
+#endif
+
+#define	SCREEN				0
+#define	RS232				1
+#define BOCHS				2
+
+#define	COM1				1
+#define	COM2				2
+#define	COM3				3
+#define	COM4				4
+
+#define BOCHS_OUTPUT_PORT	0xe9
+
+U32		DebugPort = RS232;
+//U32		DebugPort = SCREEN;
+//U32		DebugPort = BOCHS;
+U32		ComPort = COM1;
+//U32		BaudRate = 19200;
+U32		BaudRate = 115200;
+
+BOOL	DebugStartOfLine = TRUE;
+
+VOID DebugInit(VOID)
+{
+	if (DebugPort == RS232)
+	{
+		Rs232PortInitialize(ComPort, BaudRate);
+	}
+}
+
+VOID DebugPrintChar(UCHAR Character)
+{
+	if (Character == '\n')
+	{
+		DebugStartOfLine = TRUE;
+	}
+
+	if (DebugPort == RS232)
+	{
+		if (Character == '\n')
+		{
+			Rs232PortPutByte('\r');
+		}
+		Rs232PortPutByte(Character);
+	}
+	else if (DebugPort == BOCHS)
+	{
+		WRITE_PORT_UCHAR((PUCHAR)BOCHS_OUTPUT_PORT, Character);
+	}
+	else
+	{
+		MachConsPutChar(Character);
+	}
+}
+
+VOID DebugPrintHeader(U32 Mask)
+{
+  /* No header */
+  if (Mask == 0)
+    return;
+
+	switch (Mask)
+	{
+	case DPRINT_WARNING:
+		DebugPrintChar('W');
+		DebugPrintChar('A');
+		DebugPrintChar('R');
+		DebugPrintChar('N');
+		DebugPrintChar('I');
+		DebugPrintChar('N');
+		DebugPrintChar('G');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_MEMORY:
+		DebugPrintChar('M');
+		DebugPrintChar('E');
+		DebugPrintChar('M');
+		DebugPrintChar('O');
+		DebugPrintChar('R');
+		DebugPrintChar('Y');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_FILESYSTEM:
+		DebugPrintChar('F');
+		DebugPrintChar('I');
+		DebugPrintChar('L');
+		DebugPrintChar('E');
+		DebugPrintChar('S');
+		DebugPrintChar('Y');
+		DebugPrintChar('S');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_INIFILE:
+		DebugPrintChar('I');
+		DebugPrintChar('N');
+		DebugPrintChar('I');
+		DebugPrintChar('F');
+		DebugPrintChar('I');
+		DebugPrintChar('L');
+		DebugPrintChar('E');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_UI:
+		DebugPrintChar('U');
+		DebugPrintChar('I');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_DISK:
+		DebugPrintChar('D');
+		DebugPrintChar('I');
+		DebugPrintChar('S');
+		DebugPrintChar('K');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_CACHE:
+		DebugPrintChar('C');
+		DebugPrintChar('A');
+		DebugPrintChar('C');
+		DebugPrintChar('H');
+		DebugPrintChar('E');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_REGISTRY:
+		DebugPrintChar('R');
+		DebugPrintChar('E');
+		DebugPrintChar('G');
+		DebugPrintChar('I');
+		DebugPrintChar('S');
+		DebugPrintChar('T');
+		DebugPrintChar('R');
+		DebugPrintChar('Y');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_REACTOS:
+		DebugPrintChar('R');
+		DebugPrintChar('E');
+		DebugPrintChar('A');
+		DebugPrintChar('C');
+		DebugPrintChar('T');
+		DebugPrintChar('O');
+		DebugPrintChar('S');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_LINUX:
+		DebugPrintChar('L');
+		DebugPrintChar('I');
+		DebugPrintChar('N');
+		DebugPrintChar('U');
+		DebugPrintChar('X');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	case DPRINT_HWDETECT:
+		DebugPrintChar('H');
+		DebugPrintChar('W');
+		DebugPrintChar('D');
+		DebugPrintChar('E');
+		DebugPrintChar('T');
+		DebugPrintChar('E');
+		DebugPrintChar('C');
+		DebugPrintChar('T');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	default:
+		DebugPrintChar('U');
+		DebugPrintChar('N');
+		DebugPrintChar('K');
+		DebugPrintChar('N');
+		DebugPrintChar('O');
+		DebugPrintChar('W');
+		DebugPrintChar('N');
+		DebugPrintChar(':');
+		DebugPrintChar(' ');
+		break;
+	}
+}
+
+static VOID DebugPrintV(char *format, int *dataptr)
+{
+	char c, *ptr, str[16];
+	int ll;
+
+	ll = 0;
+	while ((c = *(format++)))
+	{
+		if (c != '%')
+		{
+			DebugPrintChar(c);
+		}
+		else
+		{
+			if (*format == 'I' && *(format+1) == '6' && *(format+2) == '4')
+			{
+				ll = 1;
+				format += 3;
+			}
+			else
+			{
+				ll = 0;
+			}
+			switch (c = *(format++))
+			{
+			case 'd': case 'u': case 'x':
+				
+				if (ll)
+				{
+					*convert_i64_to_ascii(str, c, *((unsigned long long*) dataptr)) = 0;
+					dataptr += 2;
+				}
+				else
+				{
+					*convert_to_ascii(str, c, *((unsigned long *) dataptr++)) = 0;
+				}
+
+				ptr = str;
+
+				while (*ptr)
+				{
+					DebugPrintChar(*(ptr++));
+				}
+				break;
+
+			case 'c':
+
+				DebugPrintChar((*(dataptr++))&0xff);
+				break;
+
+			case 's':
+
+				ptr = (char *)(*(dataptr++));
+
+				while ((c = *(ptr++)))
+				{
+					DebugPrintChar(c);
+				}
+				break;
+			case '%':
+				DebugPrintChar(c);
+				break;
+			default:
+				DebugPrint(DPRINT_WARNING, "\nDebugPrint() invalid format specifier - %%%c\n", c);
+				break;
+			}
+		}
+	}
+
+
+	if (DebugPort == SCREEN)
+	{
+		//getch();
+	}
+
+}
+
+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;
+	U32		Idx;
+	U32		Idx2;
+	
+	// Mask out unwanted debug messages
+	if (!(Mask & DebugPrintMask))
+	{
+		return;
+	}
+
+	DebugStartOfLine = FALSE; // We don't want line headers
+	DebugPrint(Mask, "Dumping buffer at 0x%x with length of %d bytes:\n", Buffer, Length);
+
+	for (Idx=0; Idx<Length; )
+	{
+		DebugStartOfLine = FALSE; // We don't want line headers
+
+		if (Idx < 0x0010)
+		{
+			DebugPrint(Mask, "000%x:\t", Idx);
+		}
+		else if (Idx < 0x0100)
+		{
+			DebugPrint(Mask, "00%x:\t", Idx);
+		}
+		else if (Idx < 0x1000)
+		{
+			DebugPrint(Mask, "0%x:\t", Idx);
+		}
+		else
+		{
+			DebugPrint(Mask, "%x:\t", Idx);
+		}
+
+		for (Idx2=0; Idx2<16; Idx2++,Idx++)
+		{
+			if (BufPtr[Idx] < 0x10)
+			{
+				DebugPrint(Mask, "0");
+			}
+			DebugPrint(Mask, "%x", BufPtr[Idx]);
+
+			if (Idx2 == 7)
+			{
+				DebugPrint(Mask, "-");
+			}
+			else
+			{
+				DebugPrint(Mask, " ");
+			}
+		}
+
+		Idx -= 16;
+		DebugPrint(Mask, " ");
+
+		for (Idx2=0; Idx2<16; Idx2++,Idx++)
+		{
+			if ((BufPtr[Idx] > 20) && (BufPtr[Idx] < 0x80))
+			{
+				DebugPrint(Mask, "%c", BufPtr[Idx]);
+			}
+			else
+			{
+				DebugPrint(Mask, ".");
+			}
+		}
+
+		DebugPrint(Mask, "\n");
+	}
+}
+
+#endif // defined DEBUG

freeldr/freeldr/disk/disk.c

@@ -0,0 +1,112 @@
+/*
+ *  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 <arch.h>
+#include <rtl.h>
+#include <ui.h>
+#include <debug.h>
+
+
+#undef  UNIMPLEMENTED
+#define UNIMPLEMENTED   BugCheck((DPRINT_WARNING, "Unimplemented\n"));
+
+static BOOL bReportError = TRUE;
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+VOID DiskReportError (BOOL bError)
+{
+	bReportError = bError;
+}
+
+VOID DiskError(PUCHAR ErrorString, U32 ErrorCode)
+{
+	UCHAR	ErrorCodeString[200];
+
+	if (bReportError == FALSE)
+		return;
+
+	sprintf(ErrorCodeString, "%s\n\nError Code: 0x%x\nError: %s", ErrorString, ErrorCode, DiskGetErrorCodeString(ErrorCode));
+
+	DbgPrint((DPRINT_DISK, "%s\n", ErrorCodeString));
+
+	UiMessageBox(ErrorCodeString);
+}
+
+PUCHAR DiskGetErrorCodeString(U32 ErrorCode)
+{
+	switch (ErrorCode)
+	{
+	case 0x00:  return "no error";
+	case 0x01:  return "bad command passed to driver";
+	case 0x02:  return "address mark not found or bad sector";
+	case 0x03:  return "diskette write protect error";
+	case 0x04:  return "sector not found";
+	case 0x05:  return "fixed disk reset failed";
+	case 0x06:  return "diskette changed or removed";
+	case 0x07:  return "bad fixed disk parameter table";
+	case 0x08:  return "DMA overrun";
+	case 0x09:  return "DMA access across 64k boundary";
+	case 0x0A:  return "bad fixed disk sector flag";
+	case 0x0B:  return "bad fixed disk cylinder";
+	case 0x0C:  return "unsupported track/invalid media";
+	case 0x0D:  return "invalid number of sectors on fixed disk format";
+	case 0x0E:  return "fixed disk controlled data address mark detected";
+	case 0x0F:  return "fixed disk DMA arbitration level out of range";
+	case 0x10:  return "ECC/CRC error on disk read";
+	case 0x11:  return "recoverable fixed disk data error, data fixed by ECC";
+	case 0x20:  return "controller error (NEC for floppies)";
+	case 0x40:  return "seek failure";
+	case 0x80:  return "time out, drive not ready";
+	case 0xAA:  return "fixed disk drive not ready";
+	case 0xBB:  return "fixed disk undefined error";
+	case 0xCC:  return "fixed disk write fault on selected drive";
+	case 0xE0:  return "fixed disk status error/Error reg = 0";
+	case 0xFF:  return "sense operation failed";
+
+	default:  return "unknown error code";
+	}
+}
+
+// This function is in arch/i386/i386disk.c
+//BOOL DiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+
+BOOL DiskIsDriveRemovable(U32 DriveNumber)
+{
+	// Hard disks use drive numbers >= 0x80
+	// So if the drive number indicates a hard disk
+	// then return FALSE
+	if (DriveNumber >= 0x80)
+	{
+		return FALSE;
+	}
+
+	// Drive is a floppy diskette so return TRUE
+	return TRUE;
+}
+
+// This function is in arch/i386/i386disk.c
+//VOID DiskStopFloppyMotor(VOID)
+
+// This function is in arch/i386/i386disk.c
+//U32 DiskGetCacheableBlockCount(U32 DriveNumber)

freeldr/freeldr/disk/partition.c

@@ -0,0 +1,247 @@
+/*
+ *  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>
+#include <debug.h>
+#include <arch.h>
+#include <machine.h>
+
+
+BOOL DiskGetActivePartitionEntry(U32 DriveNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+	U32					BootablePartitionCount = 0;
+	MASTER_BOOT_RECORD	MasterBootRecord;
+
+	// Read master boot record
+	if (!DiskReadBootRecord(DriveNumber, 0, &MasterBootRecord))
+	{
+		return FALSE;
+	}
+
+	// Count the bootable partitions
+	if (MasterBootRecord.PartitionTable[0].BootIndicator == 0x80)
+	{
+		BootablePartitionCount++;
+		BootPartition = 0;
+	}
+	if (MasterBootRecord.PartitionTable[1].BootIndicator == 0x80)
+	{
+		BootablePartitionCount++;
+		BootPartition = 1;
+	}
+	if (MasterBootRecord.PartitionTable[2].BootIndicator == 0x80)
+	{
+		BootablePartitionCount++;
+		BootPartition = 2;
+	}
+	if (MasterBootRecord.PartitionTable[3].BootIndicator == 0x80)
+	{
+		BootablePartitionCount++;
+		BootPartition = 3;
+	}
+
+	// Make sure there was only one bootable partition
+	if (BootablePartitionCount == 0)
+	{
+		DiskError("No bootable (active) partitions found.", 0);
+		return FALSE;
+	}
+	else if (BootablePartitionCount != 1)
+	{
+		DiskError("Too many bootable (active) partitions found.", 0);
+		return FALSE;
+	}
+
+	// Copy the partition table entry
+	RtlCopyMemory(PartitionTableEntry, &MasterBootRecord.PartitionTable[BootPartition], sizeof(PARTITION_TABLE_ENTRY));
+
+	return TRUE;
+}
+
+BOOL DiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+	MASTER_BOOT_RECORD		MasterBootRecord;
+	PARTITION_TABLE_ENTRY	ExtendedPartitionTableEntry;
+	U32						ExtendedPartitionNumber;
+	U32						ExtendedPartitionOffset;
+	U32						Index;
+
+	// Read master boot record
+	if (!DiskReadBootRecord(DriveNumber, 0, &MasterBootRecord))
+	{
+		return FALSE;
+	}
+
+	// If they are asking for a primary
+	// partition then things are easy
+	if (PartitionNumber < 5)
+	{
+		// PartitionNumber is one-based and we need it zero-based
+		PartitionNumber--;
+
+		// Copy the partition table entry
+		RtlCopyMemory(PartitionTableEntry, &MasterBootRecord.PartitionTable[PartitionNumber], sizeof(PARTITION_TABLE_ENTRY));
+
+		return TRUE;
+	}
+	else
+	{
+		// They want an extended partition entry so we will need
+		// to loop through all the extended partitions on the disk
+		// and return the one they want.
+		
+		ExtendedPartitionNumber = PartitionNumber - 5;
+
+		// Set the initial relative starting sector to 0
+		// This is because extended partition starting
+		// sectors a numbered relative to their parent
+		ExtendedPartitionOffset = 0;
+
+		for (Index=0; Index<=ExtendedPartitionNumber; Index++)
+		{
+			// Get the extended partition table entry
+			if (!DiskGetFirstExtendedPartitionEntry(&MasterBootRecord, &ExtendedPartitionTableEntry))
+			{
+				return FALSE;
+			}
+
+			// Adjust the relative starting sector of the partition
+			ExtendedPartitionTableEntry.SectorCountBeforePartition += ExtendedPartitionOffset;
+			if (ExtendedPartitionOffset == 0)
+			{
+				// Set the start of the parrent extended partition
+				ExtendedPartitionOffset = ExtendedPartitionTableEntry.SectorCountBeforePartition;
+			}
+			// Read the partition boot record
+    			if (!DiskReadBootRecord(DriveNumber, ExtendedPartitionTableEntry.SectorCountBeforePartition, &MasterBootRecord))
+			{
+				return FALSE;
+			}
+
+			// Get the first real partition table entry
+			if (!DiskGetFirstPartitionEntry(&MasterBootRecord, PartitionTableEntry))
+			{
+				return FALSE;
+			}
+
+			// Now correct the start sector of the partition
+			PartitionTableEntry->SectorCountBeforePartition += ExtendedPartitionTableEntry.SectorCountBeforePartition;
+		}
+
+		// When we get here we should have the correct entry
+		// already stored in PartitionTableEntry
+		// so just return TRUE
+		return TRUE;
+	}
+
+}
+
+BOOL DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+	U32		Index;
+
+	for (Index=0; Index<4; Index++)
+	{
+		// Check the system indicator
+		// If it's not an extended or unused partition
+		// then we're done
+		if ((MasterBootRecord->PartitionTable[Index].SystemIndicator != PARTITION_ENTRY_UNUSED) &&
+			(MasterBootRecord->PartitionTable[Index].SystemIndicator != PARTITION_EXTENDED) &&
+			(MasterBootRecord->PartitionTable[Index].SystemIndicator != PARTITION_XINT13_EXTENDED))
+		{
+			RtlCopyMemory(PartitionTableEntry, &MasterBootRecord->PartitionTable[Index], sizeof(PARTITION_TABLE_ENTRY));
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+	U32		Index;
+
+	for (Index=0; Index<4; Index++)
+	{
+		// Check the system indicator
+		// If it an extended partition then we're done
+		if ((MasterBootRecord->PartitionTable[Index].SystemIndicator == PARTITION_EXTENDED) ||
+			(MasterBootRecord->PartitionTable[Index].SystemIndicator == PARTITION_XINT13_EXTENDED))
+		{
+			RtlCopyMemory(PartitionTableEntry, &MasterBootRecord->PartitionTable[Index], sizeof(PARTITION_TABLE_ENTRY));
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL DiskReadBootRecord(U32 DriveNumber, U64 LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord)
+{
+	char		ErrMsg[64];
+#ifdef DEBUG
+	U32		Index;
+#endif
+
+	// Read master boot record
+	if (!MachDiskReadLogicalSectors(DriveNumber, LogicalSectorNumber, 1, (PVOID)DISKREADBUFFER))
+	{
+		return FALSE;
+	}
+	RtlCopyMemory(BootRecord, (PVOID)DISKREADBUFFER, sizeof(MASTER_BOOT_RECORD));
+
+
+#ifdef DEBUG
+
+	DbgPrint((DPRINT_DISK, "Dumping partition table for drive 0x%x:\n", DriveNumber));
+	DbgPrint((DPRINT_DISK, "Boot record logical start sector = %d\n", LogicalSectorNumber));
+	DbgPrint((DPRINT_DISK, "sizeof(MASTER_BOOT_RECORD) = 0x%x.\n", sizeof(MASTER_BOOT_RECORD)));
+
+	for (Index=0; Index<4; Index++)
+	{
+		DbgPrint((DPRINT_DISK, "-------------------------------------------\n"));
+		DbgPrint((DPRINT_DISK, "Partition %d\n", (Index + 1)));
+		DbgPrint((DPRINT_DISK, "BootIndicator: 0x%x\n", BootRecord->PartitionTable[Index].BootIndicator));
+		DbgPrint((DPRINT_DISK, "StartHead: 0x%x\n", BootRecord->PartitionTable[Index].StartHead));
+		DbgPrint((DPRINT_DISK, "StartSector (Plus 2 cylinder bits): 0x%x\n", BootRecord->PartitionTable[Index].StartSector));
+		DbgPrint((DPRINT_DISK, "StartCylinder: 0x%x\n", BootRecord->PartitionTable[Index].StartCylinder));
+		DbgPrint((DPRINT_DISK, "SystemIndicator: 0x%x\n", BootRecord->PartitionTable[Index].SystemIndicator));
+		DbgPrint((DPRINT_DISK, "EndHead: 0x%x\n", BootRecord->PartitionTable[Index].EndHead));
+		DbgPrint((DPRINT_DISK, "EndSector (Plus 2 cylinder bits): 0x%x\n", BootRecord->PartitionTable[Index].EndSector));
+		DbgPrint((DPRINT_DISK, "EndCylinder: 0x%x\n", BootRecord->PartitionTable[Index].EndCylinder));
+		DbgPrint((DPRINT_DISK, "SectorCountBeforePartition: 0x%x\n", BootRecord->PartitionTable[Index].SectorCountBeforePartition));
+		DbgPrint((DPRINT_DISK, "PartitionSectorCount: 0x%x\n", BootRecord->PartitionTable[Index].PartitionSectorCount));
+	}
+
+#endif // defined DEBUG
+
+	// Check the partition table magic value
+	if (BootRecord->MasterBootRecordMagic != 0xaa55)
+	{
+		sprintf(ErrMsg, "Invalid partition table magic 0x%x found on drive 0x%x",
+		        BootRecord->MasterBootRecordMagic, DriveNumber);
+		DiskError(ErrMsg, 0);
+		return FALSE;
+	}
+
+	return TRUE;
+}

freeldr/freeldr/drivemap.c

@@ -0,0 +1,227 @@
+/*
+ *  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 <drivemap.h>
+#include <rtl.h>
+#include <inifile.h>
+#include <cache.h>
+#include <ui.h>
+#include <debug.h>
+
+BOOL	DriveMapInstalled = FALSE;	// Tells us if we have already installed our drive map int 13h handler code
+U32		OldInt13HandlerAddress = 0;	// Address of BIOS int 13h handler
+U32		DriveMapHandlerAddress = 0;	// Linear address of our drive map handler
+U32		DriveMapHandlerSegOff = 0;	// Segment:offset style address of our drive map handler
+
+VOID DriveMapMapDrivesInSection(PUCHAR SectionName)
+{
+	UCHAR			SettingName[80];
+	UCHAR			SettingValue[80];
+	UCHAR			ErrorText[260];
+	UCHAR			Drive1[80];
+	UCHAR			Drive2[80];
+	U32				SectionId;
+	U32				SectionItemCount;
+	U32				Index;
+	U32				Index2;
+	DRIVE_MAP_LIST	DriveMapList;
+
+	RtlZeroMemory(&DriveMapList, sizeof(DRIVE_MAP_LIST));
+
+	if (!IniOpenSection(SectionName, &SectionId))
+	{
+		return;
+	}
+
+	// Get the number of items in this section
+	SectionItemCount = IniGetNumSectionItems(SectionId);
+
+	// Loop through each one and check if its a DriveMap= setting
+	for (Index=0; Index<SectionItemCount; Index++)
+	{
+		// Get the next setting from the .ini file section
+		if (IniReadSettingByNumber(SectionId, Index, SettingName, 80, SettingValue, 80))
+		{
+			if (stricmp(SettingName, "DriveMap") == 0)
+			{
+				// Make sure we haven't exceeded the drive map max count
+				if (DriveMapList.DriveMapCount >= 4)
+				{
+					sprintf(ErrorText, "Max DriveMap count exceeded in section [%s]:\n\n%s=%s", SectionName, SettingName, SettingValue);
+					UiMessageBox(ErrorText);
+					continue;
+				}
+
+				RtlZeroMemory(Drive1, 80);
+				RtlZeroMemory(Drive2, 80);
+
+				strcpy(Drive1, SettingValue);
+
+				// Parse the setting value and separate a string "hd0,hd1"
+				// into two strings "hd0" and "hd1"
+				for (Index2=0; Index2<strlen(Drive1); Index2++)
+				{
+					// Check if this character is the separater character (comma - ',')
+					if (Drive1[Index2] == ',')
+					{
+						Drive1[Index2] = '\0';
+						strcpy(Drive2, &Drive1[Index2+1]);
+						break;
+					}
+				}
+
+				// Make sure we got good values before we add them to the map
+				if (!DriveMapIsValidDriveString(Drive1) || !DriveMapIsValidDriveString(Drive2))
+				{
+					sprintf(ErrorText, "Error in DriveMap setting in section [%s]:\n\n%s=%s", SectionName, SettingName, SettingValue);
+					UiMessageBox(ErrorText);
+					continue;
+				}
+
+				// Add them to the map
+				DriveMapList.DriveMap[(DriveMapList.DriveMapCount * 2)] = DriveMapGetBiosDriveNumber(Drive1);
+				DriveMapList.DriveMap[(DriveMapList.DriveMapCount * 2)+1] = DriveMapGetBiosDriveNumber(Drive2);
+				DriveMapList.DriveMapCount++;
+
+				DbgPrint((DPRINT_WARNING, "Mapping BIOS drive 0x%x to drive 0x%x\n", DriveMapGetBiosDriveNumber(Drive1), DriveMapGetBiosDriveNumber(Drive2)));
+			}
+		}
+	}
+
+	if (DriveMapList.DriveMapCount)
+	{
+		DbgPrint((DPRINT_WARNING, "Installing Int13 drive map for %d drives.\n", DriveMapList.DriveMapCount));
+		DriveMapInstallInt13Handler(&DriveMapList);
+	}
+	else
+	{
+		DbgPrint((DPRINT_WARNING, "Removing any previously installed Int13 drive map.\n"));
+		DriveMapRemoveInt13Handler();
+	}
+}
+
+BOOL DriveMapIsValidDriveString(PUCHAR DriveString)
+{
+	U32		Index;
+	
+	// Now verify that the user has given us appropriate strings
+	if ((strlen(DriveString) < 3) ||
+		((DriveString[0] != 'f') && (DriveString[0] != 'F') && (DriveString[0] != 'h') && (DriveString[0] != 'H')) ||
+		((DriveString[1] != 'd') && (DriveString[1] != 'D')))
+	{
+		return FALSE;
+	}
+
+	// Now verify that the user has given us appropriate numbers
+	// Make sure that only numeric characters were given
+	for (Index=2; Index<strlen(DriveString); Index++)
+	{
+		if (DriveString[Index] < '0' || DriveString[Index] > '9')
+		{
+			return FALSE;
+		}
+	}
+	// Now make sure that they are not outrageous values (i.e. hd90874)
+	if ((atoi(&DriveString[2]) < 0) || (atoi(&DriveString[2]) > 0xff))
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+U32 DriveMapGetBiosDriveNumber(PUCHAR DeviceName)
+{
+	U32		BiosDriveNumber = 0;
+
+	// If they passed in a number string then just
+	// convert it to decimal and return it
+	if (DeviceName[0] >= '0' && DeviceName[0] <= '9')
+	{
+		return atoi(DeviceName);
+	}
+
+	// Convert the drive number string into a number
+	// 'hd1' = 1
+	BiosDriveNumber = atoi(&DeviceName[2]);
+
+	// If it's a hard disk then set the high bit
+	if ((DeviceName[0] == 'h' || DeviceName[0] == 'H') &&
+		(DeviceName[1] == 'd' || DeviceName[1] == 'D'))
+	{
+		BiosDriveNumber |= 0x80;
+	}
+
+	return BiosDriveNumber;
+}
+
+VOID DriveMapInstallInt13Handler(PDRIVE_MAP_LIST DriveMap)
+{
+	U32*	RealModeIVT = (U32*)0x00000000;
+	U16*	BiosLowMemorySize = (U16*)0x00000413;
+
+	if (!DriveMapInstalled)
+	{
+		// Get the old INT 13h handler address from the vector table
+		OldInt13HandlerAddress = RealModeIVT[0x13];
+
+		// Decrease the size of low memory
+		(*BiosLowMemorySize)--;
+
+		// Get linear address for drive map handler
+		DriveMapHandlerAddress = (U32)(*BiosLowMemorySize) << 10;
+
+		// Convert to segment:offset style address
+		DriveMapHandlerSegOff = (DriveMapHandlerAddress << 12) & 0xffff0000;
+	}
+
+	// Copy the drive map structure to the proper place
+	RtlCopyMemory(&DriveMapInt13HandlerMapList, DriveMap, sizeof(DRIVE_MAP_LIST));
+
+	// Set the address of the BIOS INT 13h handler
+	DriveMapOldInt13HandlerAddress = OldInt13HandlerAddress;
+
+	// Copy the code to our reserved area
+	RtlCopyMemory((PVOID)DriveMapHandlerAddress, &DriveMapInt13HandlerStart, ((U32)&DriveMapInt13HandlerEnd - (U32)&DriveMapInt13HandlerStart));
+
+	// Update the IVT
+	RealModeIVT[0x13] = DriveMapHandlerSegOff;
+
+	CacheInvalidateCacheData();
+	DriveMapInstalled = TRUE;
+}
+
+VOID DriveMapRemoveInt13Handler(VOID)
+{
+	U32*	RealModeIVT = (U32*)0x00000000;
+	U16*	BiosLowMemorySize = (U16*)0x00000413;
+
+	if (DriveMapInstalled)
+	{
+		// Get the old INT 13h handler address from the vector table
+		RealModeIVT[0x13] = OldInt13HandlerAddress;
+
+		// Increase the size of low memory
+		(*BiosLowMemorySize)++;
+
+		CacheInvalidateCacheData();
+		DriveMapInstalled = FALSE;
+	}
+}

freeldr/freeldr/freeldr.c

@@ -0,0 +1,48 @@
+/*
+ *  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 <rtl.h>
+#include <arch.h>
+#include <machine.h>
+#include <mm.h>
+#include <debug.h>
+#include <bootmgr.h>
+#include <fs.h>
+#include <cmdline.h>
+
+VOID BootMain(char *CmdLine)
+{
+	CmdLineParse(CmdLine);
+
+	MachInit();
+
+	DebugInit();
+
+	DbgPrint((DPRINT_WARNING, "BootMain() called. BootDrive = 0x%x BootPartition = %d\n", BootDrive, BootPartition));
+
+	if (!MmInitializeMemoryManager())
+	{
+		printf("Press any key to reboot.\n");
+		MachConsGetCh();
+		return;
+	}
+
+	RunLoader();
+}

freeldr/freeldr/fs/ext2.h

@@ -0,0 +1,697 @@
+/*
+ *  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.
+ */
+
+#ifndef __EXT2_H
+#define __EXT2_H
+
+
+/*
+ *  linux/include/linux/ext3_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT3_FS_H
+#define _LINUX_EXT3_FS_H
+
+//#include <linux/types.h>
+
+/*
+ * The second extended filesystem constants/structures
+ */
+
+/*
+ * Define EXT3FS_DEBUG to produce debug messages
+ */
+#undef EXT3FS_DEBUG
+
+/*
+ * Define EXT3_PREALLOCATE to preallocate data blocks for expanding files
+ */
+#undef  EXT3_PREALLOCATE /* @@@ Fix this! */
+#define EXT3_DEFAULT_PREALLOC_BLOCKS	8
+
+/*
+ * The second extended file system version
+ */
+#define EXT3FS_DATE		"10 Jan 2002"
+#define EXT3FS_VERSION		"2.4-0.9.17"
+
+/*
+ * Debug code
+ */
+#ifdef EXT3FS_DEBUG
+#define ext3_debug(f, a...)						\
+	do {								\
+		printk (KERN_DEBUG "EXT3-fs DEBUG (%s, %d): %s:",	\
+			__FILE__, __LINE__, __FUNCTION__);		\
+		printk (KERN_DEBUG f, ## a);				\
+	} while (0)
+#else
+#define ext3_debug(f, a...)	do {} while (0)
+#endif
+
+/*
+ * Special inodes numbers
+ */
+#define	EXT3_BAD_INO		 1	/* Bad blocks inode */
+#define EXT3_ROOT_INO		 2	/* Root inode */
+#define EXT3_ACL_IDX_INO	 3	/* ACL inode */
+#define EXT3_ACL_DATA_INO	 4	/* ACL inode */
+#define EXT3_BOOT_LOADER_INO	 5	/* Boot loader inode */
+#define EXT3_UNDEL_DIR_INO	 6	/* Undelete directory inode */
+#define EXT3_RESIZE_INO		 7	/* Reserved group descriptors inode */
+#define EXT3_JOURNAL_INO	 8	/* Journal inode */
+
+/* First non-reserved inode for old ext3 filesystems */
+#define EXT3_GOOD_OLD_FIRST_INO	11
+
+/*
+ * The second extended file system magic number
+ */
+#define EXT3_SUPER_MAGIC	0xEF53
+
+/*
+ * Maximal count of links to a file
+ */
+#define EXT3_LINK_MAX		32000
+
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT3_MIN_BLOCK_SIZE		1024
+#define	EXT3_MAX_BLOCK_SIZE		4096
+#define EXT3_MIN_BLOCK_LOG_SIZE		  10
+#ifdef __KERNEL__
+# define EXT3_BLOCK_SIZE(s)		((s)->s_blocksize)
+#else
+# define EXT3_BLOCK_SIZE(s)		(EXT3_MIN_BLOCK_SIZE << (s)->s_log_block_size)
+#endif
+#define EXT3_ACLE_PER_BLOCK(s)		(EXT3_BLOCK_SIZE(s) / sizeof (struct ext3_acl_entry))
+#define	EXT3_ADDR_PER_BLOCK(s)		(EXT3_BLOCK_SIZE(s) / sizeof (__u32))
+#ifdef __KERNEL__
+# define EXT3_BLOCK_SIZE_BITS(s)	((s)->s_blocksize_bits)
+#else
+# define EXT3_BLOCK_SIZE_BITS(s)	((s)->s_log_block_size + 10)
+#endif
+#ifdef __KERNEL__
+#define	EXT3_ADDR_PER_BLOCK_BITS(s)	((s)->u.ext3_sb.s_addr_per_block_bits)
+#define EXT3_INODE_SIZE(s)		((s)->u.ext3_sb.s_inode_size)
+#define EXT3_FIRST_INO(s)		((s)->u.ext3_sb.s_first_ino)
+#else
+#define EXT3_INODE_SIZE(s)	(((s)->s_rev_level == EXT3_GOOD_OLD_REV) ? \
+				 EXT3_GOOD_OLD_INODE_SIZE : \
+				 (s)->s_inode_size)
+#define EXT3_FIRST_INO(s)	(((s)->s_rev_level == EXT3_GOOD_OLD_REV) ? \
+				 EXT3_GOOD_OLD_FIRST_INO : \
+				 (s)->s_first_ino)
+#endif
+
+/*
+ * Macro-instructions used to manage fragments
+ */
+#define EXT3_MIN_FRAG_SIZE		1024
+#define	EXT3_MAX_FRAG_SIZE		4096
+#define EXT3_MIN_FRAG_LOG_SIZE		  10
+#ifdef __KERNEL__
+# define EXT3_FRAG_SIZE(s)		((s)->u.ext3_sb.s_frag_size)
+# define EXT3_FRAGS_PER_BLOCK(s)	((s)->u.ext3_sb.s_frags_per_block)
+#else
+# define EXT3_FRAG_SIZE(s)		(EXT3_MIN_FRAG_SIZE << (s)->s_log_frag_size)
+# define EXT3_FRAGS_PER_BLOCK(s)	(EXT3_BLOCK_SIZE(s) / EXT3_FRAG_SIZE(s))
+#endif
+
+/*
+ * ACL structures
+ */
+struct ext3_acl_header	/* Header of Access Control Lists */
+{
+	__u32	aclh_size;
+	__u32	aclh_file_count;
+	__u32	aclh_acle_count;
+	__u32	aclh_first_acle;
+};
+
+struct ext3_acl_entry	/* Access Control List Entry */
+{
+	__u32	acle_size;
+	__u16	acle_perms;	/* Access permissions */
+	__u16	acle_type;	/* Type of entry */
+	__u16	acle_tag;	/* User or group identity */
+	__u16	acle_pad1;
+	__u32	acle_next;	/* Pointer on next entry for the */
+					/* same inode or on next free entry */
+};
+
+/*
+ * Structure of a blocks group descriptor
+ */
+struct ext3_group_desc
+{
+	__u32	bg_block_bitmap;		/* Blocks bitmap block */
+	__u32	bg_inode_bitmap;		/* Inodes bitmap block */
+	__u32	bg_inode_table;		/* Inodes table block */
+	__u16	bg_free_blocks_count;	/* Free blocks count */
+	__u16	bg_free_inodes_count;	/* Free inodes count */
+	__u16	bg_used_dirs_count;	/* Directories count */
+	__u16	bg_pad;
+	__u32	bg_reserved[3];
+};
+
+/*
+ * Macro-instructions used to manage group descriptors
+ */
+#ifdef __KERNEL__
+# define EXT3_BLOCKS_PER_GROUP(s)	((s)->u.ext3_sb.s_blocks_per_group)
+# define EXT3_DESC_PER_BLOCK(s)		((s)->u.ext3_sb.s_desc_per_block)
+# define EXT3_INODES_PER_GROUP(s)	((s)->u.ext3_sb.s_inodes_per_group)
+# define EXT3_DESC_PER_BLOCK_BITS(s)	((s)->u.ext3_sb.s_desc_per_block_bits)
+#else
+# define EXT3_BLOCKS_PER_GROUP(s)	((s)->s_blocks_per_group)
+# define EXT3_DESC_PER_BLOCK(s)		(EXT3_BLOCK_SIZE(s) / sizeof (struct ext3_group_desc))
+# define EXT3_INODES_PER_GROUP(s)	((s)->s_inodes_per_group)
+#endif
+
+/*
+ * Constants relative to the data blocks
+ */
+#define	EXT3_NDIR_BLOCKS		12
+#define	EXT3_IND_BLOCK			EXT3_NDIR_BLOCKS
+#define	EXT3_DIND_BLOCK			(EXT3_IND_BLOCK + 1)
+#define	EXT3_TIND_BLOCK			(EXT3_DIND_BLOCK + 1)
+#define	EXT3_N_BLOCKS			(EXT3_TIND_BLOCK + 1)
+
+/*
+ * Inode flags
+ */
+#define	EXT3_SECRM_FL			0x00000001 /* Secure deletion */
+#define	EXT3_UNRM_FL			0x00000002 /* Undelete */
+#define	EXT3_COMPR_FL			0x00000004 /* Compress file */
+#define EXT3_SYNC_FL			0x00000008 /* Synchronous updates */
+#define EXT3_IMMUTABLE_FL		0x00000010 /* Immutable file */
+#define EXT3_APPEND_FL			0x00000020 /* writes to file may only append */
+#define EXT3_NODUMP_FL			0x00000040 /* do not dump file */
+#define EXT3_NOATIME_FL			0x00000080 /* do not update atime */
+/* Reserved for compression usage... */
+#define EXT3_DIRTY_FL			0x00000100
+#define EXT3_COMPRBLK_FL		0x00000200 /* One or more compressed clusters */
+#define EXT3_NOCOMPR_FL			0x00000400 /* Don't compress */
+#define EXT3_ECOMPR_FL			0x00000800 /* Compression error */
+/* End compression flags --- maybe not all used */
+#define EXT3_INDEX_FL			0x00001000 /* hash-indexed directory */
+#define EXT3_IMAGIC_FL			0x00002000 /* AFS directory */
+#define EXT3_JOURNAL_DATA_FL		0x00004000 /* file data should be journaled */
+#define EXT3_RESERVED_FL		0x80000000 /* reserved for ext3 lib */
+
+#define EXT3_FL_USER_VISIBLE		0x00005FFF /* User visible flags */
+#define EXT3_FL_USER_MODIFIABLE		0x000000FF /* User modifiable flags */
+
+/*
+ * Inode dynamic state flags
+ */
+#define EXT3_STATE_JDATA		0x00000001 /* journaled data exists */
+#define EXT3_STATE_NEW			0x00000002 /* inode is newly created */
+
+/*
+ * ioctl commands
+ */
+#define	EXT3_IOC_GETFLAGS		_IOR('f', 1, long)
+#define	EXT3_IOC_SETFLAGS		_IOW('f', 2, long)
+#define	EXT3_IOC_GETVERSION		_IOR('f', 3, long)
+#define	EXT3_IOC_SETVERSION		_IOW('f', 4, long)
+#define	EXT3_IOC_GETVERSION_OLD		_IOR('v', 1, long)
+#define	EXT3_IOC_SETVERSION_OLD		_IOW('v', 2, long)
+#ifdef CONFIG_JBD_DEBUG
+#define EXT3_IOC_WAIT_FOR_READONLY	_IOR('f', 99, long)
+#endif
+
+/*
+ * Structure of an inode on the disk
+ */
+struct ext3_inode {
+	__u16	i_mode;		/* File mode */
+	__u16	i_uid;		/* Low 16 bits of Owner Uid */
+	__u32	i_size;		/* Size in bytes */
+	__u32	i_atime;	/* Access time */
+	__u32	i_ctime;	/* Creation time */
+	__u32	i_mtime;	/* Modification time */
+	__u32	i_dtime;	/* Deletion Time */
+	__u16	i_gid;		/* Low 16 bits of Group Id */
+	__u16	i_links_count;	/* Links count */
+	__u32	i_blocks;	/* Blocks count */
+	__u32	i_flags;	/* File flags */
+	union {
+		struct {
+			__u32  l_i_reserved1;
+		} linux1;
+		struct {
+			__u32  h_i_translator;
+		} hurd1;
+		struct {
+			__u32  m_i_reserved1;
+		} masix1;
+	} osd1;				/* OS dependent 1 */
+	__u32	i_block[EXT3_N_BLOCKS];/* Pointers to blocks */
+	__u32	i_generation;	/* File version (for NFS) */
+	__u32	i_file_acl;	/* File ACL */
+	__u32	i_dir_acl;	/* Directory ACL */
+	__u32	i_faddr;	/* Fragment address */
+	union {
+		struct {
+			__u8	l_i_frag;	/* Fragment number */
+			__u8	l_i_fsize;	/* Fragment size */
+			__u16	i_pad1;
+			__u16	l_i_uid_high;	/* these 2 fields    */
+			__u16	l_i_gid_high;	/* were reserved2[0] */
+			__u32	l_i_reserved2;
+		} linux2;
+		struct {
+			__u8	h_i_frag;	/* Fragment number */
+			__u8	h_i_fsize;	/* Fragment size */
+			__u16	h_i_mode_high;
+			__u16	h_i_uid_high;
+			__u16	h_i_gid_high;
+			__u32	h_i_author;
+		} hurd2;
+		struct {
+			__u8	m_i_frag;	/* Fragment number */
+			__u8	m_i_fsize;	/* Fragment size */
+			__u16	m_pad1;
+			__u32	m_i_reserved2[2];
+		} masix2;
+	} osd2;				/* OS dependent 2 */
+};
+
+#define i_size_high	i_dir_acl
+
+#if defined(__KERNEL__) || defined(__linux__)
+#define i_reserved1	osd1.linux1.l_i_reserved1
+#define i_frag		osd2.linux2.l_i_frag
+#define i_fsize		osd2.linux2.l_i_fsize
+#define i_uid_low	i_uid
+#define i_gid_low	i_gid
+#define i_uid_high	osd2.linux2.l_i_uid_high
+#define i_gid_high	osd2.linux2.l_i_gid_high
+#define i_reserved2	osd2.linux2.l_i_reserved2
+
+#elif defined(__GNU__)
+
+#define i_translator	osd1.hurd1.h_i_translator
+#define i_frag		osd2.hurd2.h_i_frag;
+#define i_fsize		osd2.hurd2.h_i_fsize;
+#define i_uid_high	osd2.hurd2.h_i_uid_high
+#define i_gid_high	osd2.hurd2.h_i_gid_high
+#define i_author	osd2.hurd2.h_i_author
+
+#elif defined(__masix__)
+
+#define i_reserved1	osd1.masix1.m_i_reserved1
+#define i_frag		osd2.masix2.m_i_frag
+#define i_fsize		osd2.masix2.m_i_fsize
+#define i_reserved2	osd2.masix2.m_i_reserved2
+
+#endif /* defined(__KERNEL__) || defined(__linux__) */
+
+/*
+ * File system states
+ */
+#define	EXT3_VALID_FS			0x0001	/* Unmounted cleanly */
+#define	EXT3_ERROR_FS			0x0002	/* Errors detected */
+#define	EXT3_ORPHAN_FS			0x0004	/* Orphans being recovered */
+
+/*
+ * Mount flags
+ */
+#define EXT3_MOUNT_CHECK		0x0001	/* Do mount-time checks */
+#define EXT3_MOUNT_GRPID		0x0004	/* Create files with directory's group */
+#define EXT3_MOUNT_DEBUG		0x0008	/* Some debugging messages */
+#define EXT3_MOUNT_ERRORS_CONT		0x0010	/* Continue on errors */
+#define EXT3_MOUNT_ERRORS_RO		0x0020	/* Remount fs ro on errors */
+#define EXT3_MOUNT_ERRORS_PANIC		0x0040	/* Panic on errors */
+#define EXT3_MOUNT_MINIX_DF		0x0080	/* Mimics the Minix statfs */
+#define EXT3_MOUNT_NOLOAD		0x0100	/* Don't use existing journal*/
+#define EXT3_MOUNT_ABORT		0x0200	/* Fatal error detected */
+#define EXT3_MOUNT_DATA_FLAGS		0x0C00	/* Mode for data writes: */
+  #define EXT3_MOUNT_JOURNAL_DATA	0x0400	/* Write data to journal */
+  #define EXT3_MOUNT_ORDERED_DATA	0x0800	/* Flush data before commit */
+  #define EXT3_MOUNT_WRITEBACK_DATA	0x0C00	/* No data ordering */
+#define EXT3_MOUNT_UPDATE_JOURNAL	0x1000	/* Update the journal format */
+#define EXT3_MOUNT_NO_UID32		0x2000  /* Disable 32-bit UIDs */
+
+/* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
+#ifndef _LINUX_EXT2_FS_H
+#define clear_opt(o, opt)		o &= ~EXT3_MOUNT_##opt
+#define set_opt(o, opt)			o |= EXT3_MOUNT_##opt
+#define test_opt(sb, opt)		((sb)->u.ext3_sb.s_mount_opt & \
+					 EXT3_MOUNT_##opt)
+#else
+#define EXT2_MOUNT_NOLOAD		EXT3_MOUNT_NOLOAD
+#define EXT2_MOUNT_ABORT		EXT3_MOUNT_ABORT
+#endif
+
+#define ext3_set_bit			ext2_set_bit
+#define ext3_clear_bit			ext2_clear_bit
+#define ext3_test_bit			ext2_test_bit
+#define ext3_find_first_zero_bit	ext2_find_first_zero_bit
+#define ext3_find_next_zero_bit		ext2_find_next_zero_bit
+
+/*
+ * Maximal mount counts between two filesystem checks
+ */
+#define EXT3_DFL_MAX_MNT_COUNT		20	/* Allow 20 mounts */
+#define EXT3_DFL_CHECKINTERVAL		0	/* Don't use interval check */
+
+/*
+ * Behaviour when detecting errors
+ */
+#define EXT3_ERRORS_CONTINUE		1	/* Continue execution */
+#define EXT3_ERRORS_RO			2	/* Remount fs read-only */
+#define EXT3_ERRORS_PANIC		3	/* Panic */
+#define EXT3_ERRORS_DEFAULT		EXT3_ERRORS_CONTINUE
+
+/*
+ * Structure of the super block
+ */
+struct ext3_super_block {
+/*00*/	__u32	s_inodes_count;		/* Inodes count */
+	__u32	s_blocks_count;		/* Blocks count */
+	__u32	s_r_blocks_count;	/* Reserved blocks count */
+	__u32	s_free_blocks_count;	/* Free blocks count */
+/*10*/	__u32	s_free_inodes_count;	/* Free inodes count */
+	__u32	s_first_data_block;	/* First Data Block */
+	__u32	s_log_block_size;	/* Block size */
+	__s32	s_log_frag_size;	/* Fragment size */
+/*20*/	__u32	s_blocks_per_group;	/* # Blocks per group */
+	__u32	s_frags_per_group;	/* # Fragments per group */
+	__u32	s_inodes_per_group;	/* # Inodes per group */
+	__u32	s_mtime;		/* Mount time */
+/*30*/	__u32	s_wtime;		/* Write time */
+	__u16	s_mnt_count;		/* Mount count */
+	__s16	s_max_mnt_count;	/* Maximal mount count */
+	__u16	s_magic;		/* Magic signature */
+	__u16	s_state;		/* File system state */
+	__u16	s_errors;		/* Behaviour when detecting errors */
+	__u16	s_minor_rev_level;	/* minor revision level */
+/*40*/	__u32	s_lastcheck;		/* time of last check */
+	__u32	s_checkinterval;	/* max. time between checks */
+	__u32	s_creator_os;		/* OS */
+	__u32	s_rev_level;		/* Revision level */
+/*50*/	__u16	s_def_resuid;		/* Default uid for reserved blocks */
+	__u16	s_def_resgid;		/* Default gid for reserved blocks */
+	/*
+	 * These fields are for EXT3_DYNAMIC_REV superblocks only.
+	 *
+	 * Note: the difference between the compatible feature set and
+	 * the incompatible feature set is that if there is a bit set
+	 * in the incompatible feature set that the kernel doesn't
+	 * know about, it should refuse to mount the filesystem.
+	 *
+	 * e2fsck's requirements are more strict; if it doesn't know
+	 * about a feature in either the compatible or incompatible
+	 * feature set, it must abort and not try to meddle with
+	 * things it doesn't understand...
+	 */
+	__u32	s_first_ino;		/* First non-reserved inode */
+	__u16   s_inode_size;		/* size of inode structure */
+	__u16	s_block_group_nr;	/* block group # of this superblock */
+	__u32	s_feature_compat;	/* compatible feature set */
+/*60*/	__u32	s_feature_incompat;	/* incompatible feature set */
+	__u32	s_feature_ro_compat;	/* readonly-compatible feature set */
+/*68*/	__u8	s_uuid[16];		/* 128-bit uuid for volume */
+/*78*/	char	s_volume_name[16];	/* volume name */
+/*88*/	char	s_last_mounted[64];	/* directory where last mounted */
+/*C8*/	__u32	s_algorithm_usage_bitmap; /* For compression */
+	/*
+	 * Performance hints.  Directory preallocation should only
+	 * happen if the EXT3_FEATURE_COMPAT_DIR_PREALLOC flag is on.
+	 */
+	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
+	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
+	__u16	s_padding1;
+	/*
+	 * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
+	 */
+/*D0*/	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
+/*E0*/	__u32	s_journal_inum;		/* inode number of journal file */
+	__u32	s_journal_dev;		/* device number of journal file */
+	__u32	s_last_orphan;		/* start of list of inodes to delete */
+
+/*EC*/	__u32	s_reserved[197];	/* Padding to the end of the block */
+};
+
+#ifdef __KERNEL__
+#define EXT3_SB(sb)	(&((sb)->u.ext3_sb))
+#define EXT3_I(inode)	(&((inode)->u.ext3_i))
+#else
+/* Assume that user mode programs are passing in an ext3fs superblock, not
+ * a kernel struct super_block.  This will allow us to call the feature-test
+ * macros from user land. */
+#define EXT3_SB(sb)	(sb)
+#endif
+
+#define NEXT_ORPHAN(inode) (inode)->u.ext3_i.i_dtime
+
+/*
+ * Codes for operating systems
+ */
+#define EXT3_OS_LINUX		0
+#define EXT3_OS_HURD		1
+#define EXT3_OS_MASIX		2
+#define EXT3_OS_FREEBSD		3
+#define EXT3_OS_LITES		4
+
+/*
+ * Revision levels
+ */
+#define EXT3_GOOD_OLD_REV	0	/* The good old (original) format */
+#define EXT3_DYNAMIC_REV	1	/* V2 format w/ dynamic inode sizes */
+
+#define EXT3_CURRENT_REV	EXT3_GOOD_OLD_REV
+#define EXT3_MAX_SUPP_REV	EXT3_DYNAMIC_REV
+
+#define EXT3_GOOD_OLD_INODE_SIZE 128
+
+/*
+ * Feature set definitions
+ */
+
+#define EXT3_HAS_COMPAT_FEATURE(sb,mask)			\
+	( EXT3_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
+#define EXT3_HAS_RO_COMPAT_FEATURE(sb,mask)			\
+	( EXT3_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
+#define EXT3_HAS_INCOMPAT_FEATURE(sb,mask)			\
+	( EXT3_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
+#define EXT3_SET_COMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
+#define EXT3_SET_RO_COMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
+#define EXT3_SET_INCOMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
+#define EXT3_CLEAR_COMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
+#define EXT3_CLEAR_RO_COMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
+#define EXT3_CLEAR_INCOMPAT_FEATURE(sb,mask)			\
+	EXT3_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
+
+#define EXT3_FEATURE_COMPAT_DIR_PREALLOC	0x0001
+#define EXT3_FEATURE_COMPAT_IMAGIC_INODES	0x0002
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x0004
+#define EXT3_FEATURE_COMPAT_EXT_ATTR		0x0008
+#define EXT3_FEATURE_COMPAT_RESIZE_INODE	0x0010
+#define EXT3_FEATURE_COMPAT_DIR_INDEX		0x0020
+
+#define EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
+#define EXT3_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
+#define EXT3_FEATURE_RO_COMPAT_BTREE_DIR	0x0004
+
+#define EXT3_FEATURE_INCOMPAT_COMPRESSION	0x0001
+#define EXT3_FEATURE_INCOMPAT_FILETYPE		0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004 /* Needs recovery */
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008 /* Journal device */
+
+#define EXT3_FEATURE_COMPAT_SUPP	0
+/*#define EXT3_FEATURE_INCOMPAT_SUPP	(EXT3_FEATURE_INCOMPAT_FILETYPE| \
+					 EXT3_FEATURE_INCOMPAT_RECOVER)*/
+#define EXT3_FEATURE_INCOMPAT_SUPP	(EXT3_FEATURE_INCOMPAT_FILETYPE)
+#define EXT3_FEATURE_RO_COMPAT_SUPP	(EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \
+					 EXT3_FEATURE_RO_COMPAT_LARGE_FILE| \
+					 EXT3_FEATURE_RO_COMPAT_BTREE_DIR)
+
+/*
+ * Default values for user and/or group using reserved blocks
+ */
+#define	EXT3_DEF_RESUID		0
+#define	EXT3_DEF_RESGID		0
+
+/*
+ * Structure of a directory entry
+ */
+#define EXT3_NAME_LEN 255
+
+struct ext3_dir_entry {
+	__u32	inode;			/* Inode number */
+	__u16	rec_len;		/* Directory entry length */
+	__u16	name_len;		/* Name length */
+	char	name[EXT3_NAME_LEN];	/* File name */
+};
+
+/*
+ * The new version of the directory entry.  Since EXT3 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct ext3_dir_entry_2 {
+	__u32	inode;			/* Inode number */
+	__u16	rec_len;		/* Directory entry length */
+	__u8	name_len;		/* Name length */
+	__u8	file_type;
+	char	name[EXT3_NAME_LEN];	/* File name */
+};
+
+/*
+ * Ext3 directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+#define EXT3_FT_UNKNOWN		0
+#define EXT3_FT_REG_FILE	1
+#define EXT3_FT_DIR		2
+#define EXT3_FT_CHRDEV		3
+#define EXT3_FT_BLKDEV		4
+#define EXT3_FT_FIFO		5
+#define EXT3_FT_SOCK		6
+#define EXT3_FT_SYMLINK		7
+
+#define EXT3_FT_MAX		8
+
+/*
+ * EXT3_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 4
+ */
+#define EXT3_DIR_PAD			4
+#define EXT3_DIR_ROUND			(EXT3_DIR_PAD - 1)
+#define EXT3_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT3_DIR_ROUND) & \
+					 ~EXT3_DIR_ROUND)
+
+#ifdef __KERNEL__
+/*
+ * Describe an inode's exact location on disk and in memory
+ */
+struct ext3_iloc
+{
+	struct buffer_head *bh;
+	struct ext3_inode *raw_inode;
+	unsigned long block_group;
+};
+
+
+
+#endif	/* __KERNEL__ */
+
+#endif	/* _LINUX_EXT3_FS_H */
+
+
+
+typedef struct ext3_super_block	EXT2_SUPER_BLOCK, *PEXT2_SUPER_BLOCK;
+typedef struct ext3_inode		EXT2_INODE, *PEXT2_INODE;
+typedef struct ext3_group_desc	EXT2_GROUP_DESC, *PEXT2_GROUP_DESC;
+typedef struct ext3_dir_entry_2	EXT2_DIR_ENTRY, *PEXT2_DIR_ENTRY;
+
+// EXT2_INODE::i_mode values
+#define EXT2_S_IRWXO	0x0007	// Other mask
+#define EXT2_S_IXOTH	0x0001	// ---------x execute
+#define EXT2_S_IWOTH	0x0002	// --------w- write
+#define EXT2_S_IROTH	0x0004	// -------r-- read
+
+#define EXT2_S_IRWXG	0x0038	// Group mask
+#define EXT2_S_IXGRP	0x0008	// ------x--- execute
+#define EXT2_S_IWGRP	0x0010	// -----w---- write
+#define EXT2_S_IRGRP	0x0020	// ----r----- read
+
+#define EXT2_S_IRWXU	0x01C0	// User mask
+#define EXT2_S_IXUSR	0x0040	// ---x------ execute
+#define EXT2_S_IWUSR	0x0080	// --w------- write
+#define EXT2_S_IRUSR	0x0100	// -r-------- read
+
+#define EXT2_S_ISVTX	0x0200	// Sticky bit
+#define EXT2_S_ISGID	0x0400	// SGID
+#define EXT2_S_ISUID	0x0800	// SUID
+
+#define EXT2_S_IFMT		0xF000	// Format mask
+#define EXT2_S_IFIFO	0x1000	// FIFO buffer
+#define EXT2_S_IFCHR	0x2000	// Character device
+#define EXT2_S_IFDIR	0x4000	// Directory
+#define EXT2_S_IFBLK	0x6000	// Block device
+#define EXT2_S_IFREG	0x8000	// Regular file
+#define EXT2_S_IFLNK	0xA000	// Symbolic link
+#define EXT2_S_IFSOCK	0xC000	// Socket
+
+#define FAST_SYMLINK_MAX_NAME_SIZE	(EXT3_N_BLOCKS * sizeof(U32)) /* 60 bytes */
+
+typedef struct
+{
+	U64			FileSize;			// File size
+	U64			FilePointer;		// File pointer
+	U32*		FileBlockList;		// File block list
+	U8			DriveNumber;		// Drive number of open file
+	EXT2_INODE	Inode;				// File's inode
+} EXT2_FILE_INFO, * PEXT2_FILE_INFO;
+
+
+
+BOOL	Ext2OpenVolume(U8 DriveNumber, U64 VolumeStartSector);
+FILE*	Ext2OpenFile(PUCHAR FileName);
+BOOL	Ext2LookupFile(PUCHAR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer);
+BOOL	Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 DirectorySize, PUCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry);
+BOOL	Ext2ReadFile(FILE *FileHandle, U64 BytesToRead, U64* BytesRead, PVOID Buffer);
+U64		Ext2GetFileSize(FILE *FileHandle);
+VOID	Ext2SetFilePointer(FILE *FileHandle, U64 NewFilePointer);
+U64		Ext2GetFilePointer(FILE *FileHandle);
+BOOL	Ext2ReadVolumeSectors(U8 DriveNumber, U64 SectorNumber, U64 SectorCount, PVOID Buffer);
+
+BOOL	Ext2ReadSuperBlock(VOID);
+BOOL	Ext2ReadGroupDescriptors(VOID);
+BOOL	Ext2ReadDirectory(U32 Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer);
+BOOL	Ext2ReadBlock(U32 BlockNumber, PVOID Buffer);
+BOOL	Ext2ReadPartialBlock(U32 BlockNumber, U32 StartingOffset, U32 Length, PVOID Buffer);
+U32		Ext2GetGroupDescBlockNumber(U32 Group);
+U32		Ext2GetGroupDescOffsetInBlock(U32 Group);
+U32		Ext2GetInodeGroupNumber(U32 Inode);
+U32		Ext2GetInodeBlockNumber(U32 Inode);
+U32		Ext2GetInodeOffsetInBlock(U32 Inode);
+BOOL	Ext2ReadInode(U32 Inode, PEXT2_INODE InodeBuffer);
+BOOL	Ext2ReadGroupDescriptor(U32 Group, PEXT2_GROUP_DESC GroupBuffer);
+U32*	Ext2ReadBlockPointerList(PEXT2_INODE Inode);
+U64		Ext2GetInodeFileSize(PEXT2_INODE Inode);
+BOOL	Ext2CopyIndirectBlockPointers(U32* BlockList, U32* CurrentBlockInList, U32 BlockCount, U32 IndirectBlock);
+BOOL	Ext2CopyDoubleIndirectBlockPointers(U32* BlockList, U32* CurrentBlockInList, U32 BlockCount, U32 DoubleIndirectBlock);
+BOOL	Ext2CopyTripleIndirectBlockPointers(U32* BlockList, U32* CurrentBlockInList, U32 BlockCount, U32 TripleIndirectBlock);
+
+#endif // #defined __EXT2_H

freeldr/freeldr/fs/fat.h

@@ -0,0 +1,192 @@
+/*
+ *  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.
+ */
+
+#ifndef __FAT_H
+#define __FAT_H
+
+typedef struct _FAT_BOOTSECTOR
+{
+	U8		JumpBoot[3];				// Jump instruction to boot code
+	U8		OemName[8];					// "MSWIN4.1" for MS formatted volumes
+	U16		BytesPerSector;				// Bytes per sector
+	U8		SectorsPerCluster;			// Number of sectors in a cluster
+	U16		ReservedSectors;			// Reserved sectors, usually 1 (the bootsector)
+	U8		NumberOfFats;				// Number of FAT tables
+	U16		RootDirEntries;				// Number of root directory entries (fat12/16)
+	U16		TotalSectors;				// Number of total sectors on the drive, 16-bit
+	U8		MediaDescriptor;			// Media descriptor byte
+	U16		SectorsPerFat;				// Sectors per FAT table (fat12/16)
+	U16		SectorsPerTrack;			// Number of sectors in a track
+	U16		NumberOfHeads;				// Number of heads on the disk
+	U32		HiddenSectors;				// Hidden sectors (sectors before the partition start like the partition table)
+	U32		TotalSectorsBig;			// This field is the new 32-bit total count of sectors on the volume
+	U8		DriveNumber;				// Int 0x13 drive number (e.g. 0x80)
+	U8		Reserved1;					// Reserved (used by Windows NT). Code that formats FAT volumes should always set this byte to 0.
+	U8		BootSignature;				// Extended boot signature (0x29). This is a signature byte that indicates that the following three fields in the boot sector are present.
+	U32		VolumeSerialNumber;			// Volume serial number
+	U8		VolumeLabel[11];			// Volume label. This field matches the 11-byte volume label recorded in the root directory
+	U8		FileSystemType[8];			// One of the strings "FAT12   ", "FAT16   ", or "FAT     "
+
+	U8		BootCodeAndData[448];		// The remainder of the boot sector
+
+	U16		BootSectorMagic;			// 0xAA55
+	
+} PACKED FAT_BOOTSECTOR, *PFAT_BOOTSECTOR;
+
+typedef struct _FAT32_BOOTSECTOR
+{
+	U8		JumpBoot[3];				// Jump instruction to boot code
+	U8		OemName[8];					// "MSWIN4.1" for MS formatted volumes
+	U16		BytesPerSector;				// Bytes per sector
+	U8		SectorsPerCluster;			// Number of sectors in a cluster
+	U16		ReservedSectors;			// Reserved sectors, usually 1 (the bootsector)
+	U8		NumberOfFats;				// Number of FAT tables
+	U16		RootDirEntries;				// Number of root directory entries (fat12/16)
+	U16		TotalSectors;				// Number of total sectors on the drive, 16-bit
+	U8		MediaDescriptor;			// Media descriptor byte
+	U16		SectorsPerFat;				// Sectors per FAT table (fat12/16)
+	U16		SectorsPerTrack;			// Number of sectors in a track
+	U16		NumberOfHeads;				// Number of heads on the disk
+	U32		HiddenSectors;				// Hidden sectors (sectors before the partition start like the partition table)
+	U32		TotalSectorsBig;			// This field is the new 32-bit total count of sectors on the volume
+	U32		SectorsPerFatBig;			// This field is the FAT32 32-bit count of sectors occupied by ONE FAT. BPB_FATSz16 must be 0
+	U16		ExtendedFlags;				// Extended flags (fat32)
+	U16		FileSystemVersion;			// File system version (fat32)
+	U32		RootDirStartCluster;		// Starting cluster of the root directory (fat32)
+	U16		FsInfo;						// Sector number of FSINFO structure in the reserved area of the FAT32 volume. Usually 1.
+	U16		BackupBootSector;			// If non-zero, indicates the sector number in the reserved area of the volume of a copy of the boot record. Usually 6.
+	U8		Reserved[12];				// Reserved for future expansion
+	U8		DriveNumber;				// Int 0x13 drive number (e.g. 0x80)
+	U8		Reserved1;					// Reserved (used by Windows NT). Code that formats FAT volumes should always set this byte to 0.
+	U8		BootSignature;				// Extended boot signature (0x29). This is a signature byte that indicates that the following three fields in the boot sector are present.
+	U32		VolumeSerialNumber;			// Volume serial number
+	U8		VolumeLabel[11];			// Volume label. This field matches the 11-byte volume label recorded in the root directory
+	U8		FileSystemType[8];			// Always set to the string "FAT32   "
+
+	U8		BootCodeAndData[420];		// The remainder of the boot sector
+
+	U16		BootSectorMagic;			// 0xAA55
+	
+} 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 */
+} 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 */
+	WCHAR	Name5_10[6];		/* 6 more characters in name */
+	U16	StartCluster;		/* Starting cluster number */
+	WCHAR	Name11_12[2];		/* Last 2 characters in name */
+} PACKED LFN_DIRENTRY, * PLFN_DIRENTRY;
+
+typedef struct
+{
+	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 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*	FatGetClusterChainArray(U32 StartCluster);
+BOOL	FatReadCluster(U32 ClusterNumber, PVOID Buffer);
+BOOL	FatReadClusterChain(U32 StartClusterNumber, U32 NumberOfClusters, PVOID Buffer);
+BOOL	FatReadPartialCluster(U32 ClusterNumber, U32 StartingOffset, U32 Length, PVOID Buffer);
+BOOL	FatReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer);
+U32		FatGetFileSize(FILE *FileHandle);
+VOID	FatSetFilePointer(FILE *FileHandle, U32 NewFilePointer);
+U32		FatGetFilePointer(FILE *FileHandle);
+BOOL	FatReadVolumeSectors(U32 DriveNumber, U32 SectorNumber, U32 SectorCount, PVOID Buffer);
+
+
+#define	ATTR_NORMAL		0x00
+#define	ATTR_READONLY	0x01
+#define	ATTR_HIDDEN		0x02
+#define	ATTR_SYSTEM		0x04
+#define	ATTR_VOLUMENAME	0x08
+#define	ATTR_DIRECTORY	0x10
+#define	ATTR_ARCHIVE	0x20
+#define ATTR_LONG_NAME	(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUMENAME)
+
+#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

@@ -0,0 +1,419 @@
+/*
+ *  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 <fs.h>
+#include "fat.h"
+#include "iso.h"
+#include "ext2.h"
+#include "ntfs.h"
+#include "fsrec.h"
+#include <disk.h>
+#include <rtl.h>
+#include <ui.h>
+#include <arch.h>
+#include <debug.h>
+#include <machine.h>
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// DATA
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+U32			FileSystemType = 0;	// Type of filesystem on boot device, set by FsOpenVolume()
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+VOID FileSystemError(PUCHAR ErrorString)
+{
+	DbgPrint((DPRINT_FILESYSTEM, "%s\n", ErrorString));
+
+	UiMessageBox(ErrorString);
+}
+
+/*
+ *
+ * BOOL FsOpenVolume(U32 DriveNumber, U32 PartitionNumber);
+ *
+ * This function is called to open a disk volume for file access.
+ * It must be called before any of the file functions will work.
+ * It takes two parameters:
+ *
+ * Drive: The BIOS drive number of the disk to open
+ * Partition: This is zero for floppy drives.
+ *            If the disk is a hard disk then this specifies
+ *            The partition number to open (1 - 4)
+ *            If it is zero then it opens the active (bootable) partition
+ *
+ */
+BOOL FsOpenVolume(U32 DriveNumber, U32 PartitionNumber)
+{
+	PARTITION_TABLE_ENTRY	PartitionTableEntry;
+	UCHAR					ErrorText[80];
+	U8						VolumeType;
+
+	DbgPrint((DPRINT_FILESYSTEM, "FsOpenVolume() DriveNumber: 0x%x PartitionNumber: 0x%x\n", DriveNumber, PartitionNumber));
+
+	// Check and see if it is a floppy drive
+	// If so then just assume FAT12 file system type
+	if (DiskIsDriveRemovable(DriveNumber))
+	{
+		DbgPrint((DPRINT_FILESYSTEM, "Drive is a floppy diskette drive. Assuming FAT12 file system.\n"));
+
+		FileSystemType = FS_FAT;
+		return FatOpenVolume(DriveNumber, 0, 0);
+	}
+
+	// Check for ISO9660 file system type
+	if (DriveNumber >= 0x80 && FsRecIsIso9660(DriveNumber))
+	{
+		DbgPrint((DPRINT_FILESYSTEM, "Drive is a cdrom drive. Assuming ISO-9660 file system.\n"));
+
+		FileSystemType = FS_ISO9660;
+		return IsoOpenVolume(DriveNumber);
+	}
+
+	// Set the boot partition
+	BootPartition = PartitionNumber;
+
+	// Get the requested partition entry
+	if (PartitionNumber == 0)
+	{
+		// Partition requested was zero which means the boot partition
+		if (DiskGetActivePartitionEntry(DriveNumber, &PartitionTableEntry) == FALSE)
+		{
+			FileSystemError("No active partition.");
+			return FALSE;
+		}
+	}
+	else
+	{
+		// Get requested partition
+		if (MachDiskGetPartitionEntry(DriveNumber, PartitionNumber, &PartitionTableEntry) == FALSE)
+		{
+			FileSystemError("Partition not found.");
+			return FALSE;
+		}
+	}
+
+	// Check for valid partition
+	if (PartitionTableEntry.SystemIndicator == PARTITION_ENTRY_UNUSED)
+	{
+		FileSystemError("Invalid partition.");
+		return FALSE;
+	}
+
+	// Try to recognize the file system
+	if (!FsRecognizeVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition, &VolumeType))
+	{
+		FileSystemError("Unrecognized file system.");
+		return FALSE;
+	}
+
+	//switch (PartitionTableEntry.SystemIndicator)
+	switch (VolumeType)
+	{
+	case PARTITION_FAT_12:
+	case PARTITION_FAT_16:
+	case PARTITION_HUGE:
+	case PARTITION_XINT13:
+	case PARTITION_FAT32:
+	case PARTITION_FAT32_XINT13:
+		FileSystemType = FS_FAT;
+		return FatOpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition, PartitionTableEntry.PartitionSectorCount);
+	case PARTITION_EXT2:
+		FileSystemType = FS_EXT2;
+		return Ext2OpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition);
+	case PARTITION_NTFS:
+		FileSystemType = FS_NTFS;
+		return NtfsOpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition);
+	default:
+		FileSystemType = 0;
+		sprintf(ErrorText, "Unsupported file system. Type: 0x%x", VolumeType);
+		FileSystemError(ErrorText);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+PFILE FsOpenFile(PUCHAR FileName)
+{
+	PFILE	FileHandle = NULL;
+
+	//
+	// Print status message
+	//
+	DbgPrint((DPRINT_FILESYSTEM, "Opening file '%s'...\n", FileName));
+
+	//
+	// Check and see if the first character is '\' or '/' and remove it if so
+	//
+	while ((*FileName == '\\') || (*FileName == '/'))
+	{
+		FileName++;
+	}
+	
+	//
+	// Check file system type and pass off to appropriate handler
+	//
+	switch (FileSystemType)
+	{
+	case FS_FAT:
+		FileHandle = FatOpenFile(FileName);
+		break;
+	case FS_ISO9660:
+		FileHandle = IsoOpenFile(FileName);
+		break;
+	case FS_EXT2:
+		FileHandle = Ext2OpenFile(FileName);
+		break;
+	case FS_NTFS:
+		FileHandle = NtfsOpenFile(FileName);
+		break;
+	default:
+		FileSystemError("Error: Unknown filesystem.");
+		break;
+	}
+
+#ifdef DEBUG
+	//
+	// Check return value
+	//
+	if (FileHandle != NULL)
+	{
+		DbgPrint((DPRINT_FILESYSTEM, "FsOpenFile() succeeded. FileHandle: 0x%x\n", FileHandle));
+	}
+	else
+	{
+		DbgPrint((DPRINT_FILESYSTEM, "FsOpenFile() failed.\n"));
+	}
+#endif // defined DEBUG
+
+	return FileHandle;
+}
+
+VOID FsCloseFile(PFILE FileHandle)
+{
+}
+
+/*
+ * ReadFile()
+ * returns number of bytes read or EOF
+ */
+BOOL FsReadFile(PFILE FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer)
+{
+	U64		BytesReadBig;
+	BOOL	Success;
+
+	//
+	// Set the number of bytes read equal to zero
+	//
+	if (BytesRead != NULL)
+	{
+		*BytesRead = 0;
+	}
+
+	switch (FileSystemType)
+	{
+	case FS_FAT:
+
+		return FatReadFile(FileHandle, BytesToRead, BytesRead, Buffer);
+
+	case FS_ISO9660:
+
+		return IsoReadFile(FileHandle, BytesToRead, BytesRead, Buffer);
+
+	case FS_EXT2:
+
+		//return Ext2ReadFile(FileHandle, BytesToRead, BytesRead, Buffer);
+		Success = Ext2ReadFile(FileHandle, BytesToRead, &BytesReadBig, Buffer);
+		*BytesRead = (U32)BytesReadBig;
+		return Success;
+
+	case FS_NTFS:
+
+		return NtfsReadFile(FileHandle, BytesToRead, BytesRead, Buffer);
+
+	default:
+
+		FileSystemError("Unknown file system.");
+		return FALSE;
+	}
+
+	return FALSE;
+}
+
+U32 FsGetFileSize(PFILE FileHandle)
+{
+	switch (FileSystemType)
+	{
+	case FS_FAT:
+
+		return FatGetFileSize(FileHandle);
+
+	case FS_ISO9660:
+
+		return IsoGetFileSize(FileHandle);
+
+	case FS_EXT2:
+
+		return Ext2GetFileSize(FileHandle);
+
+	case FS_NTFS:
+
+		return NtfsGetFileSize(FileHandle);
+
+	default:
+		FileSystemError("Unknown file system.");
+		break;
+	}
+
+	return 0;
+}
+
+VOID FsSetFilePointer(PFILE FileHandle, U32 NewFilePointer)
+{
+	switch (FileSystemType)
+	{
+	case FS_FAT:
+
+		FatSetFilePointer(FileHandle, NewFilePointer);
+		break;
+
+	case FS_ISO9660:
+
+		IsoSetFilePointer(FileHandle, NewFilePointer);
+		break;
+
+	case FS_EXT2:
+
+		Ext2SetFilePointer(FileHandle, NewFilePointer);
+		break;
+
+	case FS_NTFS:
+
+		NtfsSetFilePointer(FileHandle, NewFilePointer);
+		break;
+
+	default:
+		FileSystemError("Unknown file system.");
+		break;
+	}
+}
+
+U32 FsGetFilePointer(PFILE FileHandle)
+{
+	switch (FileSystemType)
+	{
+	case FS_FAT:
+
+		return FatGetFilePointer(FileHandle);
+		break;
+
+	case FS_ISO9660:
+
+		return IsoGetFilePointer(FileHandle);
+		break;
+
+	case FS_EXT2:
+
+		return Ext2GetFilePointer(FileHandle);
+		break;
+
+	case FS_NTFS:
+
+		return NtfsGetFilePointer(FileHandle);
+		break;
+
+	default:
+		FileSystemError("Unknown file system.");
+		break;
+	}
+
+	return 0;
+}
+
+BOOL FsIsEndOfFile(PFILE FileHandle)
+{
+	if (FsGetFilePointer(FileHandle) >= FsGetFileSize(FileHandle))
+	{
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+/*
+ * FsGetNumPathParts()
+ * This function parses a path in the form of dir1\dir2\file1.ext
+ * and returns the number of parts it has (i.e. 3 - dir1,dir2,file1.ext)
+ */
+U32 FsGetNumPathParts(PUCHAR Path)
+{
+	U32		i;
+	U32		num;
+
+	for (i=0,num=0; i<(int)strlen(Path); i++)
+	{
+		if ((Path[i] == '\\') || (Path[i] == '/'))
+		{
+			num++;
+		}
+	}
+	num++;
+
+	DbgPrint((DPRINT_FILESYSTEM, "FatGetNumPathParts() Path = %s NumPathParts = %d\n", Path, num));
+
+	return num;
+}
+
+/*
+ * FsGetFirstNameFromPath()
+ * This function parses a path in the form of dir1\dir2\file1.ext
+ * and puts the first name of the path (e.g. "dir1") in buffer
+ * compatible with the MSDOS directory structure
+ */
+VOID FsGetFirstNameFromPath(PUCHAR Buffer, PUCHAR Path)
+{
+	U32		i;
+
+	// Copy all the characters up to the end of the
+	// string or until we hit a '\' character
+	// and put them in Buffer
+	for (i=0; i<(int)strlen(Path); i++)
+	{
+		if ((Path[i] == '\\') || (Path[i] == '/'))
+		{
+			break;
+		}
+		else
+		{
+			Buffer[i] = Path[i];
+		}
+	}
+
+	Buffer[i] = 0;
+
+	DbgPrint((DPRINT_FILESYSTEM, "FatGetFirstNameFromPath() Path = %s FirstName = %s\n", Path, Buffer));
+}

freeldr/freeldr/fs/fsrec.c

@@ -0,0 +1,142 @@
+/*
+ *  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 <fs.h>
+#include "fsrec.h"
+#include "fat.h"
+#include "iso.h"
+#include "ext2.h"
+#include "ntfs.h"
+#include <disk.h>
+#include <rtl.h>
+#include <arch.h>
+#include <debug.h>
+#include <machine.h>
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ *
+ * BOOL FsRecognizeVolume(U32 DriveNumber, U32 VolumeStartSector, U8* VolumeType);
+ *
+ */
+BOOL FsRecognizeVolume(U32 DriveNumber, U32 VolumeStartSector, U8* VolumeType)
+{
+
+	DbgPrint((DPRINT_FILESYSTEM, "FsRecognizeVolume() DriveNumber: 0x%x VolumeStartSector: %d\n", DriveNumber, VolumeStartSector));
+
+	if (FsRecIsExt2(DriveNumber, VolumeStartSector))
+	{
+		*VolumeType = PARTITION_EXT2;
+		return TRUE;
+	}
+	else if (FsRecIsFat(DriveNumber, VolumeStartSector))
+	{
+		*VolumeType = PARTITION_FAT32;
+		return TRUE;
+	}
+	else if (FsRecIsNtfs(DriveNumber, VolumeStartSector))
+	{
+		*VolumeType = PARTITION_NTFS;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL FsRecIsIso9660(U32 DriveNumber)
+{
+	PUCHAR Sector = (PUCHAR)DISKREADBUFFER;
+
+	if (!MachDiskReadLogicalSectors(DriveNumber, 16, 1, Sector))
+	{
+		FileSystemError("Failed to read the PVD.");
+		return FALSE;
+	}
+
+	return (Sector[0] == 1 &&
+		Sector[1] == 'C' &&
+		Sector[2] == 'D' &&
+		Sector[3] == '0' &&
+		Sector[4] == '0' &&
+		Sector[5] == '1');
+}
+
+BOOL FsRecIsExt2(U32 DriveNumber, U32 VolumeStartSector)
+{
+	PEXT2_SUPER_BLOCK	SuperBlock = (PEXT2_SUPER_BLOCK)DISKREADBUFFER;
+
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector + 2, 2, SuperBlock))
+	{
+		FileSystemError("Failed to read the super block.");
+		return FALSE;
+	}
+
+	if (SuperBlock->s_magic == EXT3_SUPER_MAGIC)
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL FsRecIsFat(U32 DriveNumber, U32 VolumeStartSector)
+{
+	PFAT_BOOTSECTOR	BootSector = (PFAT_BOOTSECTOR)DISKREADBUFFER;
+	PFAT32_BOOTSECTOR BootSector32 = (PFAT32_BOOTSECTOR)DISKREADBUFFER;
+	PFATX_BOOTSECTOR BootSectorX = (PFATX_BOOTSECTOR)DISKREADBUFFER;
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
+	{
+		FileSystemError("Failed to read the boot sector.");
+		return FALSE;
+	}
+
+	if (strncmp(BootSector->FileSystemType, "FAT12   ", 8) == 0 ||
+		strncmp(BootSector->FileSystemType, "FAT16   ", 8) == 0 ||
+		strncmp(BootSector32->FileSystemType, "FAT32   ", 8) == 0 ||
+		strncmp(BootSectorX->FileSystemType, "FATX", 4) == 0)
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL FsRecIsNtfs(U32 DriveNumber, U32 VolumeStartSector)
+{
+	PNTFS_BOOTSECTOR BootSector = (PNTFS_BOOTSECTOR)DISKREADBUFFER;
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
+	{
+		FileSystemError("Failed to read the boot sector.");
+		return FALSE;
+	}
+
+	if (!RtlCompareMemory(BootSector->SystemId, "NTFS", 4))
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}

freeldr/freeldr/fs/fsrec.h

@@ -0,0 +1,29 @@
+/*
+ *  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.
+ */
+
+#ifndef __FSREC_H
+#define __FSREC_H
+
+BOOL	FsRecognizeVolume(U32 DriveNumber, U32 VolumeStartSector, U8* VolumeType);
+BOOL	FsRecIsIso9660(U32 DriveNumber);
+BOOL	FsRecIsExt2(U32 DriveNumber, U32 VolumeStartSector);
+BOOL	FsRecIsFat(U32 DriveNumber, U32 VolumeStartSector);
+BOOL	FsRecIsNtfs(U32 DriveNumber, U32 VolumeStartSector);
+
+#endif // #defined __FSREC_H

freeldr/freeldr/fs/iso.c

@@ -0,0 +1,479 @@
+/*
+ *  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 <fs.h>
+#include <disk.h>
+#include <rtl.h>
+#include <arch.h>
+#include <mm.h>
+#include <debug.h>
+#include <cache.h>
+#include <machine.h>
+
+#include "iso.h"
+
+
+#define SECTORSIZE 2048
+
+static U32		IsoRootSector;		// Starting sector of the root directory
+static U32		IsoRootLength;		// Length of the root directory
+
+U32			IsoDriveNumber = 0;
+
+
+BOOL IsoOpenVolume(U32 DriveNumber)
+{
+	PPVD Pvd = (PPVD)DISKREADBUFFER;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoOpenVolume() DriveNumber = 0x%x VolumeStartSector = 16\n", DriveNumber));
+
+	// Store the drive number
+	IsoDriveNumber = DriveNumber;
+
+	IsoRootSector = 0;
+	IsoRootLength = 0;
+
+	if (!MachDiskReadLogicalSectors(DriveNumber, 16, 1, Pvd))
+	{
+		FileSystemError("Failed to read the PVD.");
+		return FALSE;
+	}
+
+	IsoRootSector = Pvd->RootDirRecord.ExtentLocationL;
+	IsoRootLength = Pvd->RootDirRecord.DataLengthL;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoRootSector = %u  IsoRootLegth = %u\n", IsoRootSector, IsoRootLength));
+
+	return TRUE;
+}
+
+
+static BOOL IsoSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 DirectoryLength, PUCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
+{
+	PDIR_RECORD	Record;
+	U32		Offset;
+	U32 i;
+	UCHAR Name[32];
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x DirectoryLength = %d FileName = %s\n", DirectoryBuffer, DirectoryLength, FileName));
+
+	RtlZeroMemory(Name, 32 * sizeof(UCHAR));
+
+	Offset = 0;
+	Record = (PDIR_RECORD)DirectoryBuffer;
+	while (TRUE)
+	{
+		Offset = Offset + Record->RecordLength;
+		Record = (PDIR_RECORD)(DirectoryBuffer + Offset);
+
+		if (Record->RecordLength == 0)
+		{
+			Offset = ROUND_UP(Offset, SECTORSIZE);
+			Record = (PDIR_RECORD)(DirectoryBuffer + Offset);
+		}
+
+		if (Offset >= DirectoryLength)
+			return FALSE;
+
+		if (Record->FileIdLength == 1 && Record->FileId[0] == 0)
+		{
+			DbgPrint((DPRINT_FILESYSTEM, "Name '.'\n"));
+		}
+		else if (Record->FileIdLength == 1 && Record->FileId[0] == 1)
+		{
+			DbgPrint((DPRINT_FILESYSTEM, "Name '..'\n"));
+		}
+		else
+		{
+			for (i = 0; i < Record->FileIdLength && Record->FileId[i] != ';'; i++)
+				Name[i] = Record->FileId[i];
+			Name[i] = 0;
+			DbgPrint((DPRINT_FILESYSTEM, "Name '%s'\n", Name));
+
+			if (strlen(FileName) == strlen(Name) && stricmp(FileName, Name) == 0)
+			{
+				IsoFileInfoPointer->FileStart = Record->ExtentLocationL;
+				IsoFileInfoPointer->FileSize = Record->DataLengthL;
+				IsoFileInfoPointer->FilePointer = 0;
+				IsoFileInfoPointer->Directory = (Record->FileFlags & 0x02)?TRUE:FALSE;
+
+				return TRUE;
+			}
+
+		}
+
+		RtlZeroMemory(Name, 32 * sizeof(UCHAR));
+	}
+
+	return FALSE;
+}
+
+
+/*
+ * IsoBufferDirectory()
+ * This function allocates a buffer, reads the specified directory
+ * and returns a pointer to that buffer. The function returns NULL
+ * if allocation or read fails. The directory is specified by its
+ * starting sector and length.
+ */
+static PVOID IsoBufferDirectory(U32 DirectoryStartSector, U32 DirectoryLength)
+{
+	PVOID	DirectoryBuffer;
+	PVOID	Ptr;
+	U32	SectorCount;
+	U32	i;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoBufferDirectory() DirectoryStartSector = %d DirectoryLength = %d\n", DirectoryStartSector, DirectoryLength));
+
+	SectorCount = ROUND_UP(DirectoryLength, SECTORSIZE) / SECTORSIZE;
+	DbgPrint((DPRINT_FILESYSTEM, "Trying to read (DirectoryCount) %d sectors.\n", SectorCount));
+
+	//
+	// Attempt to allocate memory for directory buffer
+	//
+	DbgPrint((DPRINT_FILESYSTEM, "Trying to allocate (DirectoryLength) %d bytes.\n", DirectoryLength));
+	DirectoryBuffer = MmAllocateMemory(DirectoryLength);
+
+	if (DirectoryBuffer == NULL)
+	{
+		return NULL;
+	}
+
+	//
+	// Now read directory contents into DirectoryBuffer
+	//
+	for (i = 0, Ptr = DirectoryBuffer; i < SectorCount; i++, Ptr += SECTORSIZE)
+	{
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, DirectoryStartSector + i, 1, (PVOID)DISKREADBUFFER))
+		{
+			MmFreeMemory(DirectoryBuffer);
+			return NULL;
+		}
+		RtlCopyMemory(Ptr, (PVOID)DISKREADBUFFER, SECTORSIZE);
+	}
+
+	return DirectoryBuffer;
+}
+
+
+/*
+ * IsoLookupFile()
+ * This function searches the file system for the
+ * specified filename and fills in an ISO_FILE_INFO structure
+ * with info describing the file, etc. returns true
+ * if the file exists or false otherwise
+ */
+static BOOL IsoLookupFile(PUCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
+{
+	int		i;
+	U32			NumberOfPathParts;
+	UCHAR		PathPart[261];
+	PVOID		DirectoryBuffer;
+	U32		DirectorySector;
+	U32		DirectoryLength;
+	ISO_FILE_INFO	IsoFileInfo;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoLookupFile() FileName = %s\n", FileName));
+
+	RtlZeroMemory(IsoFileInfoPointer, sizeof(ISO_FILE_INFO));
+
+	//
+	// Figure out how many sub-directories we are nested in
+	//
+	NumberOfPathParts = FsGetNumPathParts(FileName);
+
+	DirectorySector = IsoRootSector;
+	DirectoryLength = IsoRootLength;
+
+	//
+	// Loop once for each part
+	//
+	for (i=0; i<NumberOfPathParts; i++)
+	{
+		//
+		// Get first path part
+		//
+		FsGetFirstNameFromPath(PathPart, FileName);
+
+		//
+		// Advance to the next part of the path
+		//
+		for (; (*FileName != '\\') && (*FileName != '/') && (*FileName != '\0'); FileName++)
+		{
+		}
+		FileName++;
+
+		//
+		// Buffer the directory contents
+		//
+		DirectoryBuffer = IsoBufferDirectory(DirectorySector, DirectoryLength);
+		if (DirectoryBuffer == NULL)
+		{
+			return FALSE;
+		}
+
+		//
+		// Search for file name in directory
+		//
+		if (!IsoSearchDirectoryBufferForFile(DirectoryBuffer, DirectoryLength, PathPart, &IsoFileInfo))
+		{
+			MmFreeMemory(DirectoryBuffer);
+			return FALSE;
+		}
+
+		MmFreeMemory(DirectoryBuffer);
+
+		//
+		// If we have another sub-directory to go then
+		// grab the start sector and file size
+		//
+		if ((i+1) < NumberOfPathParts)
+		{
+			DirectorySector = IsoFileInfo.FileStart;
+			DirectoryLength = IsoFileInfo.FileSize;
+		}
+
+	}
+
+	RtlCopyMemory(IsoFileInfoPointer, &IsoFileInfo, sizeof(ISO_FILE_INFO));
+
+	return TRUE;
+}
+
+
+/*
+ * IsoOpenFile()
+ * Tries to open the file 'name' and returns true or false
+ * for success and failure respectively
+ */
+FILE* IsoOpenFile(PUCHAR FileName)
+{
+	ISO_FILE_INFO		TempFileInfo;
+	PISO_FILE_INFO		FileHandle;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoOpenFile() FileName = %s\n", FileName));
+
+	if (!IsoLookupFile(FileName, &TempFileInfo))
+	{
+		return NULL;
+	}
+
+	FileHandle = MmAllocateMemory(sizeof(ISO_FILE_INFO));
+
+	if (FileHandle == NULL)
+	{
+		return NULL;
+	}
+
+	RtlCopyMemory(FileHandle, &TempFileInfo, sizeof(ISO_FILE_INFO));
+
+	return (FILE*)FileHandle;
+}
+
+
+/*
+ * IsoReadFile()
+ * Reads BytesToRead from open file and
+ * returns the number of bytes read in BytesRead
+ */
+BOOL IsoReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer)
+{
+	PISO_FILE_INFO	IsoFileInfo = (PISO_FILE_INFO)FileHandle;
+	U32		SectorNumber;
+	U32		OffsetInSector;
+	U32		LengthInSector;
+	U32		NumberOfSectors;
+	U32		i;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoReadFile() BytesToRead = %d Buffer = 0x%x\n", BytesToRead, Buffer));
+
+	if (BytesRead != NULL)
+	{
+		*BytesRead = 0;
+	}
+
+	//
+	// If they are trying to read past the
+	// end of the file then return success
+	// with BytesRead == 0
+	//
+	if (IsoFileInfo->FilePointer >= IsoFileInfo->FileSize)
+	{
+		return TRUE;
+	}
+
+	//
+	// If they are trying to read more than there is to read
+	// then adjust the amount to read
+	//
+	if ((IsoFileInfo->FilePointer + BytesToRead) > IsoFileInfo->FileSize)
+	{
+		BytesToRead = (IsoFileInfo->FileSize - IsoFileInfo->FilePointer);
+	}
+
+	//
+	// Ok, now we have to perform at most 3 calculations
+	// I'll draw you a picture (using nifty ASCII art):
+	//
+	// CurrentFilePointer -+
+	//                     |
+	//    +----------------+
+	//    |
+	// +-----------+-----------+-----------+-----------+
+	// | Sector  1 | Sector  2 | Sector  3 | Sector  4 |
+	// +-----------+-----------+-----------+-----------+
+	//    |                                    |
+	//    +---------------+--------------------+
+	//                    |
+	// BytesToRead -------+
+	//
+	// 1 - The first calculation (and read) will align
+	//     the file pointer with the next sector
+	//     boundary (if we are supposed to read that much)
+	// 2 - The next calculation (and read) will read
+	//     in all the full sectors that the requested
+	//     amount of data would cover (in this case
+	//     sectors 2 & 3).
+	// 3 - The last calculation (and read) would read
+	//     in the remainder of the data requested out of
+	//     the last sector.
+	//
+
+
+	//
+	// Only do the first read if we
+	// aren't aligned on a cluster boundary
+	//
+	if (IsoFileInfo->FilePointer % SECTORSIZE)
+	{
+		//
+		// Do the math for our first read
+		//
+		SectorNumber = IsoFileInfo->FileStart + (IsoFileInfo->FilePointer / SECTORSIZE);
+		OffsetInSector = IsoFileInfo->FilePointer % SECTORSIZE;
+		LengthInSector = (BytesToRead > (SECTORSIZE - OffsetInSector)) ? (SECTORSIZE - OffsetInSector) : BytesToRead;
+
+		//
+		// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
+		//
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+		{
+			return FALSE;
+		}
+		RtlCopyMemory(Buffer, ((PVOID)DISKREADBUFFER + OffsetInSector), LengthInSector);
+		if (BytesRead != NULL)
+		{
+			*BytesRead += LengthInSector;
+		}
+		BytesToRead -= LengthInSector;
+		IsoFileInfo->FilePointer += LengthInSector;
+		Buffer += LengthInSector;
+	}
+
+	//
+	// Do the math for our second read (if any data left)
+	//
+	if (BytesToRead > 0)
+	{
+		//
+		// Determine how many full clusters we need to read
+		//
+		NumberOfSectors = (BytesToRead / SECTORSIZE);
+
+		for (i = 0; i < NumberOfSectors; i++)
+		{
+			SectorNumber = IsoFileInfo->FileStart + (IsoFileInfo->FilePointer / SECTORSIZE);
+
+			//
+			// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
+			//
+			if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+			{
+				return FALSE;
+			}
+
+			RtlCopyMemory(Buffer, (PVOID)DISKREADBUFFER, SECTORSIZE);
+
+			if (BytesRead != NULL)
+			{
+				*BytesRead += SECTORSIZE;
+			}
+			BytesToRead -= SECTORSIZE;
+			IsoFileInfo->FilePointer += SECTORSIZE;
+			Buffer += SECTORSIZE;
+		}
+	}
+
+	//
+	// Do the math for our third read (if any data left)
+	//
+	if (BytesToRead > 0)
+	{
+		SectorNumber = IsoFileInfo->FileStart + (IsoFileInfo->FilePointer / SECTORSIZE);
+
+		//
+		// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
+		//
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+		{
+			return FALSE;
+		}
+		RtlCopyMemory(Buffer, (PVOID)DISKREADBUFFER, BytesToRead);
+		if (BytesRead != NULL)
+		{
+			*BytesRead += BytesToRead;
+		}
+		IsoFileInfo->FilePointer += BytesToRead;
+		BytesToRead -= BytesToRead;
+		Buffer += BytesToRead;
+	}
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoReadFile() done\n"));
+
+	return TRUE;
+}
+
+
+U32 IsoGetFileSize(FILE *FileHandle)
+{
+	PISO_FILE_INFO	IsoFileHandle = (PISO_FILE_INFO)FileHandle;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoGetFileSize() FileSize = %d\n", IsoFileHandle->FileSize));
+
+	return IsoFileHandle->FileSize;
+}
+
+VOID IsoSetFilePointer(FILE *FileHandle, U32 NewFilePointer)
+{
+	PISO_FILE_INFO	IsoFileHandle = (PISO_FILE_INFO)FileHandle;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoSetFilePointer() NewFilePointer = %d\n", NewFilePointer));
+
+	IsoFileHandle->FilePointer = NewFilePointer;
+}
+
+U32 IsoGetFilePointer(FILE *FileHandle)
+{
+	PISO_FILE_INFO	IsoFileHandle = (PISO_FILE_INFO)FileHandle;
+
+	DbgPrint((DPRINT_FILESYSTEM, "IsoGetFilePointer() FilePointer = %d\n", IsoFileHandle->FilePointer));
+
+	return IsoFileHandle->FilePointer;
+}

freeldr/freeldr/fs/iso.h

@@ -0,0 +1,115 @@
+/*
+ *  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.
+ */
+
+#ifndef __ISO_H
+#define __ISO_H
+
+
+struct _DIR_RECORD
+{
+  UCHAR  RecordLength;			// 1
+  UCHAR  ExtAttrRecordLength;		// 2
+  U32  ExtentLocationL;		// 3-6
+  U32  ExtentLocationM;		// 7-10
+  U32  DataLengthL;			// 11-14
+  U32  DataLengthM;			// 15-18
+  UCHAR  Year;				// 19
+  UCHAR  Month;				// 20
+  UCHAR  Day;				// 21
+  UCHAR  Hour;				// 22
+  UCHAR  Minute;			// 23
+  UCHAR  Second;			// 24
+  UCHAR  TimeZone;			// 25
+  UCHAR  FileFlags;			// 26
+  UCHAR  FileUnitSize;			// 27
+  UCHAR  InterleaveGapSize;		// 28
+  U32  VolumeSequenceNumber;		// 29-32
+  UCHAR  FileIdLength;			// 33
+  UCHAR  FileId[1];			// 34
+} __attribute__((packed));
+
+typedef struct _DIR_RECORD DIR_RECORD, *PDIR_RECORD;
+
+
+
+
+/* Volume Descriptor header*/
+struct _VD_HEADER
+{
+  UCHAR  VdType;			// 1
+  UCHAR  StandardId[5];			// 2-6
+  UCHAR  VdVersion;			// 7
+} __attribute__((packed));
+
+typedef struct _VD_HEADER VD_HEADER, *PVD_HEADER;
+
+
+
+/* Primary Volume Descriptor */
+struct _PVD
+{
+  UCHAR  VdType;			// 1
+  UCHAR  StandardId[5];			// 2-6
+  UCHAR  VdVersion;			// 7
+  UCHAR  unused0;			// 8
+  UCHAR  SystemId[32];			// 9-40
+  UCHAR  VolumeId[32];			// 41-72
+  UCHAR  unused1[8];			// 73-80
+  U32  VolumeSpaceSizeL;		// 81-84
+  U32  VolumeSpaceSizeM;		// 85-88
+  UCHAR  unused2[32];			// 89-120
+  U32  VolumeSetSize;			// 121-124
+  U32  VolumeSequenceNumber;		// 125-128
+  U32  LogicalBlockSize;		// 129-132
+  U32  PathTableSizeL;		// 133-136
+  U32  PathTableSizeM;		// 137-140
+  U32  LPathTablePos;			// 141-144
+  U32  LOptPathTablePos;		// 145-148
+  U32  MPathTablePos;			// 149-152
+  U32  MOptPathTablePos;		// 153-156
+  DIR_RECORD RootDirRecord;		// 157-190
+  UCHAR  VolumeSetIdentifier[128];	// 191-318
+  UCHAR  PublisherIdentifier[128];	// 319-446
+
+  /* more data ... */
+
+} __attribute__((packed));
+
+typedef struct _PVD PVD, *PPVD;
+
+
+
+typedef struct
+{
+	U32		FileStart;		// File start sector
+	U32		FileSize;		// File size
+	U32		FilePointer;		// File pointer
+	BOOL	Directory;
+	U32		DriveNumber;
+} ISO_FILE_INFO, * PISO_FILE_INFO;
+
+
+BOOL	IsoOpenVolume(U32 DriveNumber);
+FILE*	IsoOpenFile(PUCHAR FileName);
+BOOL	IsoReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer);
+U32		IsoGetFileSize(FILE *FileHandle);
+VOID	IsoSetFilePointer(FILE *FileHandle, U32 NewFilePointer);
+U32		IsoGetFilePointer(FILE *FileHandle);
+
+#endif // #defined __FAT_H

freeldr/freeldr/fs/ntfs.c

@@ -0,0 +1,739 @@
+/*
+ *  FreeLoader NTFS support
+ *  Copyright (C) 2004       Filip Navara  <xnavara@volny.cz>
+ *
+ *  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.
+ */
+
+/*
+ * Limitations:
+ * - No support for compressed files.
+ * - No attribute list support.
+ * - May crash on currupted filesystem.
+ */
+
+#include <freeldr.h>
+#include <fs.h>
+#include <disk.h>
+#include <rtl.h>
+#include <arch.h>
+#include <mm.h>
+#include <debug.h>
+#include <cache.h>
+#include <machine.h>
+
+#include "ntfs.h"
+
+PNTFS_BOOTSECTOR NtfsBootSector;
+U32 NtfsClusterSize;
+U32 NtfsMftRecordSize;
+U32 NtfsIndexRecordSize;
+U32 NtfsDriveNumber;
+U32 NtfsSectorOfClusterZero;
+PNTFS_MFT_RECORD NtfsMasterFileTable;
+NTFS_ATTR_CONTEXT NtfsMFTContext;
+
+PUCHAR NtfsDecodeRun(PUCHAR DataRun, S64 *DataRunOffset, U64 *DataRunLength)
+{
+    U8 DataRunOffsetSize;
+    U8 DataRunLengthSize;
+    S8 i;
+
+    DataRunOffsetSize = (*DataRun >> 4) & 0xF;
+    DataRunLengthSize = *DataRun & 0xF;
+    *DataRunOffset = 0;
+    *DataRunLength = 0;
+    DataRun++;
+    for (i = 0; i < DataRunLengthSize; i++)
+    {
+        *DataRunLength += *DataRun << (i << 3);
+        DataRun++;
+    }
+
+    /* NTFS 3+ sparse files */
+    if (DataRunOffsetSize == 0)
+    {
+        *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));
+
+    return DataRun;
+}
+
+/* FIXME: Add support for attribute lists! */
+BOOL NtfsFindAttribute(PNTFS_ATTR_CONTEXT Context, PNTFS_MFT_RECORD MftRecord, U32 Type, PWCHAR Name)
+{
+    PNTFS_ATTR_RECORD AttrRecord;
+    PNTFS_ATTR_RECORD AttrRecordEnd;
+    U32 NameLength;
+    PWCHAR AttrName;
+
+    AttrRecord = (PNTFS_ATTR_RECORD)((PCHAR)MftRecord + MftRecord->AttributesOffset);
+    AttrRecordEnd = (PNTFS_ATTR_RECORD)((PCHAR)MftRecord + NtfsMftRecordSize);
+    for (NameLength = 0; Name[NameLength] != 0; NameLength++)
+        ;
+
+    while (AttrRecord < AttrRecordEnd)
+    {
+        if (AttrRecord->Type == NTFS_ATTR_TYPE_END)
+            break;
+
+        if (AttrRecord->Type == Type)
+        {
+            if (AttrRecord->NameLength == NameLength)
+            {
+                AttrName = (PWCHAR)((PCHAR)AttrRecord + AttrRecord->NameOffset);
+                if (!RtlCompareMemory(AttrName, Name, NameLength << 1))
+                {                
+                    /* Found it, fill up the context and return. */
+                    Context->Record = AttrRecord;
+                    if (AttrRecord->IsNonResident)
+                    {
+                    	S64 DataRunOffset;
+                    	U64 DataRunLength;
+
+                        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. */
+                            Context->CacheRunStartLCN = 
+                            Context->CacheRunLastLCN = DataRunOffset;
+                        }
+                        else
+                        {
+                            /* Sparse run. */
+                            Context->CacheRunStartLCN = -1;
+                            Context->CacheRunLastLCN = 0;
+                        }
+                        Context->CacheRunCurrentOffset = 0;
+                    }
+                    return TRUE;
+                }
+            }
+        }
+
+        AttrRecord = (PNTFS_ATTR_RECORD)((PCHAR)AttrRecord + AttrRecord->Length);
+    }
+
+    return FALSE;
+}
+
+/* FIXME: Optimize for multisector reads. */
+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 (!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);
+        Buffer += ReadLength;
+        Length -= ReadLength;
+        Offset += ReadLength;
+    }
+
+    /* II. Read all complete 64-sector blocks. */
+    while (Length >= 64 * NtfsBootSector->BytesPerSector)
+    {
+        if (!MachDiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), 64, (PCHAR)DISKREADBUFFER))
+            return FALSE;
+        RtlCopyMemory(Buffer, (PCHAR)DISKREADBUFFER, 64 * NtfsBootSector->BytesPerSector);
+        Buffer += 64 * NtfsBootSector->BytesPerSector;
+        Length -= 64 * NtfsBootSector->BytesPerSector;
+        Offset += 64 * NtfsBootSector->BytesPerSector;
+    }
+
+    /* III. Read the rest of data */
+    if (Length)
+    {
+        ReadLength = ((Length + NtfsBootSector->BytesPerSector - 1) / NtfsBootSector->BytesPerSector);
+        if (!MachDiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), ReadLength, (PCHAR)DISKREADBUFFER))
+            return FALSE;
+        RtlCopyMemory(Buffer, (PCHAR)DISKREADBUFFER, Length);
+    }
+
+    return TRUE;
+}
+
+U64 NtfsReadAttribute(PNTFS_ATTR_CONTEXT Context, U64 Offset, PCHAR Buffer, U64 Length)
+{
+    U64 LastLCN;
+    PUCHAR DataRun;
+    S64 DataRunOffset;
+    U64 DataRunLength;
+    S64 DataRunStartLCN;
+    U64 CurrentOffset;
+    U64 ReadLength;
+    U64 AlreadyRead;
+    
+    if (!Context->Record->IsNonResident)
+    {
+        if (Offset > Context->Record->Resident.ValueLength)
+            return 0;
+        if (Offset + Length > Context->Record->Resident.ValueLength)
+            Length = Context->Record->Resident.ValueLength - Offset;
+        RtlCopyMemory(Buffer, (PCHAR)Context->Record + Context->Record->Resident.ValueOffset + Offset, Length);
+        return Length;
+    }
+
+    /*
+     * Non-resident attribute
+     */
+
+    /*
+     * I. Find the corresponding start data run.
+     */
+
+    if (Context->CacheRunOffset == Offset)
+    {
+        DataRun = Context->CacheRun;
+        LastLCN = Context->CacheRunLastLCN;
+        DataRunStartLCN = Context->CacheRunStartLCN;
+        DataRunLength = Context->CacheRunLength;
+        CurrentOffset = Context->CacheRunCurrentOffset;
+    }
+    else
+    {
+        LastLCN = 0;
+        DataRun = (PUCHAR)Context->Record + Context->Record->NonResident.MappingPairsOffset;
+        CurrentOffset = 0;
+
+        while (1)
+        {
+            DataRun = NtfsDecodeRun(DataRun, &DataRunOffset, &DataRunLength);
+            if (DataRunOffset != -1)
+            {
+                /* Normal data run. */
+                DataRunStartLCN = LastLCN + DataRunOffset;
+                LastLCN = DataRunStartLCN;
+            }
+            else
+            {
+                /* Sparse data run. */
+                DataRunStartLCN = -1;
+            }
+
+            if (Offset >= CurrentOffset &&
+                Offset < CurrentOffset + (DataRunLength * NtfsClusterSize))
+            {
+                break;
+            }
+
+            if (*DataRun == 0)
+            {
+                return 0;
+            }
+
+            CurrentOffset += DataRunLength * NtfsClusterSize;
+        }
+    }
+
+    /*
+     * II. Go through the run list and read the data
+     */
+
+    AlreadyRead = 0;
+    while (Length > 0)
+    {
+        ReadLength = min(DataRunLength * NtfsClusterSize, Length);
+        if (DataRunStartLCN == -1)
+            RtlZeroMemory(Buffer, ReadLength);
+	else if (!NtfsDiskRead(DataRunStartLCN * NtfsClusterSize + Offset - CurrentOffset, ReadLength, Buffer))
+	    break;
+	Length -= ReadLength;
+	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.
+         */
+	
+	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)
+{
+    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
+VOID NtfsPrintFile(PNTFS_INDEX_ENTRY IndexEntry)
+{
+    PWCHAR FileName;
+    U8 FileNameLength;
+    CHAR AnsiFileName[256];
+    U8 i;
+
+    FileName = IndexEntry->FileName.FileName;
+    FileNameLength = IndexEntry->FileName.FileNameLength;
+
+    for (i = 0; i < FileNameLength; i++)
+        AnsiFileName[i] = FileName[i];
+    AnsiFileName[i] = 0;
+
+    DbgPrint((DPRINT_FILESYSTEM, "- %s (%x)\n", AnsiFileName, IndexEntry->Data.Directory.IndexedFile));
+}
+#endif
+
+BOOL NtfsCompareFileName(PCHAR FileName, PNTFS_INDEX_ENTRY IndexEntry)
+{
+    PWCHAR EntryFileName;
+    U8 EntryFileNameLength;
+    U8 i;
+
+    EntryFileName = IndexEntry->FileName.FileName;
+    EntryFileNameLength = IndexEntry->FileName.FileNameLength;
+
+#ifdef DEBUG
+    NtfsPrintFile(IndexEntry);
+#endif
+
+    if (strlen(FileName) != EntryFileNameLength)
+        return FALSE;
+
+    /* Do case-sensitive compares for Posix file names. */
+    if (IndexEntry->FileName.FileNameType == NTFS_FILE_NAME_POSIX)
+    {
+        for (i = 0; i < EntryFileNameLength; i++)
+            if (EntryFileName[i] != FileName[i])
+                return FALSE;
+    }
+    else
+    {
+        for (i = 0; i < EntryFileNameLength; i++)
+            if (tolower(EntryFileName[i]) != tolower(FileName[i]))
+                return FALSE;
+    }
+
+    return TRUE;
+}
+
+BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
+{
+    PNTFS_MFT_RECORD MftRecord;
+    U32 Magic;
+    NTFS_ATTR_CONTEXT IndexRootCtx;
+    NTFS_ATTR_CONTEXT IndexBitmapCtx;
+    NTFS_ATTR_CONTEXT IndexAllocationCtx;
+    PNTFS_INDEX_ROOT IndexRoot;
+    U64 BitmapDataSize;
+    U64 IndexAllocationSize;
+    PCHAR BitmapData;
+    PCHAR IndexRecord;
+    PNTFS_INDEX_ENTRY IndexEntry, IndexEntryEnd;
+    U32 RecordOffset;
+    U32 IndexBlockSize;
+
+    MftRecord = MmAllocateMemory(NtfsMftRecordSize);
+    if (MftRecord == NULL)
+    {
+        return FALSE;
+    }
+
+    if (NtfsReadMftRecord(MFTIndex, MftRecord))
+    {
+        Magic = MftRecord->Magic;
+
+        if (!NtfsFindAttribute(&IndexRootCtx, MftRecord, NTFS_ATTR_TYPE_INDEX_ROOT, L"$I30"))
+        {
+            MmFreeMemory(MftRecord);
+            return FALSE;
+        }
+        
+        IndexRecord = MmAllocateMemory(NtfsIndexRecordSize);
+        if (IndexRecord == NULL)
+        {
+            MmFreeMemory(MftRecord);
+            return FALSE;
+        }
+
+        NtfsReadAttribute(&IndexRootCtx, 0, IndexRecord, NtfsIndexRecordSize);
+        IndexRoot = (PNTFS_INDEX_ROOT)IndexRecord;
+        IndexEntry = (PNTFS_INDEX_ENTRY)((PCHAR)&IndexRoot->IndexHeader + IndexRoot->IndexHeader.EntriesOffset);
+        /* Index root is always resident. */
+        IndexEntryEnd = (PNTFS_INDEX_ENTRY)(IndexRecord + IndexRootCtx.Record->Resident.ValueLength);
+
+        DbgPrint((DPRINT_FILESYSTEM, "NtfsIndexRecordSize: %x IndexBlockSize: %x\n", NtfsIndexRecordSize, IndexRoot->IndexBlockSize));
+
+        while (IndexEntry < IndexEntryEnd &&
+               !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END))
+        {
+            if (NtfsCompareFileName(FileName, IndexEntry))
+            {
+                *OutMFTIndex = IndexEntry->Data.Directory.IndexedFile;
+                MmFreeMemory(IndexRecord);
+                MmFreeMemory(MftRecord);
+                return TRUE;
+            }
+	    IndexEntry = (PNTFS_INDEX_ENTRY)((PCHAR)IndexEntry + IndexEntry->Length);
+        }
+
+        if (IndexRoot->IndexHeader.Flags & NTFS_LARGE_INDEX)
+        {
+            DbgPrint((DPRINT_FILESYSTEM, "Large Index!\n"));
+
+            IndexBlockSize = IndexRoot->IndexBlockSize;
+
+            if (!NtfsFindAttribute(&IndexBitmapCtx, MftRecord, NTFS_ATTR_TYPE_BITMAP, L"$I30"))
+            {
+                DbgPrint((DPRINT_FILESYSTEM, "Corrupted filesystem!\n"));
+                MmFreeMemory(MftRecord);
+                return FALSE;
+            }
+            if (IndexBitmapCtx.Record->IsNonResident)
+                BitmapDataSize = IndexBitmapCtx.Record->NonResident.DataSize;
+            else
+                BitmapDataSize = IndexBitmapCtx.Record->Resident.ValueLength;
+            DbgPrint((DPRINT_FILESYSTEM, "BitmapDataSize: %x\n", BitmapDataSize));
+            BitmapData = MmAllocateMemory(BitmapDataSize);
+            if (BitmapData == NULL)
+            {
+                MmFreeMemory(IndexRecord);
+                MmFreeMemory(MftRecord);
+                return FALSE;
+            }
+            NtfsReadAttribute(&IndexBitmapCtx, 0, BitmapData, BitmapDataSize);
+
+            if (!NtfsFindAttribute(&IndexAllocationCtx, MftRecord, NTFS_ATTR_TYPE_INDEX_ALLOCATION, L"$I30"))
+            {
+                DbgPrint((DPRINT_FILESYSTEM, "Corrupted filesystem!\n"));
+                MmFreeMemory(BitmapData);
+                MmFreeMemory(IndexRecord);
+                MmFreeMemory(MftRecord);
+                return FALSE;
+            }
+            if (IndexAllocationCtx.Record->IsNonResident)
+                IndexAllocationSize = IndexAllocationCtx.Record->NonResident.DataSize;
+            else
+                IndexAllocationSize = IndexAllocationCtx.Record->Resident.ValueLength;
+
+            RecordOffset = 0;
+
+            for (;;)
+            {
+                DbgPrint((DPRINT_FILESYSTEM, "RecordOffset: %x IndexAllocationSize: %x\n", RecordOffset, IndexAllocationSize));
+                for (; RecordOffset < IndexAllocationSize;)
+                {
+                    U8 Bit = 1 << ((RecordOffset / IndexBlockSize) & 7);
+                    U32 Byte = (RecordOffset / IndexBlockSize) >> 3;
+                    if ((BitmapData[Byte] & Bit))
+                        break;
+                    RecordOffset += IndexBlockSize;
+                }
+            
+                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 & NTFS_INDEX_ENTRY_END))
+                {        
+                    if (NtfsCompareFileName(FileName, IndexEntry))
+                    {
+                        DbgPrint((DPRINT_FILESYSTEM, "File found\n"));
+                        *OutMFTIndex = IndexEntry->Data.Directory.IndexedFile;
+                        MmFreeMemory(BitmapData);
+                        MmFreeMemory(IndexRecord);
+                        MmFreeMemory(MftRecord);
+                        return TRUE;
+                    }
+                    IndexEntry = (PNTFS_INDEX_ENTRY)((PCHAR)IndexEntry + IndexEntry->Length);
+                }
+
+                RecordOffset += IndexBlockSize;
+            }
+
+            MmFreeMemory(BitmapData);
+        }
+        
+        MmFreeMemory(IndexRecord);
+    }
+    else
+    {
+        DbgPrint((DPRINT_FILESYSTEM, "Can't read MFT record\n"));
+    }
+    MmFreeMemory(MftRecord);
+
+    return FALSE;
+}
+
+BOOL NtfsLookupFile(PUCHAR FileName, PNTFS_MFT_RECORD MftRecord, PNTFS_ATTR_CONTEXT DataContext)
+{
+    U32 NumberOfPathParts;
+    UCHAR PathPart[261];
+    U32 CurrentMFTIndex;
+    U8 i;
+
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsLookupFile() FileName = %s\n", FileName));
+
+    CurrentMFTIndex = NTFS_FILE_ROOT;
+    NumberOfPathParts = FsGetNumPathParts(FileName);
+    for (i = 0; i < NumberOfPathParts; i++)
+    {
+        FsGetFirstNameFromPath(PathPart, FileName);
+
+        for (; (*FileName != '\\') && (*FileName != '/') && (*FileName != '\0'); FileName++)
+            ;
+        FileName++;
+
+        DbgPrint((DPRINT_FILESYSTEM, "- Lookup: %s\n", PathPart));
+        if (!NtfsFindMftRecord(CurrentMFTIndex, PathPart, &CurrentMFTIndex))
+        {
+            DbgPrint((DPRINT_FILESYSTEM, "- Failed\n"));
+            return FALSE;
+        }
+        DbgPrint((DPRINT_FILESYSTEM, "- Lookup: %x\n", CurrentMFTIndex));
+    }
+
+    if (!NtfsReadMftRecord(CurrentMFTIndex, MftRecord))
+    {
+        DbgPrint((DPRINT_FILESYSTEM, "NtfsLookupFile: Can't read MFT record\n"));
+        return FALSE;
+    }
+
+    if (!NtfsFindAttribute(DataContext, MftRecord, NTFS_ATTR_TYPE_DATA, L""))
+    {
+        DbgPrint((DPRINT_FILESYSTEM, "NtfsLookupFile: Can't find data attribute\n"));
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+BOOL NtfsOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
+{
+    NtfsBootSector = (PNTFS_BOOTSECTOR)DISKREADBUFFER;
+
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsOpenVolume() DriveNumber = 0x%x VolumeStartSector = 0x%x\n", DriveNumber, VolumeStartSector));
+
+    if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, (PCHAR)DISKREADBUFFER))
+    {
+        FileSystemError("Failed to read the boot sector.");
+        return FALSE;
+    }
+
+    if (RtlCompareMemory(NtfsBootSector->SystemId, "NTFS", 4))
+    {
+        FileSystemError("Invalid NTFS signature.");
+        return FALSE;
+    }
+
+    NtfsBootSector = MmAllocateMemory(NtfsBootSector->BytesPerSector);
+    if (NtfsBootSector == NULL)
+    {
+        return FALSE;
+    }
+
+    RtlCopyMemory(NtfsBootSector, (PCHAR)DISKREADBUFFER, ((PNTFS_BOOTSECTOR)DISKREADBUFFER)->BytesPerSector);
+
+    NtfsClusterSize = NtfsBootSector->SectorsPerCluster * NtfsBootSector->BytesPerSector;
+    if (NtfsBootSector->ClustersPerMftRecord > 0)
+        NtfsMftRecordSize = NtfsBootSector->ClustersPerMftRecord * NtfsClusterSize;
+    else
+        NtfsMftRecordSize = 1 << (-NtfsBootSector->ClustersPerMftRecord);
+    if (NtfsBootSector->ClustersPerIndexRecord > 0)
+        NtfsIndexRecordSize = NtfsBootSector->ClustersPerIndexRecord * NtfsClusterSize;
+    else
+        NtfsIndexRecordSize = 1 << (-NtfsBootSector->ClustersPerIndexRecord);
+
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsClusterSize: 0x%x\n", NtfsClusterSize));
+    DbgPrint((DPRINT_FILESYSTEM, "ClustersPerMftRecord: %d\n", NtfsBootSector->ClustersPerMftRecord));
+    DbgPrint((DPRINT_FILESYSTEM, "ClustersPerIndexRecord: %d\n", NtfsBootSector->ClustersPerIndexRecord));
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsMftRecordSize: 0x%x\n", NtfsMftRecordSize));
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsIndexRecordSize: 0x%x\n", NtfsIndexRecordSize));
+
+    NtfsDriveNumber = DriveNumber;
+    NtfsSectorOfClusterZero = VolumeStartSector;
+
+    DbgPrint((DPRINT_FILESYSTEM, "Reading MFT index...\n"));
+    if (!MachDiskReadLogicalSectors(DriveNumber,
+                                NtfsSectorOfClusterZero +
+                                (NtfsBootSector->MftLocation * NtfsBootSector->SectorsPerCluster),
+                                NtfsMftRecordSize / NtfsBootSector->BytesPerSector, (PCHAR)DISKREADBUFFER))
+    {
+        FileSystemError("Failed to read the Master File Table record.");
+        return FALSE;
+    }
+
+    NtfsMasterFileTable = MmAllocateMemory(NtfsMftRecordSize);
+    if (NtfsMasterFileTable == NULL)
+    {
+        MmFreeMemory(NtfsBootSector);
+        return FALSE;
+    }
+
+    RtlCopyMemory(NtfsMasterFileTable, (PCHAR)DISKREADBUFFER, NtfsMftRecordSize);
+
+    DbgPrint((DPRINT_FILESYSTEM, "Searching for DATA attribute...\n"));
+    if (!NtfsFindAttribute(&NtfsMFTContext, NtfsMasterFileTable, NTFS_ATTR_TYPE_DATA, L""))
+    {
+        FileSystemError("Can't find data attribute for Master File Table.");
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+FILE* NtfsOpenFile(PUCHAR FileName)
+{
+    PNTFS_FILE_HANDLE FileHandle;
+    PNTFS_MFT_RECORD MftRecord;
+
+    FileHandle = MmAllocateMemory(sizeof(NTFS_FILE_HANDLE) + NtfsMftRecordSize);
+    if (FileHandle == NULL)
+    {
+        return NULL;
+    }
+
+    MftRecord = (PNTFS_MFT_RECORD)(FileHandle + 1);
+    if (!NtfsLookupFile(FileName, MftRecord, &FileHandle->DataContext))
+    {
+        MmFreeMemory(FileHandle);
+        return NULL;
+    }
+
+    FileHandle->Offset = 0;
+
+    return (FILE*)FileHandle;
+}
+
+BOOL NtfsReadFile(FILE *File, U32 BytesToRead, U32* BytesRead, PVOID Buffer)
+{
+    PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
+    U64 BytesRead64;
+    BytesRead64 = NtfsReadAttribute(&FileHandle->DataContext, FileHandle->Offset, Buffer, BytesToRead);
+    if (BytesRead64)
+    {
+        *BytesRead = (U32)BytesRead64;
+        FileHandle->Offset += BytesRead64;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+U32 NtfsGetFileSize(FILE *File)
+{
+    PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
+    if (FileHandle->DataContext.Record->IsNonResident)
+        return (U32)FileHandle->DataContext.Record->NonResident.DataSize;
+    else
+        return (U32)FileHandle->DataContext.Record->Resident.ValueLength;
+}
+
+VOID NtfsSetFilePointer(FILE *File, U32 NewFilePointer)
+{
+    PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
+    FileHandle->Offset = NewFilePointer;
+}
+
+U32 NtfsGetFilePointer(FILE *File)
+{
+    PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
+    return FileHandle->Offset;
+}

freeldr/freeldr/fs/ntfs.h

@@ -0,0 +1,228 @@
+/*
+ *  FreeLoader NTFS support
+ *  Copyright (C) 2004       Filip Navara  <xnavara@volny.cz>
+ *
+ *  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 __NTFS_H
+#define __NTFS_H
+
+#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 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 NTFS_ATTR_NORMAL			0
+#define NTFS_ATTR_COMPRESSED			1
+#define NTFS_ATTR_RESIDENT			2
+#define NTFS_ATTR_ENCRYPTED			0x4000
+
+#define NTFS_SMALL_INDEX			0
+#define NTFS_LARGE_INDEX			1
+
+#define NTFS_INDEX_ENTRY_NODE			1
+#define NTFS_INDEX_ENTRY_END			2
+
+#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		Unused1[7];
+	U8		MediaDescriptor;		// Media descriptor byte
+	U8		Unused2[2];
+	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		CurrentHead;
+	U8		BootSignature;			// Extended boot signature (0x80)
+	U8		Unused4;
+	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
+	U8		BootCodeAndData[430];		// The remainder of the boot sector
+	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;
+	U16		USAOffset;					// Offset to the Update Sequence Array from the start of the ntfs record
+	U16		USACount;
+	U64		LogSequenceNumber;
+	U16		SequenceNumber;
+	U16		LinkCount;
+	U16		AttributesOffset;
+	U16		Flags;
+	U32		BytesInUse;					// Number of bytes used in this mft record.
+	U32		BytesAllocated;
+	U64		BaseMFTRecord;
+	U16		NextAttributeInstance;
+} PACKED NTFS_MFT_RECORD, *PNTFS_MFT_RECORD;
+
+typedef struct
+{
+	U32		Type;
+	U32		Length;
+	U8		IsNonResident;
+	U8		NameLength;
+	U16		NameOffset;
+	U16		Flags;
+	U16		Instance;
+	union
+	{
+		// Resident attributes
+		struct
+		{
+			U32		ValueLength;
+			U16		ValueOffset;
+			U16		Flags;
+		} PACKED Resident;
+		// Non-resident attributes
+		struct
+		{
+			U64		LowestVCN;
+			U64		HighestVCN;
+			U16		MappingPairsOffset;
+			U8		CompressionUnit;
+			U8		Reserved[5];
+			S64		AllocatedSize;
+			S64		DataSize;
+			S64		InitializedSize;
+			S64		CompressedSize;
+		} PACKED NonResident;
+	} PACKED;
+} PACKED NTFS_ATTR_RECORD, *PNTFS_ATTR_RECORD;
+
+typedef struct
+{
+	U32		EntriesOffset;
+	U32		IndexLength;
+	U32		AllocatedSize;
+	U8		Flags;
+	U8		Reserved[3];
+} PACKED NTFS_INDEX_HEADER, *PNTFS_INDEX_HEADER;
+
+typedef struct
+{
+	U32		Type;
+	U32		CollationRule;
+	U32		IndexBlockSize;
+	U8		ClustersPerIndexBlock;
+	U8		Reserved[3];
+	NTFS_INDEX_HEADER	IndexHeader;
+} PACKED NTFS_INDEX_ROOT, *PNTFS_INDEX_ROOT;
+
+typedef struct
+{
+	U64		ParentDirectory;
+	S64		CreationTime;
+	S64		LastDataChangeTime;
+	S64		LastMftChangeTime;
+	S64		LastAccessTime;
+	S64		AllocatedSize;
+	S64		DataSize;
+	U32		FileAttributes;
+	U16		PackedExtendedAttributeSize;
+	U16		Reserved;
+	U8		FileNameLength;
+	U8		FileNameType;
+	WCHAR		FileName[0];
+} PACKED NTFS_FILE_NAME_ATTR, *PNTFS_FILE_NAME_ATTR;
+
+typedef struct {
+	union
+	{
+		struct
+		{
+			U64	IndexedFile;
+		} PACKED Directory;
+		struct
+		{
+			U16	DataOffset;
+			U16	DataLength;
+			U32	Reserved;
+		} PACKED ViewIndex;
+	} PACKED Data;
+	U16			Length;
+	U16			KeyLength;
+	U16			Flags;
+	U16			Reserved;
+	NTFS_FILE_NAME_ATTR	FileName;
+} PACKED NTFS_INDEX_ENTRY, *PNTFS_INDEX_ENTRY;
+
+typedef struct
+{
+	PNTFS_ATTR_RECORD	Record;
+	PUCHAR			CacheRun;
+	U64			CacheRunOffset;
+	S64			CacheRunStartLCN;
+	U64			CacheRunLength;
+	S64			CacheRunLastLCN;
+	U64			CacheRunCurrentOffset;
+} NTFS_ATTR_CONTEXT, *PNTFS_ATTR_CONTEXT;
+
+typedef struct
+{
+	NTFS_ATTR_CONTEXT	DataContext;
+	U64			Offset;
+} PACKED NTFS_FILE_HANDLE, *PNTFS_FILE_HANDLE;
+
+BOOL	NtfsOpenVolume(U32 DriveNumber, U32 VolumeStartSector);
+FILE*	NtfsOpenFile(PUCHAR FileName);
+BOOL	NtfsReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer);
+U32	NtfsGetFileSize(FILE *FileHandle);
+VOID	NtfsSetFilePointer(FILE *FileHandle, U32 NewFilePointer);
+U32	NtfsGetFilePointer(FILE *FileHandle);
+
+#endif // #defined __NTFS_H

freeldr/freeldr/include/arch.h

@@ -0,0 +1,167 @@
+/*
+ *  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.
+ */
+
+
+#ifndef __ARCH_H
+#define __ARCH_H
+
+/* Defines needed for switching between real and protected mode */
+#define NULL_DESC	0x00	/* NULL descriptor */
+#define PMODE_CS	0x08	/* PMode code selector, base 0 limit 4g */
+#define PMODE_DS	0x10	/* PMode data selector, base 0 limit 4g */
+#define RMODE_CS	0x18	/* RMode code selector, base 0 limit 64k */
+#define RMODE_DS	0x20	/* RMode data selector, base 0 limit 64k */
+
+#define	KERNEL_BASE	0xC0000000
+#define	KERNEL_CS	0x08
+#define	KERNEL_DS	0x10
+
+#define CR0_PE_SET	0x00000001	/* OR this value with CR0 to enable pmode */
+#define CR0_PE_CLR	0xFFFFFFFE	/* AND this value with CR0 to disable pmode */
+
+#define STACK16ADDR	0x7000	/* The 16-bit stack top will be at 0000:7000 */
+#define STACK32ADDR	0x78000	/* The 32-bit stack top will be at 7000:8000, or 0x78000 */
+
+#define BIOSCALLBUFFER		0x78000	/* Buffer to store temporary data for any Int386() call */
+#define BIOSCALLBUFSEGMENT	0x7800	/* Buffer to store temporary data for any Int386() call */
+#define BIOSCALLBUFOFFSET	0x0000	/* Buffer to store temporary data for any Int386() call */
+#define FILESYSBUFFER		0x80000	/* Buffer to store file system data (e.g. cluster buffer for FAT) */
+#define DISKREADBUFFER		0x90000	/* Buffer to store data read in from the disk via the BIOS */
+
+/* Makes "x" a global variable or label */
+#define EXTERN(x)	.global x; x:
+
+
+
+
+#ifndef ASM
+
+
+typedef struct
+{
+	unsigned long	eax;
+	unsigned long	ebx;
+	unsigned long	ecx;
+	unsigned long	edx;
+
+	unsigned long	esi;
+	unsigned long	edi;
+
+	unsigned short	ds;
+	unsigned short	es;
+	unsigned short	fs;
+	unsigned short	gs;
+
+	unsigned long	eflags;
+
+} PACKED DWORDREGS;
+
+typedef struct
+{
+	unsigned short	ax, _upper_ax;
+	unsigned short	bx, _upper_bx;
+	unsigned short	cx, _upper_cx;
+	unsigned short	dx, _upper_dx;
+
+	unsigned short	si, _upper_si;
+	unsigned short	di, _upper_di;
+
+	unsigned short	ds;
+	unsigned short	es;
+	unsigned short	fs;
+	unsigned short	gs;
+
+	unsigned short	flags, _upper_flags;
+
+} PACKED WORDREGS;
+
+typedef struct
+{
+	unsigned char	al;
+	unsigned char	ah;
+	unsigned short	_upper_ax;
+	unsigned char	bl;
+	unsigned char	bh;
+	unsigned short	_upper_bx;
+	unsigned char	cl;
+	unsigned char	ch;
+	unsigned short	_upper_cx;
+	unsigned char	dl;
+	unsigned char	dh;
+	unsigned short	_upper_dx;
+
+	unsigned short	si, _upper_si;
+	unsigned short	di, _upper_di;
+
+	unsigned short	ds;
+	unsigned short	es;
+	unsigned short	fs;
+	unsigned short	gs;
+
+	unsigned short	flags, _upper_flags;
+
+} PACKED BYTEREGS;
+
+typedef union
+{
+	DWORDREGS	x;
+	DWORDREGS	d;
+	WORDREGS	w;
+	BYTEREGS	b;
+} REGS;
+
+// Int386()
+//
+// Real mode interrupt vector interface
+//
+// (E)FLAGS can *only* be returned by this function, not set.
+// Make sure all memory pointers are in SEG:OFFS format and
+// not linear addresses, unless the interrupt handler
+// specifically handles linear addresses.
+int		Int386(int ivec, REGS* in, REGS* out);
+
+// Flag Masks
+#define I386FLAG_CF		0x0001		// Carry Flag
+#define I386FLAG_RESV1	0x0002		// Reserved - Must be 1
+#define I386FLAG_PF		0x0004		// Parity Flag
+#define I386FLAG_RESV2	0x0008		// Reserved - Must be 0
+#define I386FLAG_AF		0x0010		// Auxiliary Flag
+#define I386FLAG_RESV3	0x0020		// Reserved - Must be 0
+#define I386FLAG_ZF		0x0040		// Zero Flag
+#define I386FLAG_SF		0x0080		// Sign Flag
+#define I386FLAG_TF		0x0100		// Trap Flag (Single Step)
+#define I386FLAG_IF		0x0200		// Interrupt Flag
+#define I386FLAG_DF		0x0400		// Direction Flag
+#define I386FLAG_OF		0x0800		// Overflow Flag
+
+// This macro tests the Carry Flag
+// If CF is set then the call failed (usually)
+#define INT386_SUCCESS(regs)	((regs.x.eflags & I386FLAG_CF) == 0)
+
+void	EnableA20(void);
+
+VOID	ChainLoadBiosBootSectorCode(VOID);	// Implemented in boot.S
+VOID	SoftReboot(VOID);					// Implemented in boot.S
+
+VOID	DetectHardware(VOID);		// Implemented in hardware.c
+
+#endif /* ! ASM */
+
+
+#endif // #defined __ARCH_H

freeldr/freeldr/include/bootmgr.h

@@ -0,0 +1,29 @@
+/*
+ *  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.
+ */
+
+#ifndef __BOOTMGR_H
+#define __BOOTMGR_H
+
+
+U32		GetDefaultOperatingSystem(PUCHAR OperatingSystemList[], U32 OperatingSystemCount);
+S32		GetTimeOut(VOID);
+BOOL	MainBootMenuKeyPressFilter(U32 KeyPress);
+
+
+#endif // #defined __BOOTMGR_H

freeldr/freeldr/include/cache.h

@@ -0,0 +1,30 @@
+/*
+ *  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.
+ */
+
+
+#ifndef __CACHE_H
+#define __CACHE_H
+
+BOOL	CacheInitializeDrive(U32 DriveNumber);
+VOID	CacheInvalidateCacheData(VOID);
+BOOL	CacheReadDiskSectors(U32 DiskNumber, U32 StartSector, U32 SectorCount, PVOID Buffer);
+BOOL	CacheForceDiskSectorsIntoCache(U32 DiskNumber, U32 StartSector, U32 SectorCount);
+BOOL	CacheReleaseMemory(U32 MinimumAmountToRelease);
+
+#endif // defined __CACHE_H

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/comm.h

@@ -0,0 +1,32 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 2001  Brian Palmer  <brianp@sginet.com>
+ *  Copyright (C) 2001  Eric Kohl
+ *  Copyright (C) 2001  Emanuele Aliberti
+ *
+ *  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 __RS232_H
+#define __RS232_H
+
+BOOL Rs232PortInitialize(U32 ComPort, U32 BaudRate);
+BOOL Rs232PortGetByte(PUCHAR ByteRecieved);
+BOOL Rs232PortPollByte(PUCHAR ByteRecieved);
+VOID Rs232PortPutByte(UCHAR ByteToSend);
+
+
+
+#endif // defined __RS232_H

freeldr/freeldr/include/debug.h

@@ -0,0 +1,88 @@
+/*
+ *  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.
+ */
+
+
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+#ifdef DEBUG
+
+	#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_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_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
+
+	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_)
+
+#ifdef __i386__
+
+	// Debugging support functions:
+	//
+	// BREAKPOINT() - Inserts an "int 3" instruction
+	// INSTRUCTION_BREAKPOINTX(x) - Enters exception handler right before instruction at address "x" is executed
+	// MEMORY_READWRITE_BREAKPOINTX(x) - Enters exception handler when a read or write occurs at address "x"
+	// MEMORY_WRITE_BREAKPOINTX(x) - Enters exception handler when a write occurs at address "x"
+	//
+	// You may have as many BREAKPOINT()'s as you like but you may only
+	// have up to four of any of the others.
+#define	BREAKPOINT()				__asm__ ("int $3");
+void	INSTRUCTION_BREAKPOINT1(unsigned long addr);
+void	MEMORY_READWRITE_BREAKPOINT1(unsigned long addr);
+void	MEMORY_WRITE_BREAKPOINT1(unsigned long addr);
+void	INSTRUCTION_BREAKPOINT2(unsigned long addr);
+void	MEMORY_READWRITE_BREAKPOINT2(unsigned long addr);
+void	MEMORY_WRITE_BREAKPOINT2(unsigned long addr);
+void	INSTRUCTION_BREAKPOINT3(unsigned long addr);
+void	MEMORY_READWRITE_BREAKPOINT3(unsigned long addr);
+void	MEMORY_WRITE_BREAKPOINT3(unsigned long addr);
+void	INSTRUCTION_BREAKPOINT4(unsigned long addr);
+void	MEMORY_READWRITE_BREAKPOINT4(unsigned long addr);
+void	MEMORY_WRITE_BREAKPOINT4(unsigned long addr);
+
+#endif // defined __i386__
+
+#else
+
+	#define DebugInit()
+	#define DbgPrint(_x_)
+	#define DPRINT1(_x_)
+	#define BugCheck(_x_)
+	#define DbgDumpBuffer(_x_, _y_, _z_)
+
+#endif // defined DEBUG
+
+#define UNIMPLEMENTED()   BugCheck((DPRINT_WARNING, "This function is unimplemented!\n"))
+
+#endif // defined __DEBUG_H

freeldr/freeldr/include/disk.h

@@ -0,0 +1,139 @@
+/*
+ *  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.
+ */
+
+#ifndef __DISK_H
+#define __DISK_H
+
+
+typedef struct _GEOMETRY
+{
+	U32		Cylinders;						// Number of cylinders on the disk
+	U32		Heads;							// Number of heads on the disk
+	U32		Sectors;						// Number of sectors per track
+	U32		BytesPerSector;					// Number of bytes per sector
+
+} GEOMETRY, *PGEOMETRY;
+
+//
+// Extended disk geometry (Int13 / ah=48h)
+//
+typedef struct _EXTENDED_GEOMETRY
+{
+	U16		Size;
+	U16		Flags;
+	U32		Cylinders;
+	U32		Heads;
+	U32		SectorsPerTrack;
+	U64		Sectors;
+	U16		BytesPerSector;
+	U32		PDPTE;
+} __attribute__((packed)) EXTENDED_GEOMETRY, *PEXTENDED_GEOMETRY;
+
+//
+// Define the structure of a partition table entry
+//
+typedef struct _PARTITION_TABLE_ENTRY
+{
+	U8		BootIndicator;					// 0x00 - non-bootable partition, 0x80 - bootable partition (one partition only)
+	U8		StartHead;						// Beginning head number
+	U8		StartSector;					// Beginning sector (2 high bits of cylinder #)
+	U8		StartCylinder;					// Beginning cylinder# (low order bits of cylinder #)
+	U8		SystemIndicator;				// System indicator
+	U8		EndHead;						// Ending head number
+	U8		EndSector;						// Ending sector (2 high bits of cylinder #)
+	U8		EndCylinder;					// Ending cylinder# (low order bits of cylinder #)
+	U32		SectorCountBeforePartition;		// Number of sectors preceding the partition
+	U32		PartitionSectorCount;			// Number of sectors in the partition
+
+} PACKED PARTITION_TABLE_ENTRY, *PPARTITION_TABLE_ENTRY;
+
+//
+// Define the structure of the master boot record
+//
+typedef struct _MASTER_BOOT_RECORD
+{
+	U8			MasterBootRecordCodeAndData[0x1b8];	/* 0x000 */
+	U32			Signature;				/* 0x1B8 */
+	U16			Reserved;				/* 0x1BC */
+	PARTITION_TABLE_ENTRY	PartitionTable[4];			/* 0x1BE */
+	U16			MasterBootRecordMagic;			/* 0x1FE */
+
+} PACKED MASTER_BOOT_RECORD, *PMASTER_BOOT_RECORD;
+
+//
+// Partition type defines
+//
+#define PARTITION_ENTRY_UNUSED          0x00      // Entry unused
+#define PARTITION_FAT_12                0x01      // 12-bit FAT entries
+#define PARTITION_XENIX_1               0x02      // Xenix
+#define PARTITION_XENIX_2               0x03      // Xenix
+#define PARTITION_FAT_16                0x04      // 16-bit FAT entries
+#define PARTITION_EXTENDED              0x05      // Extended partition entry
+#define PARTITION_HUGE                  0x06      // Huge partition MS-DOS V4
+#define PARTITION_IFS                   0x07      // IFS Partition
+#define PARTITION_OS2BOOTMGR            0x0A      // OS/2 Boot Manager/OPUS/Coherent swap
+#define PARTITION_FAT32                 0x0B      // FAT32
+#define PARTITION_FAT32_XINT13          0x0C      // FAT32 using extended int13 services
+#define PARTITION_XINT13                0x0E      // Win95 partition using extended int13 services
+#define PARTITION_XINT13_EXTENDED       0x0F      // Same as type 5 but uses extended int13 services
+#define PARTITION_NTFS                  0x17      // NTFS
+#define PARTITION_PREP                  0x41      // PowerPC Reference Platform (PReP) Boot Partition
+#define PARTITION_LDM                   0x42      // Logical Disk Manager partition
+#define PARTITION_UNIX                  0x63      // Unix
+#define PARTITION_LINUX_SWAP			0x82      // Linux Swap Partition
+#define PARTITION_EXT2					0x83      // Linux Ext2/Ext3
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// i386 BIOS Disk Functions (i386disk.c)
+//
+///////////////////////////////////////////////////////////////////////////////////////
+#ifdef __i386__
+
+BOOL	DiskResetController(U32 DriveNumber);
+BOOL	DiskInt13ExtensionsSupported(U32 DriveNumber);
+//VOID	DiskStopFloppyMotor(VOID);
+BOOL	DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSize);
+
+#endif // defined __i386__
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// FreeLoader Disk Functions
+//
+///////////////////////////////////////////////////////////////////////////////////////
+VOID	DiskReportError (BOOL bError);
+VOID	DiskError(PUCHAR ErrorString, U32 ErrorCode);
+PUCHAR	DiskGetErrorCodeString(U32 ErrorCode);
+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
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+// Fixed Disk Partition Management Functions
+//
+///////////////////////////////////////////////////////////////////////////////////////
+BOOL	DiskGetActivePartitionEntry(U32 DriveNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL	DiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL	DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL	DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL	DiskReadBootRecord(U32 DriveNumber, U64 LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord);
+
+#endif  // defined __DISK_H

freeldr/freeldr/include/drivemap.h

@@ -0,0 +1,43 @@
+/*
+ *  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.
+ */
+
+#ifndef __DRIVEMAP_H
+#define __DRIVEMAP_H
+
+
+typedef struct
+{
+	U8		DriveMapCount;		// Count of drives currently mapped
+
+	U8		DriveMap[8];		// Map of BIOS drives
+
+} PACKED DRIVE_MAP_LIST, *PDRIVE_MAP_LIST;
+
+VOID	DriveMapMapDrivesInSection(PUCHAR SectionName);
+BOOL	DriveMapIsValidDriveString(PUCHAR DriveString);			// Checks the drive string ("hd0") for validity
+U32		DriveMapGetBiosDriveNumber(PUCHAR DeviceName);			// Returns a BIOS drive number for any given device name (e.g. 0x80 for 'hd0')
+VOID	DriveMapInstallInt13Handler(PDRIVE_MAP_LIST DriveMap);	// Installs the int 13h handler for the drive mapper
+VOID	DriveMapRemoveInt13Handler(VOID);						// Removes a previously installed int 13h drive map handler
+
+extern PVOID			DriveMapInt13HandlerStart;
+extern PVOID			DriveMapInt13HandlerEnd;
+extern U32				DriveMapOldInt13HandlerAddress;
+extern DRIVE_MAP_LIST	DriveMapInt13HandlerMapList;
+
+#endif // #defined __DRIVEMAP_H

freeldr/freeldr/include/freeldr.h

@@ -0,0 +1,81 @@
+/*
+ *  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.
+ */
+
+#ifndef __FREELDR_H
+#define __FREELDR_H
+
+#define	NULL	0
+#define	TRUE	1
+#define FALSE	0
+
+#define BOOL	int
+#define BOOLEAN	int
+typedef BOOLEAN *PBOOLEAN;
+
+#define CHAR	char
+#define PCHAR	char *
+#define UCHAR	unsigned char
+#define PUCHAR	unsigned char *
+#define WCHAR	unsigned short
+#define PWCHAR	unsigned short *
+
+#define VOID	void
+#define PVOID	VOID*
+
+#ifdef __i386__
+
+#define	size_t	unsigned int
+
+typedef unsigned char		U8;
+typedef char				S8;
+typedef unsigned short		U16;
+typedef short				S16;
+typedef unsigned long		U32;
+typedef long				S32;
+typedef unsigned long long	U64;
+typedef long long			S64;
+
+typedef U8					__u8;
+typedef S8					__s8;
+typedef U16					__u16;
+typedef S16					__s16;
+typedef U32					__u32;
+typedef S32					__s32;
+typedef U64					__u64;
+typedef S64					__s64;
+
+#endif // __i386__
+
+typedef U8 *PU8;
+typedef U16 *PU16;
+typedef U32 *PU32;
+
+#define ROUND_UP(N, S) ((N) + (S) - ((N) % (S)))
+#define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
+
+#define PACKED __attribute__((packed))
+
+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(char *CmdLine);
+VOID	RunLoader(VOID);
+
+#endif  // defined __FREELDR_H

freeldr/freeldr/include/fs.h

@@ -0,0 +1,47 @@
+/*
+ *  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.
+ */
+
+#ifndef __FS_H
+#define __FS_H
+
+
+#define	EOF				-1
+
+#define	FS_FAT			1
+#define	FS_NTFS			2
+#define	FS_EXT2			3
+#define FS_REISER		4
+#define FS_ISO9660		5
+
+#define FILE			VOID
+#define PFILE			FILE *
+
+VOID	FileSystemError(PUCHAR ErrorString);
+BOOL	FsOpenVolume(U32 DriveNumber, U32 PartitionNumber);
+PFILE	FsOpenFile(PUCHAR FileName);
+VOID	FsCloseFile(PFILE FileHandle);
+BOOL	FsReadFile(PFILE FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer);
+U32		FsGetFileSize(PFILE FileHandle);
+VOID	FsSetFilePointer(PFILE FileHandle, U32 NewFilePointer);
+U32		FsGetFilePointer(PFILE FileHandle);
+BOOL	FsIsEndOfFile(PFILE FileHandle);
+U32		FsGetNumPathParts(PUCHAR Path);
+VOID	FsGetFirstNameFromPath(PUCHAR Buffer, PUCHAR Path);
+
+#endif // #defined __FS_H

freeldr/freeldr/include/inffile.h

@@ -0,0 +1,130 @@
+/*
+ *  ReactOS kernel
+ *  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.
+ */
+/* $Id: inffile.h,v 1.1 2003/05/25 21:17:30 ekohl Exp $
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS text-mode setup
+ * FILE:            subsys/system/usetup/infcache.h
+ * PURPOSE:         INF file parser that caches contents of INF file in memory
+ * PROGRAMMER:      Royce Mitchell III
+ *                  Eric Kohl
+ */
+
+#ifndef __INFCACHE_H__
+#define __INFCACHE_H__
+
+
+#define STATUS_BAD_SECTION_NAME_LINE   (0xC0700001)
+#define STATUS_SECTION_NAME_TOO_LONG   (0xC0700002)
+#define STATUS_WRONG_INF_STYLE         (0xC0700003)
+#define STATUS_NOT_ENOUGH_MEMORY       (0xC0700004)
+
+#define MAX_INF_STRING_LENGTH  512
+
+typedef PU32 HINF, *PHINF;
+
+typedef struct _INFCONTEXT
+{
+  PVOID Inf;
+//  PVOID CurrentInf;
+  PVOID Section;
+  PVOID Line;
+} INFCONTEXT, *PINFCONTEXT;
+
+
+/* FUNCTIONS ****************************************************************/
+
+BOOLEAN
+InfOpenFile (PHINF InfHandle,
+	     PCHAR FileName,
+	     PU32 ErrorLine);
+
+VOID
+InfCloseFile (HINF InfHandle);
+
+
+BOOLEAN
+InfFindFirstLine (HINF InfHandle,
+		  PCHAR Section,
+		  PCHAR Key,
+		  PINFCONTEXT Context);
+
+BOOLEAN
+InfFindNextLine (PINFCONTEXT ContextIn,
+		 PINFCONTEXT ContextOut);
+
+BOOLEAN
+InfFindFirstMatchLine (PINFCONTEXT ContextIn,
+		       PCHAR Key,
+		       PINFCONTEXT ContextOut);
+
+BOOLEAN
+InfFindNextMatchLine (PINFCONTEXT ContextIn,
+		      PCHAR Key,
+		      PINFCONTEXT ContextOut);
+
+
+S32
+InfGetLineCount (HINF InfHandle,
+		 PCHAR Section);
+
+S32
+InfGetFieldCount (PINFCONTEXT Context);
+
+
+BOOLEAN
+InfGetBinaryField (PINFCONTEXT Context,
+		   U32 FieldIndex,
+		   PU8 ReturnBuffer,
+		   U32 ReturnBufferSize,
+		   PU32 RequiredSize);
+
+BOOLEAN
+InfGetIntField (PINFCONTEXT Context,
+		U32 FieldIndex,
+		S32 *IntegerValue);
+
+BOOLEAN
+InfGetMultiSzField (PINFCONTEXT Context,
+		    U32 FieldIndex,
+		    PCHAR ReturnBuffer,
+		    U32 ReturnBufferSize,
+		    PU32 RequiredSize);
+
+BOOLEAN
+InfGetStringField (PINFCONTEXT Context,
+		   U32 FieldIndex,
+		   PCHAR ReturnBuffer,
+		   U32 ReturnBufferSize,
+		   PU32 RequiredSize);
+
+
+
+BOOLEAN
+InfGetData (PINFCONTEXT Context,
+	    PCHAR *Key,
+	    PCHAR *Data);
+
+BOOLEAN
+InfGetDataField (PINFCONTEXT Context,
+		 U32 FieldIndex,
+		 PCHAR *Data);
+
+#endif /* __INFCACHE_H__ */
+
+/* EOF */

freeldr/freeldr/include/inifile.h

@@ -0,0 +1,35 @@
+/*
+ *  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.
+ */
+
+#ifndef __PARSEINI_H
+#define __PARSEINI_H
+
+BOOL	IniFileInitialize(VOID);
+
+BOOL	IniOpenSection(PUCHAR SectionName, U32* SectionId);
+U32		IniGetNumSectionItems(U32 SectionId);
+U32		IniGetSectionSettingNameSize(U32 SectionId, U32 SettingIndex);
+U32		IniGetSectionSettingValueSize(U32 SectionId, U32 SettingIndex);
+BOOL	IniReadSettingByNumber(U32 SectionId, U32 SettingNumber, PUCHAR SettingName, U32 NameSize, PUCHAR SettingValue, U32 ValueSize);
+BOOL	IniReadSettingByName(U32 SectionId, PUCHAR SettingName, PUCHAR Buffer, U32 BufferSize);
+BOOL	IniAddSection(PUCHAR SectionName, U32* SectionId);
+BOOL	IniAddSettingValueToSection(U32 SectionId, PUCHAR SettingName, PUCHAR SettingValue);
+
+
+#endif // defined __PARSEINI_H

freeldr/freeldr/include/keycodes.h

@@ -0,0 +1,46 @@
+/*
+ *  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.
+ */
+
+#ifndef __KEYCODES_H
+#define __KEYCODES_H
+
+
+// Key codes
+#define KEY_EXTENDED	0x00
+#define	KEY_ENTER		0x0D
+#define KEY_BACKSPACE	0x08
+#define KEY_SPACE		0x20
+#define KEY_UP			0x48
+#define KEY_DOWN		0x50
+#define KEY_LEFT		0x4B
+#define KEY_RIGHT		0x4D
+#define KEY_ESC			0x1B
+#define KEY_F1			0x3B
+#define KEY_F2			0x3C
+#define KEY_F3			0x3D
+#define KEY_F4			0x3E
+#define KEY_F5			0x3F
+#define KEY_F6			0x40
+#define KEY_F7			0x41
+#define KEY_F8			0x42
+#define KEY_F9			0x43
+#define KEY_F10			0x44
+
+
+#endif // #defined __KEYCODES_H

freeldr/freeldr/include/linux.h

@@ -0,0 +1,139 @@
+/*
+ *  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 <fs.h>
+
+#ifndef __LINUX_H
+#define __LINUX_H
+
+
+#define LINUX_LOADER_TYPE_LILO			0x01
+#define LINUX_LOADER_TYPE_LOADLIN		0x11
+#define LINUX_LOADER_TYPE_BOOTSECT		0x21
+#define LINUX_LOADER_TYPE_SYSLINUX		0x31
+#define	LINUX_LOADER_TYPE_ETHERBOOT		0x41
+#define LINUX_LOADER_TYPE_FREELOADER	0x81
+
+#define LINUX_COMMAND_LINE_MAGIC		0xA33F
+
+#define LINUX_SETUP_HEADER_ID			0x53726448			// 'HdrS'
+
+#define LINUX_BOOT_SECTOR_MAGIC			0xAA55
+
+#define LINUX_KERNEL_LOAD_ADDRESS		0x100000
+
+#define LINUX_FLAG_LOAD_HIGH			0x01
+#define LINUX_FLAG_CAN_USE_HEAP			0x80
+
+#define LINUX_MAX_INITRD_ADDRESS		0x38000000
+
+typedef struct
+{
+	U8		BootCode1[0x20];
+
+	U16		CommandLineMagic;
+	U16		CommandLineOffset;
+
+	U8		BootCode2[0x1CD];
+
+	U8		SetupSectors;
+	U16		RootFlags;
+	U16		SystemSize;
+	U16		SwapDevice;
+	U16		RamSize;
+	U16		VideoMode;
+	U16		RootDevice;
+	U16		BootFlag;			// 0xAA55
+
+} PACKED LINUX_BOOTSECTOR, *PLINUX_BOOTSECTOR;
+
+typedef struct
+{
+	U8		JumpInstruction[2];
+	U32		SetupHeaderSignature;	// Signature for SETUP-header
+	U16		Version;				// Version number of header format
+	U16		RealModeSwitch;			// Default switch
+	U16		SetupSeg;				// SETUPSEG
+	U16		StartSystemSeg;
+	U16		KernelVersion;			// Offset to kernel version string
+	U8		TypeOfLoader;			// Loader ID
+									// =0, old one (LILO, Loadlin,
+									//     Bootlin, SYSLX, bootsect...)
+									// else it is set by the loader:
+									// 0xTV: T=0 for LILO
+									//       T=1 for Loadlin
+									//       T=2 for bootsect-loader
+									//       T=3 for SYSLX
+									//       T=4 for ETHERBOOT
+									//       V = version
+
+	U8		LoadFlags;				// flags, unused bits must be zero (RFU)
+									// LOADED_HIGH = 1
+									// bit within loadflags,
+									// if set, then the kernel is loaded high
+									// CAN_USE_HEAP = 0x80
+									// if set, the loader also has set heap_end_ptr
+									// to tell how much space behind setup.S
+									// can be used for heap purposes.
+									// Only the loader knows what is free!
+
+	U16		SetupMoveSize;			// size to move, when we (setup) are not
+									// loaded at 0x90000. We will move ourselves
+									// to 0x90000 then just before jumping into
+									// the kernel. However, only the loader
+									// know how much of data behind us also needs
+									// to be loaded.
+
+	U32		Code32Start;			// here loaders can put a different
+									// start address for 32-bit code.
+									// 
+									//   0x1000 = default for zImage
+									// 
+									// 0x100000 = default for big kernel
+
+	U32		RamdiskAddress;			// address of loaded ramdisk image
+									// Here the loader (or kernel generator) puts
+									// the 32-bit address were it loaded the image.
+	U32		RamdiskSize;			// its size in bytes
+
+	U16		BootSectKludgeOffset;
+	U16		BootSectKludgeSegment;
+	U16		HeapEnd;				// space from here (exclusive) down to
+									// end of setup code can be used by setup
+									// for local heap purposes.
+	U16		Pad1;
+	U32		CommandLinePointer;		// 32-bit pointer to the kernel command line
+	U32		InitrdAddressMax;		// Highest legal initrd address
+
+
+} PACKED LINUX_SETUPSECTOR, *PLINUX_SETUPSECTOR;
+
+VOID	BootNewLinuxKernel(VOID);				// Implemented in linux.S
+VOID	BootOldLinuxKernel(U32 KernelSize);		// Implemented in linux.S
+
+VOID	LoadAndBootLinux(PUCHAR OperatingSystemName, PUCHAR Description);
+
+BOOL	LinuxParseIniSection(PUCHAR OperatingSystemName);
+BOOL	LinuxReadBootSector(PFILE LinuxKernelFile);
+BOOL	LinuxReadSetupSector(PFILE LinuxKernelFile);
+BOOL	LinuxReadKernel(PFILE LinuxKernelFile);
+BOOL	LinuxCheckKernelVersion(VOID);
+BOOL	LinuxReadInitrd(PFILE LinuxInitrdFile);
+
+#endif // defined __LINUX_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 */