57 files changed, 7971 insertions, 0 deletions
diff --git a/v4.0-ozzie/Multitasking DOS BETA - 286 Compatability.pdf b/v4.0-ozzie/Multitasking DOS BETA - 286 Compatability.pdf
new file mode 100644
index 0000000..e56cb3d
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - 286 Compatability.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Command Guide.pdf b/v4.0-ozzie/Multitasking DOS BETA - Command Guide.pdf
new file mode 100644
index 0000000..6df8d3d
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Command Guide.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Device Drivers.pdf b/v4.0-ozzie/Multitasking DOS BETA - Device Drivers.pdf
new file mode 100644
index 0000000..7054542
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Device Drivers.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Dynamic Linking.pdf b/v4.0-ozzie/Multitasking DOS BETA - Dynamic Linking.pdf
new file mode 100644
index 0000000..d40f2c5
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Dynamic Linking.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Intro.pdf b/v4.0-ozzie/Multitasking DOS BETA - Intro.pdf
new file mode 100644
index 0000000..abc1ee9
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Intro.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Memory Management.pdf b/v4.0-ozzie/Multitasking DOS BETA - Memory Management.pdf
new file mode 100644
index 0000000..c9f9a07
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Memory Management.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Overview.pdf b/v4.0-ozzie/Multitasking DOS BETA - Overview.pdf
new file mode 100644
index 0000000..ce6f077
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Overview.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Release Notes.pdf b/v4.0-ozzie/Multitasking DOS BETA - Release Notes.pdf
new file mode 100644
index 0000000..8a632f3
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Release Notes.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Session Manager.pdf b/v4.0-ozzie/Multitasking DOS BETA - Session Manager.pdf
new file mode 100644
index 0000000..5c02646
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Session Manager.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - System Calls.pdf b/v4.0-ozzie/Multitasking DOS BETA - System Calls.pdf
new file mode 100644
index 0000000..e09f284
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - System Calls.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Welcome Beta Site Letter.pdf b/v4.0-ozzie/Multitasking DOS BETA - Welcome Beta Site Letter.pdf
new file mode 100644
index 0000000..80cbbdb
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Welcome Beta Site Letter.pdf
Binary files differ
diff --git a/v4.0-ozzie/Multitasking DOS BETA - Welcome OEMs Letter.pdf b/v4.0-ozzie/Multitasking DOS BETA - Welcome OEMs Letter.pdf
new file mode 100644
index 0000000..a19def0
--- /dev/null
+++ b/v4.0-ozzie/Multitasking DOS BETA - Welcome OEMs Letter.pdf
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/AUTOEXEC.BAT b/v4.0-ozzie/bin/DISK1/AUTOEXEC.BAT
new file mode 100644
index 0000000..7842e98
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/AUTOEXEC.BAT
@@ -0,0 +1,5 @@
+date
+time
+prompt $p$g
+path a:\bin;a:\
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/BIN/ARENA.EXE b/v4.0-ozzie/bin/DISK1/BIN/ARENA.EXE
new file mode 100644
index 0000000..0bf52f1
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/ARENA.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/BBSET.EXE b/v4.0-ozzie/bin/DISK1/BIN/BBSET.EXE
new file mode 100644
index 0000000..1414161
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/BBSET.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/CHKDSK.EXE b/v4.0-ozzie/bin/DISK1/BIN/CHKDSK.EXE
new file mode 100644
index 0000000..3a6dded
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/CHKDSK.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/COUNTDOW.EXE b/v4.0-ozzie/bin/DISK1/BIN/COUNTDOW.EXE
new file mode 100644
index 0000000..148ce1c
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/COUNTDOW.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/DEMO1.BAT b/v4.0-ozzie/bin/DISK1/BIN/DEMO1.BAT
new file mode 100644
index 0000000..c4f8563
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/DEMO1.BAT
@@ -0,0 +1,3 @@
+cd bin
+pound 290 a:bbset.exe a:sm.exe
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/BIN/DEMO2.BAT b/v4.0-ozzie/bin/DISK1/BIN/DEMO2.BAT
new file mode 100644
index 0000000..49fe3d6
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/DEMO2.BAT
@@ -0,0 +1,4 @@
+c:
+cd \bin
+pound 800 bbset.exe sm.exe
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/BIN/DEMO3.BAT b/v4.0-ozzie/bin/DISK1/BIN/DEMO3.BAT
new file mode 100644
index 0000000..eb99c7b
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/DEMO3.BAT
@@ -0,0 +1,7 @@
+c:
+cd \bin
+cd a:\bin
+detach pound 800 bbset.exe sm.exe
+detach pound 290 a:bbset.exe a:sm.exe
+basica a:prime
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/BIN/DETACH.EXE b/v4.0-ozzie/bin/DISK1/BIN/DETACH.EXE
new file mode 100644
index 0000000..dc75d46
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/DETACH.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/HE_DAEM.EXE b/v4.0-ozzie/bin/DISK1/BIN/HE_DAEM.EXE
new file mode 100644
index 0000000..3cf823b
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/HE_DAEM.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/KILL.EXE b/v4.0-ozzie/bin/DISK1/BIN/KILL.EXE
new file mode 100644
index 0000000..ef240b6
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/KILL.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/POUND.EXE b/v4.0-ozzie/bin/DISK1/BIN/POUND.EXE
new file mode 100644
index 0000000..1ed27f1
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/POUND.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/PRIME.BAS b/v4.0-ozzie/bin/DISK1/BIN/PRIME.BAS
new file mode 100644
index 0000000..a088c0c
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/PRIME.BAS
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/SLEEP.EXE b/v4.0-ozzie/bin/DISK1/BIN/SLEEP.EXE
new file mode 100644
index 0000000..fdeaa14
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/SLEEP.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/SM.EXE b/v4.0-ozzie/bin/DISK1/BIN/SM.EXE
new file mode 100644
index 0000000..15da78c
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/SM.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/BIN/TEXT.EXE b/v4.0-ozzie/bin/DISK1/BIN/TEXT.EXE
new file mode 100644
index 0000000..edcc27f
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/BIN/TEXT.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/COMMAND.COM b/v4.0-ozzie/bin/DISK1/COMMAND.COM
new file mode 100644
index 0000000..3546cbd
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/COMMAND.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/COMMANDS.DOC b/v4.0-ozzie/bin/DISK1/COMMANDS.DOC
new file mode 100644
index 0000000..0fcfed7
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/COMMANDS.DOC
@@ -0,0 +1,199 @@
+                                Multi-Tasking MS-DOS
+                               Beta Test Release 1.00
+                                   Command Guide
+            ARENA.EXE - Prints out arena assignments
+                 arena
+                      The system's  memory arena  is printed  out.   The
+                      number listed  under the owner field is the PID of
+                      the process which owns the memory.
+            BBSET.EXE - Set and report on behavior bits
+                 bbset [-o] [ {+|-}bitname ... ] fname ...
+                      BBSET sets or clears behavior bits in an .EXE file
+                      header.   Multi-Tasking MS-DOS  uses the  behavior
+                      bits   to   determine   the   level   of   special
+                      compatibility   support    needed   to   run   the
+                      application.
+                      BBSET will  set  (if  +bitname)  or  clear  (if  -
+                      bitname)  the   named  behavior  bit(s)  from  the
+                      specified files.   If  the -o switch is specified,
+                      BBSET writes  a report  on the  current setting of
+                      all the  defined behavior  bits  to  stdout  after
+                      making the requested changes.
+                      For a  list of  behavior  bits  that  BBSET  knows
+                      about, type BBSET without any arguments.
+            COUNTDOW.EXE - Count down a CPU loop
+                 countdown number
+                      Its argument  is a  number; it  counts the  number
+                      down to 0, at about a 1hz rate.     It  prints out
+                      the countdown.   Another  CPU  loop  program  like
+                      TEXT, but  this  one  terminates  when  the  count
+                      reaches 0
+            DETACH.EXE - Detaches a child process
+                 detach command [argument ...]
+                      The command  given is run as a background process.
+                      Detach prints  out the  Command Subgroup ID (CSID)
+                      which may  be used  as  an  argument  to  KILL  to
+                      terminate the process.
+     Multi-Tasking MS-DOS Command Guide - Page: 2
+            HE_DAEM.EXE - Hard error catcher
+                 detach he_daem
+                      Intercepts hard  errors, reports them and requests
+                      user action.   This  should always  be run  in the
+                      background for now.  Put the above command line in
+                      your AUTOEXEC.BAT  file if you're not going to use
+                      the Session Manager (SM).
+            KILL.EXE - send a signal to a process
+                 kill [-nn] [sig=nn] [disp=mm] pid ...
+                      Sends signal  nn with  disposition mm to processes
+                      mentioned in pid.  Defaults to SIGTERM and process
+                      tree disposition.
+            POUND.EXE - Exercise disk I/O system
+                 pound [t]count filea fileb
+                      Pound reads  sequencially through filea and fileb,
+                      reading 512  bytes at  a time  alternating between
+                      the files  on each  read.  When the end of file is
+                      read the  following read  for that  file begins at
+                      the  beginning  of  the  file.    If  a  count  is
+                      specified without  the preceeding  "t" then  pound
+                      reads 512  bytes, count  number of times from each
+                      file  before  the  program  terminates.    If  "t"
+                      preceeds the  count value  then the files are read
+                      for count  number of  seconds before  the  program
+                      terminates.
+            SLEEP.EXE - Sleep for a while
+                 sleep sec[.millisec]
+                      Sleep will  execute a  sleep system  call for  the
+                      number  of  seconds  and  milliseconds  specified.
+                      This might  be useful  in batch files to pause for
+                      an interval  as opposed  to  waiting  for  a  user
+                      response.
+            SM.EXE - Session manager
+                 sm
+                      Manages multiple  processes running  on  different
+                      screens.   Uses initialization  file SM.INI.  This
+     Multi-Tasking MS-DOS Command Guide - Page: 3
+                      program includes  the hard error catcher, so don't
+                      run HE_DAEM  if you're going to use this.  See the
+                      file SM.DOC for more information.
+            TEXT.EXE - Loop and print text
+                 text argument
+                      CPU loops  and prints  its argument  every  2  CPU
+                      seconds or so
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/CONFIG.SYS b/v4.0-ozzie/bin/DISK1/CONFIG.SYS
new file mode 100644
index 0000000..3d6d514
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/CONFIG.SYS
@@ -0,0 +1,3 @@
+buffers = 40
+files = 20
+break=on
diff --git a/v4.0-ozzie/bin/DISK1/DOS33/FDISK.COM b/v4.0-ozzie/bin/DISK1/DOS33/FDISK.COM
new file mode 100644
index 0000000..b4e3af1
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/DOS33/FDISK.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/DOS33/FORMAT.COM b/v4.0-ozzie/bin/DISK1/DOS33/FORMAT.COM
new file mode 100644
index 0000000..306fc49
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/DOS33/FORMAT.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/DOS33/SYS.COM b/v4.0-ozzie/bin/DISK1/DOS33/SYS.COM
new file mode 100644
index 0000000..d26e982
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/DOS33/SYS.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/IBMBIO.COM b/v4.0-ozzie/bin/DISK1/IBMBIO.COM
new file mode 100644
index 0000000..280a2ef
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/IBMBIO.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/IBMDOS.COM b/v4.0-ozzie/bin/DISK1/IBMDOS.COM
new file mode 100644
index 0000000..a859665
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/IBMDOS.COM
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK1/README b/v4.0-ozzie/bin/DISK1/README
new file mode 100644
index 0000000..4163d4f
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/README
@@ -0,0 +1,67 @@
+                                Multi-Taking MS-DOS
+                               Beta Test Release 1.00
+                                   Release Notes
+                 Enclosed you  will find  Microsoft's first beta release
+            of Multi-tasking  MS-DOS.  This version is based upon MS-DOS
+            Version 2  sources, we  will be  reimplementing  the  multi-
+            tasking enhancements on top of Version 3 sources shortly.
+                 Although we  have distributed  a bootable  disk for the
+            IBM PC,  this package  can be adapted to any MS-DOS machine.
+            Those manufacturers  who are  designing IBM compatible ROMs,
+            would be  wise to keep multi-tasking in mind.  Specifically,
+            this IBM  PC implementation  has had  to hook out the entire
+            disk (both  floppy and  hard disk) ROM code because after he
+            IBM code  set's up  the DMA  transfer it simply loops in ROM
+            waiting for the interrupt to occur (routine WAIT_INT).
+            Problems you may wish to avoid within future ROMs are:
+                 1)   loading ES  with the  physical video  RAM location
+                      (label M3)
+                 2)   Looping in ROM on Cntrl-NumLock (label K40)
+                 3)   No  way  to  add  special  detecting  special  key
+                      strokes which  a jump  out into  RAM after reading
+                      the keystroke at KB_INT would avoid
+                 4)   Not being  able to hook the loading of DS to point
+                      to DATA (EQU 40H) in numerous routines.
+            Other than  these deficiencies the ROM code developed should
+            be very usable.
+                 By implementing the above suggestions, the size of your
+            BIOS can  be reduced  since it  will  not  be  necessary  to
+            duplicate functionality in RAM.
+                 More  detailed  specifications  of  the  device  driver
+            formats will  be forth  coming.  For the time being you will
+            have to  make use  of the sample source code for the IBM PC.
+            If you  have further  questions please contact Microsoft OEM
+            customer support through Technical Assist Requests (TAR).
+               * * *  WARNING  * * *  WARNING  * * *  WARNING  * * *
+                 Each copy  of this  software distribution has been
+                 individually serialized  to facilitate  tracing of
+                 unauthorized duplication.
+               * * *  WARNING  * * *  WARNING  * * *  WARNING  * * *
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/SM.DOC b/v4.0-ozzie/bin/DISK1/SM.DOC
new file mode 100644
index 0000000..ebbe220
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/SM.DOC
@@ -0,0 +1,199 @@
+                                Multi-Tasking MS-DOS
+                               Beta Test Release 1.00
+                                  Session Manager
+                                    User's Guide
+            Introduction
+                 The  Session  Manager(SM)    for  Multi-Tasking  MS-DOS
+            allows you  to run up to six programs at one time and switch
+            between them  with a  couple of  keystrokes.  Each program's
+            screen is  preserved so  that it  can be  restored when  you
+            switch back  to it.  SM also contains the system-wide, Int24
+            Handler.
+            Initialization
+                 The first  thing SM does when it is started is look for
+            any program  initialization information  you may  have.   SM
+            looks for  the initialization  information in  a file  named
+            SM.INI in  the current  directory.  Although recommended, no
+            initialization information is needed.
+            There are two types of initialization lines:
+                 1)   define <program key> <program name> [program args]
+                      <working directory>
+                 2)   start  <program key>
+                 "program key"  - a printable ascii character, a control
+                           character (^A thru ^^), or a function key (F1
+                           - F10).
+                 "working directory"  - a well formed path; i.e., begins
+                           with drive letter (d:\).
+                 Each define  line will  associate a key with a program.
+            If there  is more  than one  define line using the same key,
+            only the information in the last one is used.
+                 A start  line is  optional.  If one exists, the program
+            associated with  the key on the start line is run as soon as
+            SM finishes  initializing.   If more  than one start line is
+            given, the last one is used.
+            This is what a sample initialization file might look like:
+                      define f1 a:\command.com c:\bin\src
+                      define ^z z.exe foo.c a:\foo\bar
+                      start f1
+            Running the Session Manager
+                 To run  Session Manager,  just type  SM.   It does  not
+            require any  arguments.   If there  was a  start line in the
+     Session Manager User's Guide - Page: 2
+            initialization file,  the program  associated with the start
+            key will be run.  Otherwise, the SM screen will be displayed
+            and you will be prompted for input.
+                 The SM  screen contains  a chart  that  describes  each
+            defined  program's   key,  status,  arguments,  and  working
+            directory.  There are 3 types of program status:
+                      1)   New - the program has never been run.
+                      2)   Active - the program has been started.
+                      3)   Dead - the program has terminated.
+                 The input  choices at  this point  are to either type a
+            program key  or hit  the <ESC> button to enter command mode.
+            If you  hit a  program key,  the screen associated with that
+            program   will   be   displayed   and   the   program   will
+            start/continue executing.   If  this is  the first  time the
+            program has  been run,  a chdir  to  the  program's  working
+            directory is  made before it is started.  If SM cannot start
+            the program you desired, the SM screen will reappear.
+                 If the  program you  chose to  run has died, its screen
+            will still  be displayed  so that  you can check its output.
+            That is  all you  can do  while in  a dead  programs  screen
+            except switch back to SM.
+                 To  switch  back  to  SM,  hit  Alt-F10.    Alt-F10  is
+            currently the  program key  for SM and will be recognized no
+            matter what  other programs  are running.   This is the only
+            program key  that works  this way.   All  of the others will
+            only be  recognized if  SM is  running and  the SM screen is
+            being displayed.
+                 Whenever any  of SM's  children die,  their  status  is
+            changed to  dead.   You will  see the status change the next
+            time the  SM screen  is displayed.  If the program using the
+            current screen dies, you will go back into SM.
+            Command Mode
+            When you  enter SM's  command mode the prompt "SM command or
+            HELP>" is displayed.  The valid SM commands are:
+                 1)   INIT <program key>
+                      Initialize the program associated with key so that
+                      it can  be run  again.   The program's  status  is
+                      changed to  "New" and  its screen memory is freed.
+                      If the   program is active, it is killed before it
+                      is initialized.
+                 2)   DEFINE <program key> <program name> [program args]
+                      <working directory>
+                      Define and  run a  new program  using the supplied
+                      information.   If the  key was previously defined,
+                      redefine it.
+     Session Manager User's Guide - Page: 3
+                 3)   RUN <program key>
+                      Run the program associated with key.
+                 4)   RESTART <program key>
+                      Restart the  program associated  with key.    This
+                      like issuing an INIT and a RUN command.
+                 5)   KILL <program key>
+                      Kill the  program associated with key.  Its status
+                      is changed to dead.
+                 6) HELP
+                      Display a help screen.
+                 7)   EXIT
+                      Kill all of SM's children and exit SM.
+                 In all  of the  above commands,  "key" is the printable
+            ascii representation of a programs key.  If a command fails,
+            you will either be asked to enter a new command or placed in
+            SM's top level.
+            Session Manager's Int24 Handler
+                 Whenever an Int24 occurs, SM's Int24 handler is called.
+            No matter  what program  is using  the screen  and no matter
+            which program  caused the error, SM's Int24 screen is always
+            displayed.  This screen will contain information on the type
+            of Int24  that happened, and the name and pid of the program
+            that caused the error.  You will then be prompted for one of
+            the valid  actions for this type of error.  After the action
+            typed in  has been taken, you are returned to the screen you
+            were using before the Int24.
+\ No newline at end of file
diff --git a/v4.0-ozzie/bin/DISK1/SM.INI b/v4.0-ozzie/bin/DISK1/SM.INI
new file mode 100644
index 0000000..bf7dfc8
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK1/SM.INI
@@ -0,0 +1,2 @@
+define F7 a:\command.com a:\
+define F8 a:\command.com c:\
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/ANSI.INC b/v4.0-ozzie/bin/DISK2/BIOS/ANSI.INC
new file mode 100644
index 0000000..37e661b
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/ANSI.INC
@@ -0,0 +1,573 @@
+;       Termcap description of capabilities:
+;ibmans4:mtcon:IBM PC with V4.0 ANSI driver:\
+;       :al=\E[L:am:bs:ce=\E[K:cl=\E[2J\E[H:cm=\E[%;%H:co#80:\
+;       :dl=\E[M:do=\E[B:ho=\E[H:li#24:mi:nd=\E[C:\
+;       :ms:pt:se=\E[m:so=\E[1;36m:up=\E[A:\
+;       :kb=^h:ku=\E[A:kd=\E[B:kl=\E[D:kr=\E[C:kh=\E[H:kn#8:\
+;       :k1=\ES:k2=\ET:k3=\EU:k4=\EV:k5=\EW:\
+;       :k6=\EP:k7=\EQ:k8=\ER:
+CMDTABL DB      'A'
+        DW      CUU             ;CUrsor Up
+        DB      'B'
+        DW      CUD             ;CUrsor Down
+        DB      'C'
+        DW      CUF             ;CUrsor Forward
+        DB      'D'
+        DW      CUB             ;CUrsor Back
+        DB      'H'
+        DW      CUP             ;CUrsor Position
+        DB      'J'
+        DW      ED              ;Erase in Display
+        DB      'K'
+        DW      EL              ;Erase in Line
+        DB      'L'
+        DW      IL              ;Insert Line
+        DB      'M'
+        DW      xDL             ;Delete Line
+;;      DB      'R'
+;;      DW      CPR             ;Cursor Postion Report
+        DB      'f'
+        DW      HVP             ;Horizontal and Vertical Position
+        DB      'h'
+        DW      SM              ;Set Mode
+        DB      'l'
+        DW      RM              ;Reset Mode
+        DB      'm'
+        DW      SGR             ;Select Graphics Rendition
+;;      DB      'n'
+;;      DW      DSR             ;Device Status Report
+        DB      's'
+        DW      SCP             ;Save Cursor Position
+        DB      'u'
+        DW      RCP             ;Restore Cursor Position
+        DB      00
+;       Graphic Rendition modes:  parameter, mask, set
+GRMODE  DB      00,00000000B,00000111B  ; all off
+        DB      01,11111111B,00001000B  ; bold (increased intensity)
+        DB      04,11111000B,00000001B  ; underscore
+        DB      05,11111111B,10000000B  ; blink
+        DB      07,11111000B,01110000B  ; reverse video
+        DB      08,10001000B,00000000B  ; concealed
+        DB      30,11111000B,00000000B  ; foreground colors ...
+        DB      31,11111000B,00000100B
+        DB      32,11111000B,00000010B
+        DB      33,11111000B,00000110B
+        DB      34,11111000B,00000001B
+        DB      35,11111000B,00000101B
+        DB      36,11111000B,00000011B
+        DB      37,11111000B,00000111B
+        DB      40,10001111B,00000000B  ; background colors ...
+        DB      41,10001111B,01000000B
+        DB      42,10001111B,00100000B
+        DB      43,10001111B,01100000B
+        DB      44,10001111B,00010000B
+        DB      45,10001111B,01010000B
+        DB      46,10001111B,00110000B
+        DB      47,10001111B,01110000B
+        DB      0FFH
+; Set/Reset Modes:  indexed by (SelChar-'<'*8) + (PARAM0 AND 7)
+SRMODE  DW      0,0,0,0,0,0,0,0         ; SelChar '<'
+        DW      1,1,1,1,1,1,1,WRAP      ; SelChar '='   
+        DW      0,EnaL25,0,0,0,0,0,0    ; SelChar '>'
+        DW      0,0,0,0,0,0,0,WRAP      ; SelChar '?'   
+PAGE
+;       The following are duplicates of the same variables from the ROM
+;
+;* WARNING - the following two variables are accessed as a word
+MODE    DB      3
+MAXCOL  DB      79
+IF      LINE25          ; special treatment of line 25?
+maxrow  equ     24
+ELSE
+maxrow  equ     25
+ENDIF
+;* WARNING - the following two variables are accessed as a word
+COL     DB      0                       ; current column
+ROW     DB      0                       ; current row
+AnsiState       LABEL   BYTE    ; the following must be saved on a screen swap
+WRAP    DB      1               ; 0 = NO WRAP, 1 = WRAP
+EnaL25  DB      0               ; 0 = 25th line disabled, 1 = enabled
+STATE   DW      S1
+SAVCR   DW      0                       ; saved cursor position
+;* WARNING - the following two variables are accessed as a word
+SelChar DB      0                       ; <,=,> or ? private use indicators
+PRMCNT  LABEL   BYTE                    ; number of parameters for command
+PRMCNTW DW      0
+NUMPARAM equ    5                       ; max. number of parameters
+PARAM   DB      NUMPARAM DUP (?)        ; buffer for command parameters
+;* WARNING - the following two variables are accessed as a word
+attrw   LABEL   WORD
+ATTR    DB      00000111B       ;CHARACTER ATTRIBUTE
+BPAGE   DB      0               ;BASE PAGE
+AnsiSize        equ     ($-AnsiState)
+IF      (AnsiSize GT TermSize)
+        .RADIX 0                ; ERROR - Terminal state not big enough
+ENDIF
+;-------------------------------------------------------------
+;
+;       CHROUT - WRITE OUT CHAR IN AL USING CURRENT ATTRIBUTE
+;
+base       dw   0b800h
+screen_seg dw   00000h
+chrout: cmp     al,13           ; carriage return?
+        ja      outchr
+        jnz     trylf
+        mov     [col],0
+;;      jmp     short setit
+        jmp     setit
+trylf:  cmp     al,10           ; line feed?
+        jz      lf
+        cmp     al,7            ; bell?
+        jnz     trytab
+torom:
+        mov     bx,[attrw]
+        and     bl,7
+        mov     ah,14
+        int     10h
+ret5:   ret
+trytab:
+        cmp     al,9            ; tab?
+        jnz     tryback
+        mov     al,[col]
+        add     al,8
+        mov     ah,al
+        and     ah,7
+        sub     al,ah
+        cmp     al,[maxcol]
+        jb      tunder
+        mov     al,[maxcol]
+tunder:
+        mov     [col],al
+                jmp     short setit
+tryback:
+        cmp     al,8            ; backspace?
+        jnz     outchr
+        cmp     [col],0
+        jz      ret5
+        dec     [col]
+        jmp     short setit
+outchr:
+        mov     bx,[attrw]
+        mov     cx,1
+        mov     ah,9
+        int     10h
+        inc     [col]
+        mov     al,[col]
+        cmp     al,[maxcol]
+        jbe     setit
+        cmp     [wrap],1
+        jz      outchr1
+        dec     [col]
+        ret
+outchr1:
+        mov     [col],0
+lf:     cmp     [row],(maxrow-1)
+        ja      setit                           ; on line 25, don't move
+        jz      lf1                             ; on 24th line, scroll
+        inc     [row]
+        jmp     short setit
+lf1:    call    scroll
+setit:  mov     dx,word ptr col
+        mov     bh,[bpage]
+        mov     ah,2
+        int     10h
+        ret
+scroll: mov     al,mode
+        cmp     al,2
+        jz      myscroll
+        cmp     al,3
+        jz      myscroll
+IF      LINE25
+        xor     cx,cx                   ; from 0,0
+        mov     dh,(maxrow-1)           ; to maxrow-1,maxcol
+        mov     dl,maxcol
+        mov     bh,attr
+        mov     ax,0601h                ; scroll  up one line
+        int     10h
+        ret
+ELSE
+        mov     al,10
+        jmp     torom
+ENDIF
+myscroll:
+        mov     bh,[attr]
+        mov     bl,' '
+        mov     bp,80
+        mov     ax,[base]
+        add     ax,[screen_seg]
+        mov     es,ax
+        mov     ds,ax
+        xor     di,di
+        mov     si,160
+        mov     cx,(maxrow-1)*80
+        cld
+;       This code will never get executed since we get here when
+;  mode = 2 or 3 only.
+;;      cmp     cs:[base],0b800h
+;;      jz      colorcard
+;;    rep       movsw
+;;      mov     ax,bx
+;;      mov     cx,bp
+;;    rep       stosw
+;;      jmp     short sret
+;;colorcard:
+        mov     dx,3dah
+wait2:  in      al,dx
+        test    al,8
+        jz      wait2
+        mov     al,25h
+        mov     dx,3d8h
+        out     dx,al           ;turn off video
+    rep movsw
+        mov     ax,bx
+        mov     cx,bp
+        rep     stosw
+        mov     al,29h
+        mov     dx,3d8h
+        out     dx,al           ;turn on video
+sret:   push    cs
+        pop     ds
+        ret
+CharOut:        PUSH    AX              ; Main entry point
+        PUSH    BX
+        PUSH    CX
+        PUSH    DX
+        PUSH    SI
+        PUSH    DI
+        PUSH    ES
+        PUSH    BP
+        MOV     [base],0B800H
+        XCHG    AX,SI                   ; SAVE CHARACTER TO STUFF
+        MOV     AX,40H                  ; POINT TO ROS BIOS
+        MOV     DS,AX
+        MOV     AX,DS:[49H]             ; AL=MODE, AH=MAX COL
+        DEC     AH                      ; ANSI NEEDS 0-79 OR 0-39
+        MOV     WORD PTR CS:[MODE],AX   ; SAVE MODE AND MAX COL
+        CMP     AL,7
+        JNZ     NOT_BW
+        MOV     WORD PTR CS:[base],0B000H
+NOT_BW: MOV     AL,DS:[62H]             ; GET ACTIVE PAGE
+        MOV     CS:[BPAGE],AL
+        CBW
+        ADD     AX,AX
+        MOV     BX,AX
+        MOV     AX,DS:[BX+50H]          ; AL=COL, AH=ROW
+        MOV     WORD PTR CS:[COL],AX    ; SAVE ROW AND COLUMN
+        MOV     AX,DS:[4EH]             ; GET START OF SCREEN SEG
+        MOV     CL,4
+        SHR     AX,CL                   ; CONVERT TO A SEGMENT
+        PUSH    CS
+        POP     DS
+        MOV     [screen_seg],AX
+        XCHG    AX,SI                   ; GET BACK CHARACTER IN AL
+        CALL    VIDEO
+        POP     BP
+        POP     ES
+        POP     DI
+        POP     SI
+        POP     DX
+        POP     CX
+        POP     BX
+        POP     AX
+        RET
+;----------------------------------------------------------
+;
+;       OUTPUT SINGLE CHAR IN AL TO VIDEO DEVICE
+;
+VIDEO:  MOV     SI,OFFSET STATE
+        JMP     [SI]
+S2:     CMP     AL,'['
+        JZ      S22
+        JMP     S1
+S22:    MOV     WORD PTR [SI],OFFSET S30
+        XOR     BX,BX
+        MOV     WORD PTR SelChar,BX
+        MOV     WORD PTR PARAM,BX
+        JMP     SHORT S3B
+S30:    CMP     AL,'?'                  ; experimental use selector (SM/RM)?
+        JA      S7
+        mov     SelChar,al
+        MOV     WORD PTR [SI],OFFSET S3
+        cmp     al,'<'
+        jae     S3B
+S3:     CMP     AL,';'
+        JNZ     S3C
+S3A:    INC     PRMCNT
+S3B:    CALL    GETPTR
+        XOR     AX,AX
+        MOV     WORD PTR [BX],AX    ;DEFAULT VALUE IS ZERO
+        RET
+S3C:    CMP     AL,'0'
+        JB      S3D
+        CMP     AL,'9'
+        JA      S7
+        CALL    GETPTR
+        SUB     AL,'0'
+        XCHG    AL,BYTE PTR [BX]
+        MOV     AH,10
+        MUL     AH                      ;*10
+        ADD     BYTE PTR [BX],AL        ;MOVE IN DIGIT
+        RET
+S3D:
+;;      CMP     AL,'"'                  ;BEGIN QUOTED STRING
+;;      JZ      S3E
+;;      CMP     AL,"'"
+        JNZ     S7
+;;S3E:  MOV     WORD PTR [SI],OFFSET S4
+;;      MOV     [INQ],AL
+S3RET:  RET
+;
+;   ENTER QUOTED STRINGS
+;
+;;S4:   CMP     AL,[INQ]                ;CHECK FOR STRING TERMINATOR
+;;      JNZ     S4A
+;;      DEC     PRMCNT                  ;TERMINATE STRING
+;;      MOV     WORD PTR [SI],OFFSET S3
+;;      RET
+;;S4A:  CALL    GETPTR
+;;      MOV     BYTE PTR [BX],AL
+;;      MOV     WORD PTR [SI],OFFSET S4
+;;      JMP     S3A
+;
+;  LOOK FOR ANSI COMMAND SPECIFIED IN AL
+;
+S7:     MOV     BX,OFFSET CMDTABL-3
+;
+S7A:    ADD     BX,3
+        CMP     BYTE PTR [BX],0
+        JZ      S1B
+        CMP     BYTE PTR [BX],AL
+        JNZ     S7A
+;
+S7B:    MOV     AX,WORD PTR [BX+1]     ;AX = JUMP ADDRESS
+        MOV     BX,OFFSET PARAM
+        MOV     DL,BYTE PTR [BX]
+        XOR     DH,DH                  ;DX = FIRST PARAMETER
+        MOV     CX,DX
+        OR      CX,CX
+        JNZ     S7C
+        INC     CX                     ; if DX=0, CX=1 else CX = DX
+S7C:    JMP     AX                     ;AL = COMMAND
+S1:     CMP     AL,1Bh                 ;ESCAPE SEQUENCE?
+        JNZ     S1B
+        MOV     WORD PTR [SI],OFFSET S2
+        RET
+S1B:    CALL    CHROUT
+S1A:    MOV     WORD PTR [STATE],OFFSET S1
+        RET
+MOVCUR: CMP     BYTE PTR [BX],AH
+        JZ      SETCUR
+        ADD     BYTE PTR [BX],AL
+        LOOP    MOVCUR
+SETCUR: MOV     DX,WORD PTR COL
+        XOR     BX,BX
+        MOV     AH,2
+        int     10h                     ; call ROM
+        JMP     S1A
+HVP:
+CUP:
+IF      LINE25
+        CMP     CL,(maxrow+1)
+        jb      cup3                    ; new row is 24 or less
+        JA      SETCUR                  ; error - 26 or greater
+        cmp     EnaL25,0                ; else 25, is it allowed?
+        jz      SETCUR
+cup3:
+ELSE
+        CMP     CL,maxrow
+        JA      SETCUR
+ENDIF
+        MOV     AL,MAXCOL
+        MOV     CH,BYTE PTR [BX+1]
+        OR      CH,CH
+        JZ      CUP1
+        DEC     CH
+CUP1:   CMP     AL,CH
+        JA      CUP2
+        MOV     CH,AL
+CUP2:   XCHG    CL,CH
+        DEC     CH
+        MOV     WORD PTR COL,CX
+        JMP     SETCUR
+CUF:    MOV     AH,MAXCOL
+        MOV     AL,1
+CUF1:   MOV     BX,OFFSET COL
+        JMP     MOVCUR
+CUB:    MOV     AX,00FFH
+        JMP     CUF1
+CUU:    MOV     AX,00FFH
+CUU1:   MOV     BX,OFFSET ROW
+        JMP     MOVCUR
+CUD:    MOV     AX,(maxrow-1)*256+1
+IF      LINE25
+        cmp     ah,[row]                        ; at bottom of screen?
+        ja      SETCUR
+ENDIF
+        JMP     CUU1
+SCP:    MOV     AX,WORD PTR COL
+        MOV     SAVCR,AX
+        JMP     SETCUR
+RCP:    MOV     AX,SAVCR
+IF      LINE25
+        cmp     ch,maxrow
+        jb      rcp1
+        cmp     EnaL25,0
+        jz      rcp2
+ENDIF
+rcp1:   MOV     WORD PTR COL,AX
+rcp2:   JMP     SETCUR
+SGR:    XOR     CX,CX
+        XCHG    CL,PRMCNT
+        CALL    GETPTR
+        INC     CX
+SGR1:   MOV     AL,BYTE PTR [BX]
+        PUSH    BX
+        MOV     BX,OFFSET GRMODE
+SGR2:   MOV     AH,BYTE PTR [BX]
+        ADD     BX,3
+        CMP     AH,0FFH
+        JZ      SGR3
+        CMP     AH,AL
+        JNZ     SGR2
+        MOV     AX,WORD PTR [BX-2]
+        AND     ATTR,AL
+        OR      ATTR,AH
+SGR3:   POP     BX
+        INC     BX
+        LOOP    SGR1
+        JMP     SETCUR
+ED:
+IF      LINE25
+        cmp     row,maxrow              ; on 25th line?
+        je      EL                      ; yes, treat like Erase in Line
+ENDIF
+        xor     cx,cx
+        mov     dl,maxcol
+        mov     dh,(maxrow-1)
+        cmp     param,1                 ; which subcommand?
+        ja      el2                     ; all
+        jb      ed1
+        mov     dh,row                  ; to beginning
+        dec     dh
+        jle     EL
+        jmp     short ed2
+ed1:    mov     ch,row                  ; to end
+        inc     ch
+        cmp     ch,dh
+        jae     EL
+ed2:    mov     bh,attr
+        MOV     AX,0600H
+        int     10h                     ; call ROM
+EL:     MOV     CX,WORD PTR COL
+        MOV     dx,cx
+        mov     al,param
+        inc     al                      ; 0,1,2 => 1,2,3
+        test    al,1                    ; to end?
+        je      el1
+        mov     dl,maxcol
+el1:    test    al,2                    ; to beginning?
+        je      el2
+        mov     cl,0
+el2:    mov     bh,attr
+        mov     ax,0600H
+        int     10h
+S1A_j:  jmp     S1A
+IL:     mov     ah,7                    ; scroll down
+        jmp     short dl1
+xDL:    mov     ah,6                    ; scroll up
+dl1:    mov     al,cl                   ; number of lines
+        mov     ch,row
+        xor     cl,cl
+        mov     dh,(maxrow-1)
+        mov     dl,maxcol
+        mov     bh,attr
+        int     10h
+        jmp     S1A_j
+RM:     XOR     CL,CL
+        JMP     SHORT SM1
+SM:     MOV     CL,1
+SM1:    mov     bl,SelChar              ; get selection character
+        sub     bl,'<'                  ; adjust
+        jb      S1A_j                   ; less than '<'
+        cmp     bl,4
+        jae     S1A_j                   ; greater than '?'
+        xor     bh,bh
+        shl     bx,1
+        shl     bx,1
+        shl     bx,1
+        MOV     AL,DL
+        CMP     AL,7
+        JA      S1A_j
+        or      bl,al
+        shl     bx,1
+        mov     bx,SRMODE[bx]           ; get function indicator
+        cmp     bx,1                    ; no or special function?
+        jb      S1A_j
+        jz      SM2                     ; sets screen mode
+        MOV     [bx],CL
+        JMP     S1A_j
+SM2:    MOV     AH,0
+        int     10h                     ; call ROM
+        JMP     S1A_j
+;       GetPtr - get a pointer to the current parameter
+GETPTR: MOV     BX,PRMCNTW
+        CMP     BX,NUMPARAM
+        JB      GET1
+        DEC     PRMCNT
+        JMP     GETPTR
+GET1:   ADD     BX,OFFSET PARAM
+        RET
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/BIOSOBJ.MAK b/v4.0-ozzie/bin/DISK2/BIOS/BIOSOBJ.MAK
new file mode 100644
index 0000000..e69d153
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/BIOSOBJ.MAK
@@ -0,0 +1,20 @@
+ibmbio.obj:     ibmbio.asm defdbug.inc bugcode.inc
+        masm ibmbio;
+ibmmtcon.obj:   ibmmtcon.asm ansi.inc defdbug.inc
+        masm ibmmtcon;
+ibmdsk.obj:     ibmdsk.asm defdbug.inc
+        masm ibmdsk;
+sysini.obj:     sysini.asm dossym.inc devsym.inc syscalls.inc
+        masm sysini;
+sysimes.obj:    sysimes.asm
+        masm sysimes;
+ibmbio.exe:     ibmbio.obj ibmmtcon.obj ibmdsk.obj sysini.obj sysimes.obj
+        link ibmbio ibmmtcon ibmdsk sysini sysimes,ibmbio,ibmbio/map;
+ibmbio.com:     ibmbio.exe
+        exe2bin ibmbio ibmbio.com
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/BOOTPACH.EXE b/v4.0-ozzie/bin/DISK2/BIOS/BOOTPACH.EXE
new file mode 100644
index 0000000..378331e
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/BOOTPACH.EXE
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/BUGCODE.INC b/v4.0-ozzie/bin/DISK2/BIOS/BUGCODE.INC
new file mode 100644
index 0000000..4a87725
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/BUGCODE.INC
@@ -0,0 +1,553 @@
+;***    Bugcode.inc - Debug code for including into sysini.asm and ibmbio.asm
+;
+;       Can't link in via buglib due to memory and relocation games played
+;       by these modules.  Each gets a private, local-only copy of these
+;       modules.
+IFDEF   DEBUGFLG
+;**     DPRINTF _ Debug Printf
+;
+;       Dprintf is a kernel debug print formatting package.  It is intended
+;       to produce conviently formatted output.
+;
+;       Dprintf is called, indirectly, by a macro:
+;
+;       DEBUG   n,m,"string",<a1,...,an>
+;
+;       string = format string
+;       a1     = first argument
+;       an     = last argument
+;
+;       The format string is an ASCIZ string which can contain 2 types of
+;       specifications:  data-format specifications and literal characters.
+;       Data format specifications always begin with a '$' character; all
+;       characters not part of a data format specification are treated as
+;       literal characters.
+;
+;       Literal characters
+;           - any character not part of a format specification.  Special
+;             non-printing characters are:
+;               \n      - CRLF
+;               \t      - tab
+;               \b      - bell
+;               \\      - \
+;               \$      - $
+;
+;       Format Specifications
+;
+;       A format specification takes the form:
+;            $ [@] <char>
+;
+;       where <char> =
+;
+;           x       - print argument as a hex word
+;           d       - print argument as decimal word
+;           c       - print argument as ascii character
+;           b       - print argument as hex byte
+;               For each of the above formats, the supplied argument
+;               is a 16-bit word - the value to be printed.  The optional @
+;               (described below) allows a segmented address to be supplied,
+;               instead.
+;
+;           s[nn]   - print argument as asciz string; if optional decimal
+;                     argument follows the format character this specifys
+;                     a maximum string length.  Non printing characters are
+;                     printed in the form \nnn where "nnn" is the octal byte
+;                     value.
+;                     Note that this format character cannot be directly
+;                     followed by a digit unless that digit is to be taken
+;                     as the start of a length argument.
+;
+;           Bnn     - print argument as hex bytes.  The required following
+;                     decimal argument is the number of bytes to print.
+;
+;               Both of these formats take a long address as their argument.
+;               The '@' character is thus invalid for these formats.
+;
+;       WARNINGS
+;           As befitting a debug routine, DPRINTF does not have a whole lot
+;           of "failsafe" code in it.  Supplying screwed up formats can
+;           muck things up.  Specifically:
+;               The @ argument must NOT be specified with the 's' or 'B'
+;                    format
+;               A string/byte-length argument of 0 is taken as 65536
+;           The string "%% BAD FMT %%" appears in the output when
+;               1) an illegal format specifier is given, or
+;               2) the B format is given a 0 or missing length
+;
+;       ENTRY   (sp+n  ) = address of format string (offset from return cs value)
+;               (sp+n-2) = first argument word
+;               (sp+n-4) = second argument word
+;                   .
+;               (sp+4  ) = last argument word
+;               (sp+2  ) = seg of return address
+;               (sp    ) = offset of return address
+;               (bp) = offset of format string on the stack
+;       EXIT    none
+;       USES    flags
+        PUBLIC  DPRINTF
+DPRINTF PROC    near
+        push    ds
+        push    es
+        push    bp
+        push    di
+        push    si
+        push    dx
+        push    cx
+        push    bx
+        push    ax              ; save registers
+        cld
+        mov     si,[bp]         ; get address of format string
+        sub     bp,2
+        mov     bx,sp
+        mov     ds,ss:20[bx]    ; (ds:si) = address of format string
+        push    cs
+        pop     ds
+;       Scan format string for next character
+;
+;       (ds:si) = address of format string
+;       (ss:bp) = address of next argument
+dpf1:   lodsb                   ; (al) = format string byte
+        and     al,al
+        je      dpf3            ; all done
+        cmp     al,'$'
+        je      dpf4            ; is data escape
+        cmp     al,'\'
+        jnz     dpf2            ; got the character
+;       it's an "\" escape code - crack the argument character
+        lodsb
+        and     al,al
+        je      dpf3            ; all done, ignore hanging \
+        xchg    ah,al
+        mov     al,0Ch
+        cmp     ah,'n'
+        jne     dpf1$5          ; not \n
+        mov     al,0dH
+        call    putchar
+        mov     al,0aH
+        jmp     SHORT dpf2      ; print LF
+dpf1$5: cmp     ah,'t'
+        mov     al,9
+        je      dpf2            ; is \t
+        cmp     ah,'b'
+        mov     al,7
+        je      dpf2            ; is \b
+        xchg    ah,al
+dpf2:   call    putchar
+        jmp     dpf1
+;       have the end of the format string - exit
+dpf3:   pop     ax
+        pop     bx
+        pop     cx
+        pop     dx
+        pop     si
+        pop     di
+        pop     bp
+        pop     es
+        pop     ds
+        ret
+;*      Have a '$' character - is data format escape
+;
+;       Get address of data into es:di
+;
+;       (bp) = address of data value
+dpf4:   mov     di,bp
+        push    ss
+        pop     es              ; (es:di) = address of data value
+        sub     bp,2            ; point to next argument
+        lodsb                   ; (al) = format specifier
+        cmp     al,'@'
+        jne     dpf5            ; not an indirect flag
+        les     di,[bp]
+        sub     bp,2            ; have an extra 2 for @
+        lodsb
+dpf5:   cmp     al,'x'
+        jne     dpfd1           ; not 'x'
+;       is 'x' format - print hex word
+        mov     ax,es:[di]
+        call    THW             ; type hex word
+        jmp     dpf1
+dpfd1:  cmp     al,'d'
+        jnz     dpfc1           ; not 'd'
+;       is 'd' format - print decimal word
+        mov     ax,es:[di]
+        call    TDW             ; type decimal word
+        jmp     dpf1
+dpfc1:  cmp     al,'c'
+        jne     dpfb1
+;       is 'c' format - print character
+        mov     al,es:[di]
+        call    putchar
+        jmp     dpf1
+dpfb1:  cmp     al,'b'
+        jne     dpfs1
+;       is 'b' format - print hex byte
+        mov     al,es:[di]
+        call    THB             ; type hex byte
+        jmp     dpf1
+dpfs1:  cmp     al,'s'
+        jne     dpfbb1
+;       is 's' format - print ASCIZ string.  First, check for
+;               optional decimal limit
+        public  SSB
+SSB:    sub     cx,cx           ; set 65536 limit
+        les     di,[bp]         ; (es:DI) = fwa of string
+        sub     bp,2            ; argument to 's' was two words
+        mov     al,[si]
+        cmp     al,'0'
+        jb      dpfs2           ; not decimal
+        cmp     al,'9'
+        ja      dpfs2           ; not decimal
+        call    atod            ; (ax) = decimal value, (ds:si) updated
+        xchg    cx,ax
+;       print asciz string at es:di, max of (cx) characters
+;       (cx) = 0  means max of 65536
+;
+;       Other sections of code in dpf jump here to print strings
+dpfs2:  mov     al,es:[di]
+        inc     di
+        and     al,al
+        je      dpfs3
+        call    putchar
+        loop    dpfs2           ; continue if not at limit
+dpfs3:  jmp     dpf1
+dpfbb1: cmp     al,'B'
+        je      dpfbb2          ; is 'B' format
+;       error in format code - print message
+dpferr: push    cs
+        pop     es
+        mov     di,OFFSET dpfa  ; (es:di) = error message
+        sub     cx,cx
+        jmp     dpfs2
+dpfa:   DB      '%% BAD FMT %%',0
+;       have B format
+dpfbb2: call    atod            ; (ax) = length specifier
+        jc      dpferr          ; number not there - error
+        xchg    cx,ax
+        jcxz    dpferr          ; number is 0 - error
+        les     di,[bp]         ; (es:DI) = fwa of string
+        sub     bp,2            ; argument to 's' was two words
+dpfbb3: mov     al,es:[di]
+        call    THB             ; type hex byte
+        mov     al,' '
+        call    putchar         ; space em out
+        inc     di
+        loop    dpfbb3          ; do em all
+        jmp     dpf1
+DPRINTF ENDP
+;**     THB - Type Hex Byte
+;
+;       THB types a hex byte (via "putchar")
+;
+;       ENTRY   (AL) = byte
+;       EXIT    none
+;       USES    ax, flags
+THBA    DB      '0123456789abcdef'
+        PUBLIC  THB
+THB     PROC    near
+        push    ax
+        shr     al,1
+        shr     al,1
+        shr     al,1
+        shr     al,1
+        and     ax,0fH
+        xchg    bx,ax
+        mov     bl,CS:THBA[bx]
+        xchg    ax,bx
+        call    putchar             ; put first character
+        pop     ax
+        and     ax,0fH
+        xchg    bx,ax
+        mov     bl,CS:THBA[bx]
+        xchg    ax,bx
+        call    putchar
+        ret
+THB     ENDP
+;**     THW - Type Hex Word
+;
+;       THW types a word in hex (via "putchar")
+;
+;       ENTRY   (AX) = word
+;       EXIT    none
+;       USES    AX, flags
+        PUBLIC  THW
+THW     PROC    near
+        push    ax
+        xchg    ah,al
+        call    THB
+        pop     ax
+        call    THB
+        ret
+THW     ENDP
+;**     TDW - Type Decimal Word
+;
+;       TDW types (via "putchar") the unsigned decimal representation
+;       of a 16-bit unsigned integer.  Only significant digits are
+;       printed; if the number is 0 a "0" is printed.
+;
+;       ENTRY   (AX) = number
+;       EXIT    none
+;       USES    AX, flags
+        PUBLIC  TDW
+TDW     PROC    near
+        push    cx              ; preserve registers
+        push    dx
+        mov     cx,10
+        call    tdw$            ; recurse cracking digits
+        pop     dx
+        pop     cx
+        ret
+TDW     ENDP
+;*      tdw$ - crack number recursively
+;
+;       tdw$ cracks the least significant decimal digit.  If there
+;       are no higher-significant digits, print and return.
+;       else, recurse for higher digits
+;
+;       (AX) = value
+;       (CX) = 10
+tdw$    PROC    NEAR
+        sub     dx,dx
+        div     cx              ; (ax) = quotient, (dx) = remainder
+        and     ax,ax
+        jz      tdw$1           ; this is highest-order, do it
+        push    dx
+        call    tdw$
+        pop     dx
+tdw$1:  xchg    ax,dx
+        add     al,'0'
+        call    putchar
+        ret
+TDW$    ENDP
+;**     ATOD - Convert ASCII string to decimal number
+;
+;       ATOD is called to convert an ascii string of digits to a
+;       decimal number.  Digits are converted until we run out of them.
+;
+;       ENTRY   (DS:SI) = address of first digit
+;       EXIT    'C' clear if OK
+;                 (AX) = value
+;                 (SI) updated to first non-digit
+;               'C' set if error - no digits, or result >65535
+;                 (DS:SI) points to error character
+;       USES    AX, SI, FLAGS
+        PUBLIC  ATOD
+ATOD    PROC    near
+        push    dx
+        push    cx                  ; save registers
+        mov     al,[si]
+        sub     al,'0'
+        jc      atod9               ; error - no digits
+        cmp     al,10
+        cmc
+        jc      atod9               ; error - no digits
+        sub     ax,ax               ; clear accumulator
+        mov     cx,10               ; base 10
+;       crack next digit
+;
+;       (AX) = number accumulated so near
+;       (CX) = 10
+;       (DS:SI) = next character
+atod1:  xchg    dx,ax           ; keep accum in dx for a while
+        lodsb                   ; (al) = character
+        sub     al,'0'
+        jc      atod7           ; not digit - all done
+        cmp     al,9
+        ja      atod7           ; not digit - all done
+        sub     ah,ah           ; (ax) = digit value (0 - 9)
+        push    ax
+        xchg    ax,dx
+        mul     cx              ; (ax) = 10*accum
+        pop     dx              ; (dx) = digit to add
+        jo      atod8           ; overflow
+        add     ax,dx
+        jmp     atod1           ; go back for more
+;       Done with number, all OK
+;
+;       (dx) = number
+;       (ds:si) = address+1 of first unused character
+atod7:  clc
+;       Done with number, error
+;       'C' set
+atod8:  dec     si              ; backup over non-decimal (or error) char
+atod9:  pop     cx
+        xchg    ax,dx           ; (ax) = number iff no error
+        pop     dx              ; restore registers
+        ret                     ; exit
+ATOD    ENDP
+;**     putchar - put a character on the console
+;
+;       ENTRY   (al) = character
+;       EXIT    none
+;       USES    ax,flags
+UR_DAT  =       02f8H           ; COM1 = 03f8H, COM2 = 02f8H
+UR_IEN  =       UR_DAT+1        ; Interrupt enable
+UR_IER  =       UR_DAT+2        ; interrupt ID
+UR_LCR  =       UR_DAT+3        ; line control registers
+UR_MCR  =       UR_DAT+4        ; modem control register
+UR_LSR  =       UR_DAT+5        ; line status register
+UR_MSR  =       UR_DAT+6        ; modem status regiser
+UR_DLL  =       UR_DAT          ; divisor latch least sig
+UR_DLM  =       UR_DAT+1        ; divisor latch most sig
+iflag   DB      0               ; != 0 when initialized 8250
+;*      inchr - input character
+;
+;       EXIT    'z' set if no character
+;               'z' clear if char
+;                 (al) = char
+inchr:  mov     dx,UR_LSR
+        in      al,dx
+        and     al,1
+        jz      inchr1
+        mov     dx,UR_DAT
+        in      al,dx
+        and     al,07fh
+inchr1: ret
+        PUBLIC  putchar
+putchar PROC    NEAR
+        pushf
+        cli
+        push    dx
+        push    cx
+        push    bx
+        push    ax              ; (al) = character
+        test    iflag,255
+        jnz     putc1           ; is initialized
+        inc     iflag
+;       program the usart
+        mov     dx,UR_LCR
+        mov     al,80h
+        out     dx,al           ; command it
+        sub     al,al
+        mov     dx,UR_DLM
+        out     dx,al
+        mov     dx,UR_DLL
+        mov     al,12           ; 9600 baud = 12, 19.2 Kbaud = 6
+        out     dx,al
+        mov     al,3
+        mov     dx,UR_LCR
+        out     dx,al           ; command normal mode
+;       see if CTL-Q or CTL-S
+putc1:  pushf
+        cli
+        call    inchr
+        jz      putc3           ; no characters incomming
+        cmp     al,19           ; ctl-S?
+        jnz     putc3           ; no, ignore
+;       have ctl-s.  wait till we see ctl-Q
+putc2:  call    inchr
+        jz      putc2
+        cmp     al,17
+        jnz     putc2
+putc3:  popf
+        mov     dx,UR_LSR
+putc4:  in      al,dx
+        test    al,020h
+        jz      putc4
+;       ready.  crank it out!
+        mov     dx,UR_DAT
+        pop     ax
+        out     dx,al
+        pop     bx
+        pop     cx
+        pop     dx
+        popf
+        ret
+putchar ENDP
+ENDIF
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/DEFDBUG.INC b/v4.0-ozzie/bin/DISK2/BIOS/DEFDBUG.INC
new file mode 100644
index 0000000..590e376
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/DEFDBUG.INC
@@ -0,0 +1,122 @@
+;**     DEFDBUG.ASM - Debugging Macro Definitions
+;
+;
+;       DEBUG   n,m,<format string>, <arg list>
+;
+;
+.sall
+DEBUG   MACRO   N,M,string,args
+ local b,c
+ IFDEF DEBUGFLG
+  pushf
+  DEBUGTST N,M
+  jz    b
+  push ax
+  push bp
+  call  c               ;; push address of string
+  DB    '&string',0
+c:      mov     bp,sp
+; IFNB      <args>
+ IRP     Y,<args>
+  IFIDN   <Y>,<ax>
+    push 4[bp]
+  ELSE
+  IFIDN   <Y>,<AX>
+    push 4[bp]
+  ELSE
+  IFIDN   <Y>,<bp>
+    push 2[bp]
+  ELSE
+  IFIDN   <Y>,<BP>
+    push 2[bp]
+  ELSE
+    mov     ax,Y
+    push ax
+   ENDIF
+   ENDIF
+   ENDIF
+   ENDIF
+ ENDM
+; ENDIF
+  call    DPRINTF
+  mov     sp,bp
+  pop     ax              ;; discard format string offset
+  pop     bp
+  pop     ax
+b:      popf
+   ENDIF
+ENDM
+;**     ERRNZ - generate assembly error if arg != 0
+;
+ERRNZ   MACRO   EXPR
+ IF1
+  IFE     expr
+  ELSE
+  RADIX   0       ; CONDITION NOT MET - ERROR
+  ENDIF
+ ENDIF
+        ENDM
+;**     DBBEG - Start debugging range
+;
+DBBEG   MACRO   N,M
+ LOCAL   lab
+ IFDEF   DEBUGFLG
+  pushf
+  DEBUGTST N,M
+  jnz     lab                     ;; am to do it
+  DBJMP   %DBCNT
+lab:
+    ENDM
+DBJMP   MACRO   N
+ jmp DBLAB&N
+        ENDM
+;**     DEBUGTST - Test Debug Flags
+;
+;       DEBUGTST   n,m
+;
+;       Where N and M are bit masks.
+;
+;       If one or more of the bits in N is set in the high byte
+;       of BUGBITS, and one or more of the bits in M is set in
+;       the low byte of BUGBITS then clear the Z flag.
+;
+;       In other words:
+;
+;       If both masks show a "hit" clear 'Z' else set 'Z'
+;
+;       USES    FLAGS
+DEBUGTST    MACRO   N,M
+        LOCAL   A
+        test    BYTE PTR BUGBITS,n
+        jz      A
+        test    BYTE PTR BUGBITS+1,m
+A:
+        ENDM
+DBEND   MACRO
+        DBLAB   %DBCNT
+DBCNT   =       DBCNT+1
+        popf
+        ENDM
+DBLAB   MACRO   N
+DBLAB&N:
+        ENDM
+  DBCNT = 1
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.ASM b/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.ASM
new file mode 100644
index 0000000..318b1b0
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.ASM
@@ -0,0 +1,2214 @@
+TITLE   IBMBIO  IBM BIOS FOR MS-DOS 4.0
+;   Modified for 3.0, July '83, Marc McDonald
+;
+;   arw 02/01/84
+;       split disk driver into separate file
+;   arw 05/01/84
+;       split out console driver
+;::::::::::::::::::::::::::::::::::::::::::::::
+;
+;       IBM ADDRESSES FOR I/O
+;
+;::::::::::::::::::::::::::::::::::::::::::::::
+        PAGE    ,132
+;DEBUGFLG =     1               ; don't enable debug printfs
+CONSFLAG =      0               ; =1 to include console driver here
+.xlist
+        INCLUDE DEFDBUG.INC
+.list
+        BIOSEG=70H              ;0070   SEGMENT FOR THE BIOS
+        SYSIZE=100H             ;Number of paragraphs in sysinit module
+        RSINIT=0A3H             ;RS232 INITIALIZATION
+                                ;9600 BAUD:NO PARITY:1 STOP:8 BIT WORD
+        LF=10                   ;LINE FEED
+        CR=13                   ;CARRIAGE RETURN
+        BACKSP=8                ;BACKSPACE
+        BRKADR=6CH              ;006C  BREAK VECTOR ADDRESS
+        DSKADR=1EH*4            ;ADDRESS OF PTR TO DISK PARAMETERS
+        SEC9=522H               ;ADDRESS OF DISK PARAMETERS
+        AKPORT=20H
+        EOI=20H
+;**     Timer and Clock Definitions
+SCHEDCOUNT      EQU     50              ; # msec/scheduler tick
+MOTORCOUNT      EQU     55              ; # msec/ROM BIOS tick
+        EXTRN   CURRENT_DOS_LOCATION:WORD
+        EXTRN   FINAL_DOS_LOCATION:WORD
+        EXTRN   DEVICE_LIST:DWORD
+        EXTRN   MEMORY_SIZE:WORD
+        EXTRN   DEFAULT_DRIVE:BYTE
+        EXTRN   SYSINIT:FAR
+BiosSeg GROUP   Code,BiosInit
+Code    SEGMENT BYTE PUBLIC     'CODE'
+   ASSUME CS:BiosSeg,DS:NOTHING,ES:NOTHING
+START$:
+        JMP     INIT
+        DB      20 DUP (0)      ; IBM WANTS SOME ZEROED AREA
+SUBTTL  Jump tables for devices
+;--------------------------------------------------------------
+;
+;       COMMAND JUMP TABLES
+;
+;       BEWARE - These tables overlap somewhat! -c.p.
+;
+IF      CONSFLAG
+CONTBL:
+        DW      SetAddr
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      CMDERR
+        DW      CON$READ
+        DW      CON$RDND
+        DW      StatusComplete
+        DW      CON$FLSH
+        DW      CON$WRIT
+        DW      CON$WRIT
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+ENDIF   ;CONSFLAG
+AUXTBL:
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      CMDERR
+        DW      AUX$READ
+        DW      AUX$RDND
+        DW      StatusComplete
+        DW      AUX$FLSH
+        DW      AUX$WRIT
+        DW      AUX$WRIT
+        DW      AUX$WRST
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+TIMTBL:
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      CMDERR
+        DW      TIM$READ
+        DW      StatusDevReady
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      TIM$WRIT
+        DW      TIM$WRIT
+PRNTBL:
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      CMDERR
+        DW      StatusNoXfer            ; Printer doesn't read
+        DW      StatusDevReady
+        DW      StatusComplete
+        DW      StatusComplete
+        DW      PRN$WRIT
+        DW      PRN$WRIT
+        DW      PRN$STAT
+        DW      StatusComplete
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+        DW      CMDERR
+SUBTTL  Device entry points
+;---------------------------------------------------
+;
+;       Device Entry point
+;
+CMDLEN  =       0       ;LENGTH OF THIS COMMAND
+UNIT    =       1       ;SUB UNIT SPECIFIER
+CMD     =       2       ;COMMAND CODE
+STATUS  =       3       ;STATUS
+MEDIA   =       13      ;MEDIA DESCRIPTOR
+TRANS   =       14      ;TRANSFER ADDRESS
+Dfun    =       DWORD PTR 14            ; Passed addr of dos function
+COUNT   =       18      ;COUNT OF BLOCKS OR CHARACTERS
+START   =       20      ;FIRST BLOCK TO TRANSFER
+AUXNUM  DB      0       ;WHICH AUX DEVICE WAS REQUESTED
+; Dos routine to do functions for device drivers
+        PUBLIC  DosFunction
+DosFunction     DD      0       ; Device help function entry point
+ScrnIOok        dd      0       ; (char *) true if in current screen locus
+TIM_DRV DB      -1              ; TIME WHEN LAST DISK I/O PERFORMED
+TIM_REM DW      0               ; scheduler tics left until media presumed
+                                ; changed
+;**     Debugging control:
+;
+;       Group   Level   Controls
+;        01             General BIOS, bootstrapping and initialization
+;                01             Device initialization
+;                02             MS-DOS bootstrapping
+;                04             Driver error conditions
+;                10             Command dispatch
+;        04             Diskette driver
+;                01             Initialization
+;                02             System entrys
+;                04             Details of read/write processing
+;        08             Hard disk driver
+;                01             Initialization
+;                02             System entrys
+;        10             Console display driver
+        PUBLIC  BUGBITS
+BUGBITS DB  000H                        ; group bits
+        DB  0ffH                        ; level bits
+Strategy        PROC    FAR
+        RET
+Strategy        ENDP
+IF      CONSFLAG
+CON$IN:
+        PUSH    SI
+        MOV     SI,OFFSET CONTBL
+        JMP     SHORT Interrupt
+ENDIF   ;CONSFLAG
+AUX0$IN:
+        PUSH    SI
+        PUSH    AX
+        XOR     AL,AL
+        JMP     SHORT AUXENT
+AUX1$IN:
+        PUSH    SI
+        PUSH    AX
+        MOV     AL,1
+AUXENT:
+        MOV     SI,OFFSET AUXTBL
+        JMP     SHORT entry1
+PRN0$IN:
+        PUSH    SI
+        PUSH    AX
+        XOR     AL,AL
+        JMP     SHORT PRNENT
+PRN1$IN:
+        PUSH    SI
+        PUSH    AX
+        MOV     AL,1
+        JMP     SHORT PRNENT
+PRN2$IN:
+        PUSH    SI
+        PUSH    AX
+        MOV     AL,2
+PRNENT:
+        MOV     SI,OFFSET PRNTBL
+        JMP     SHORT entry1
+TIM$IN:
+        PUSH    SI
+        MOV     SI,OFFSET TIMTBL
+COMMENT *
+   Interrupt is the main part of the interrupt device entry point( a
+misnomer, actually is the execute function entry ) for all devices.
+The various devices set up the dispatch table address and unit choice
+and then jump to Interrupt which then dispatches to the appropriate
+device routine.
+Entry parameters:
+        SI      Address of device dispatch table
+        AL      Unit # for Aux/Prn( stored in AuxNum )
+        ES:BX   Device request packet address
+Exit parameters:        ( to device routine )
+        AL      Unit code from packet
+        AH      Media descriptor from packet
+        CX      Count from packet
+        DX      Start sector from packet
+        ES:DI   Buffer address from packet
+        DS:BX   Packet address
+        SS      TaskArea segment( from dos call )
+        *
+        PUBLIC  Interrupt
+Interrupt       PROC    FAR
+        PUSH    AX
+entry1:
+        PUSH    CX
+        PUSH    DX
+        PUSH    DI
+        PUSH    BP
+        PUSH    DS
+        PUSH    ES
+        PUSH    BX
+        debug   1,10H,< INTERRUPT cmdtbl $x >,<si>
+        MOV     CS:[AUXNUM],AL          ; Save unit choice of AUX/PRN
+        MOV     AX,ES
+        MOV     DS,AX                   ; DS:BX also points to packet
+        MOV     AL,DS:[BX].Cmd          ; Get device command
+        XOR     AH,AH
+        ADD     SI,AX
+        ADD     SI,AX                   ; Get Address of routine
+        CMP     AL,18                   ; Too high a command number?
+        JA      CmdErr                  ; Yes, error
+        MOV     AL,DS:[BX].UNIT         ;AL = Unit code
+        MOV     AH,DS:[BX].MEDIA        ;AH = Media descriptor
+        MOV     CX,DS:[BX].COUNT        ;CX = Count
+        MOV     DX,DS:[BX].START        ;DX = Start sector
+        LES     DI,DS:[BX].TRANS        ; ES:DI = buffer addr
+        debug   1,10H,<un $x xfer $x:$x rtn $x\n>,<ax,es,di,cs:[si]>
+        JMP     WORD PTR CS:[SI]        ; Do request
+Interrupt       ENDP
+SUBTTL  Routines used by device routines
+COMMENT        *
+   All routines on this page are various exits for device functions.
+They each return different information in the request packet for the
+dos. The routines are as follows:
+        StatusDevReady
+                  The busy and done bits are set in the packet. This
+                means that the device has input to be read or can
+                do output without any waiting.
+        StatusPartialXfer
+                  The device was unable to do the I/O for the requested
+                number of bytes/blocks. CX contains the number that are
+                left to do. Fall into StatusError to set error has
+                happened.
+        StatusError
+                  Set the error and done bits in the status.
+        StatusNoXfer
+                  The device couldn't do the read or write, set the
+                number of bytes transferred to 0, but don't set the
+                error bit.
+        StatusComplete
+                  The device actually completed the request and every-
+                thing was just fine, so just set the done bit in the
+                request status.
+        StatusWait
+                  The device driver is for 3.0 and saw that it would
+                have to wait in a loop to do the request, so instead
+                it will not set the done bit which tells the dos to
+                put the task into the I/O wait queue.
+Entry parameters:       ( for all of the above routines )
+        DS:BX   Address of device request packet
+        CX      Count of bytes/blocks left to transfer if applicable
+        AL      Error code if applicable
+Exit parameters:
+        ES:BX   Pointer to packet
+        AX      Destroyed
+        SI      Destroyed
+        All other registers preserved
+        *
+        PUBLIC  StatusDevReady
+StatusDevReady  PROC    NEAR            ; Device has data or can send
+        MOV     AH,00000011B            ; Done + busy
+        JMP     SHORT SetStatus
+StatusDevReady  ENDP
+        PUBLIC  CmdErr
+CmdErr  PROC    NEAR            ; Bad device command number
+        debug   1,4,< CMDERR - $b $x\n>,<ax,si>
+        MOV     AL,3                    ; Unknown command error
+CmdErr  ENDP
+StatusPartialXfer       PROC    NEAR
+        SUB     [BX].COUNT,CX           ;# of successful I/O's
+StatusPartialXfer       ENDP
+        PUBLIC  StatusError
+StatusError     PROC    NEAR
+        MOV     AH,10000001B            ; Error + done
+        JMP     SHORT SetStatus
+StatusError     ENDP
+StatusNoXfer    PROC    NEAR
+        XOR     AX,AX
+        MOV     [BX].COUNT,AX           ; No chars read
+StatusNoXfer    ENDP
+        PUBLIC  StatusComplete
+StatusComplete  PROC    NEAR
+        MOV     AH,00000001B            ; Done
+        PUBLIC  SetStatus
+SetStatus:
+        POP     BX
+        POP     ES
+        MOV     ES:WORD PTR [BX].STATUS,AX     ;MARK OPERATION COMPLETE
+        POP     DS
+        POP     BP
+        POP     DI
+        POP     DX
+        POP     CX
+        POP     AX
+        POP     SI
+XXX     PROC    FAR
+        RET                             ;RESTORE REGS AND RETURN
+XXX     ENDP
+StatusComplete  ENDP
+StatusWait      PROC    NEAR
+        MOV     AH,0                    ; Don't set done bit
+        MOV     [BX].Count,CX           ; Set number completed
+        MOV     WORD PTR [BX].Trans,DI  ; Set new offset
+        JMP     SetStatus
+StatusWait      ENDP
+IF      CONSFLAG
+; Set the address of the dos function routine for drivers
+SetAddr PROC    NEAR
+        MOV     AX,WORD PTR [BX].Dfun
+        MOV     WORD PTR DosFunction,AX
+        MOV     AX,WORD PTR [BX+2].Dfun
+        MOV     WORD PTR (DosFunction+2),AX
+        mov     ax,0
+        mov     cx,1
+        mov     dx,16
+        call    DosFunction
+        mov     word ptr ScrnIOok,ax
+        mov     word ptr ScrnIOok+2,dx
+        JMP     StatusComplete
+SetAddr ENDP
+;-------------------------------------------------------------
+;
+;       CHROUT - WRITE OUT CHAR IN AL USING CURRENT ATTRIBUTE
+;
+;       CALLED VIA INT 29H
+;
+CHROUT  =       29H
+OUTCHR: STI
+        PUSH    AX
+        MOV     BX,7
+        MOV     AH,14           ;WRITE CHARACTER
+        INT     10H             ;SEND THE CHARACTER
+        POP     AX
+        IRET
+ENDIF   ;CONSFLAG
+;----------------------------------------------
+;
+;       SET DX TO AUXNUM
+;
+GETDX:  MOV     DL,[AUXNUM]
+        XOR     DH,DH
+        RET
+SUBTTL  Console driver
+COMMENT        *
+   This is the console( CON ) device driver. The input side is assigned
+to the keyboard and the output to the video screen. The output code
+remains more or less the same as in 2.0. The input side, however, is
+changed for 4.0 to enter an I/O wait rather than loop waiting for a
+character.
+        *
+IF      CONSFLAG
+CONDEV  LABEL   WORD                    ;HEADER FOR DEVICE "CON"
+        DW      AUXDEV,BIOSEG
+        DW      1000000000010011B       ;CON IN AND CON OUT + SPECIAL
+        DW      STRATEGY
+        DW      CON$IN
+        DB      'CON     '
+ELSE
+        EXTRN   CONDEV:NEAR
+        PUBLIC  AUXDEV
+ENDIF   ;CONSFLAG
+IF      CONSFLAG
+Key2ndPart      DB      0               ; Leftover byte of 2 key codes
+RomData SEGMENT AT 40H
+        ORG     1AH
+Bufferhead      DW      ?
+BufferTail      DW      ?
+KeyBuffer       LABEL   WORD
+KeyBufLen       equ     32              ; length of KeyBuffer
+RomData ENDS
+; BREAK interrupt routine
+; ROM interrupt handler resets buffer pointers to beginning of buffer
+; and places a 0000h dummy character into the buffer.
+Break   PROC    NEAR
+        mov     Key2ndPart,3            ; Force next char to be ^C( stop )
+        IRET
+Break   ENDP
+SUBTTL  Console read and subroutines
+        PAGE
+COMMENT *
+   The console read dispatch tries to read the selected number of
+characters from the keyboard. If at any point there is no key in
+the queue, it returns to the dos to allow another process to run
+until a key is depressed.
+Entry parameters:
+        ES:DI   Pointer to buffer in which to store characters
+        CX      Number of characters to read
+        DS:BX   Pointer to device request packet
+Exit parameters:
+        CX      Number of characters left to read
+        DS:BX   Pointer to device request packet
+        *
+Con$Read        PROC    NEAR
+        JCXZ    StatusComplete
+CON$LOOP:
+        PUSH    CX              ;SAVE COUNT
+        CALL    ChrIn           ;GET CHAR IN AL
+        POP     CX
+        STOSB                   ;STORE CHAR AT ES:DI
+        LOOP    CON$LOOP
+        JMP     StatusComplete
+Con$Read        ENDP
+COMMENT *
+    ChrIn attempts to read a character from the keyboard queue that
+is maintained by the ROM BIOS. If the queue is not empty, the code
+is returned. Otherwise, the packet is added to the list of keyboard
+reads and carry is set to cause the driver routine to return to the
+dos with the done bit not set which results in an I/O wait.
+Entry parameters:
+        DS:BX   Pointer to device request packet
+Exit parameters:
+        AL      Character from keyboard if present
+*
+ChrIn   PROC    NEAR
+ConReadLoop:
+        XOR     AX,AX
+        XCHG    AL,Key2ndPart           ; GET CHARACTER & ZERO Key2ndPart
+        OR      AL,AL
+        JNZ     KeyRet
+        MOV     AH,0
+        INT     16H                     ; Get the char
+        OR      AX,AX           ;Check for non-key after BREAK
+        JZ      ConReadLoop
+        CMP     AX,7200H        ;Check for CTRL-PRTSC
+        JNZ     ALT15
+        MOV     AL,16
+ALT15:
+        OR      AL,AL           ; 2 byte keycode?
+        JNZ     KeyRet          ; No, have whole code
+        MOV     Key2ndPart,AH   ; Yes, store scan code for next read
+KeyRet: RET
+ChrIn   ENDP
+COMMENT *
+   The non-destructive keyboard read routine returns the next char
+in the queue if there is one.
+Entry parameters:
+        DS:BX   Pointer to device request packet
+Exit parameters:
+        DS:BX   Pointer to device request packet
+        *
+Con$RdNd        PROC    NEAR
+        MOV     AL,[Key2ndPart]
+        OR      AL,AL
+        JNZ     RDexit
+        mov     ah,1
+        int     16h
+        JZ      CONBUS
+        OR      AX,AX
+        JNZ     NOTBRK                  ;CHECK FOR NULL AFTER BREAK
+        MOV     AH,0
+        INT     16H                     ;READ THE NULL
+        JMP     CON$RDND                ;AND GET A REAL STATUS
+NOTBRK: CMP     AX,7200H                ;CHECK FOR CTRL-PRTSC
+        JNZ     RDexit
+        MOV     AL,16
+RDexit:
+        MOV     [BX].MEDIA,AL
+EXVEC:  JMP     StatusComplete
+CONBUS: JMP     StatusDevReady
+Con$RdNd        ENDP
+;--------------------------------------------------------------
+;
+;       KEYBOARD FLUSH ROUTINE
+;
+Con$Flsh        PROC    NEAR
+        MOV     [Key2ndPart],0                 ;Clear out holding buffer
+        CALL    Flush                   ; Flush the keyboard
+        JMP     EXVEC
+Con$Flsh        ENDP
+Flush   PROC    NEAR
+        PUSH    DS
+        MOV     AX,RomData
+        MOV     DS,AX
+    ASSUME      DS:RomData
+        CLI                             ; ** Disable interrupts
+        MOV     AX,offset RomData:KeyBuffer  ; Start of Rom buffer
+        MOV     BufferHead,AX
+        MOV     BufferTail,AX           ; Empty the queue
+        STI                             ; ** enable interrupts
+        POP     DS
+    ASSUME      DS:NOTHING
+        RET
+Flush   ENDP
+SUBTTL  Console output( video ) routines
+        PAGE
+;----------------------------------------------------------
+;
+;       CONSOLE WRITE ROUTINE
+;
+CON$WRIT:
+        JCXZ    EXVEC
+CON$LP: MOV     AL,ES:[DI]      ;GET CHAR
+        INC     DI
+        PUSH    CX
+        PUSH    DI
+        INT     CHROUT          ;OUTPUT CHAR
+        POP     DI
+        POP     CX
+        LOOP    CON$LP          ;REPEAT UNTIL ALL THROUGH
+        JMP     EXVEC
+SUBTTL  Keyboard interrupt routine
+PAGE
+; Replacement for ROM keyboard interrupt, tacks on the front.
+; OldKeyInterrupt is set to original contents of INT 09H.
+; The input character is passed to the O.S. console input filter
+; to determine if any special action should be taken.  The filter
+; return value indicates if the character should be saved in the
+; type ahead buffer or if it should be discarded.  A keyboard
+; semaphore exists to indicate if a process is waiting for input.
+; If the keboard semaphore is set all of the processes sleeping on
+; it are woken up.
+OldKeyInterrupt DD      ?
+KeySem          db      0               ; non-zero if someone waiting on input
+KeyboardInterrupt       PROC FAR
+        INT     32H                     ; Save regs
+        MOV     AX,RomData
+        MOV     DS,AX
+    ASSUME      DS:RomData
+        PUSHF                           ; Save flags to simulate INT
+        CALL    CS:OldKeyInterrupt      ; Now do ROM code
+; Now tell scheduler keyboard had char
+        cli                             ; interrupts off!
+        mov     bx,BufferTail           ; Get tail of queue
+        cmp     bx,BufferHead           ; Anything in keyboard queue?
+        JE      NoKey                   ; No, don't requeue then
+        dec     bx
+        dec     bx
+        cmp     bx,offset RomData:KeyBuffer
+        jae     kbi1                    ; no rap around in buffer
+        mov     bx,offset RomData:KeyBuffer+KeyBufLen
+kbi1:
+        mov     ax,[bx]                 ; get last queued char.
+        mov     dx,5                    ; ConsInputFilter subfunction
+        call    DosFunction
+        jnz     kbi2                    ; key should remain in buffer
+        mov     BufferTail,bx           ; discard key from buffer
+        jmp     SHORT NoKey
+kbi2:
+        cli
+        CMP     KeySem,0                ; Outstanding request?
+        JE      NoKey                   ; No, may not be inited either
+        push    ax
+        push    bx
+        push    cx
+        push    dx
+        mov     ax,cs
+        mov     bx,OFFSET KeySem
+        mov     cs:byte ptr [bx],0      ; reset keyboard semaphore
+        mov     dx,10                   ;; ProcRun
+        call    [DosFunction]           ; awaken anyone waiting on input
+        pop     dx
+        pop     cx
+        pop     bx
+        pop     ax
+NoKey:
+        IRET
+KeyBoardInterrupt       ENDP
+;-------------------------------------------------------------
+; Keyboard INT 16 intercept routine to allow console input to sleep.
+; Only console input function 1 is intercepted, all other functions
+; are allowed to go directly to the ROM BIOS.  For the function 1
+; the input status is checked, if a character is ready the function
+; is allowed to go to the ROM BIOS.  Otherwise the keyboard semaphore
+; is set and the process is put to sleep on the address of the
+; semaphore.  When a key is typed the keyboard interrupt routine
+; will wakeup any processes sleeping on this semaphore.
+;
+;       WARNING: The following routines can be entered recursively
+;                due to the fact that the ROM BIOS routines called
+;                reenable interrupts.  It's not usually a problem
+;                since interrupts will generally be processed faster
+;                than anyone can type.
+OldKbdHandler   dd      ?
+;-------------------------------------------------------------
+KeyBoardHandler proc    far
+        or      ah,ah
+        je      DoLocalRead
+        cmp     ah,1
+        je      DoLocalStat
+OldKBint:
+        jmp     [OldKbdHandler]
+DoLocalStat:
+        push    bx
+        push    ds
+        lds     bx,ScrnIOok
+        test    byte ptr [bx],0FFh
+        pop     ds
+        pop     bx
+        jnz     OldKBint
+        xor     ax,ax
+        ret     2
+DoLocalRead:
+        push    ax
+        push    bx
+        push    cx
+        push    dx
+DoLocalRd1:
+        push    ds
+        lds     bx,ScrnIOok
+        mov     ax,ds
+        test    byte ptr [bx],0FFh
+        pop     ds
+        jnz     DoLocalRd2
+        xor     cx,cx
+        mov     dx,9                    ;; ProcBlock
+        call    [DosFunction]           ; sleep until a char is typed
+        jmp     DoLocalRd1
+DoLocalRd2:
+        mov     ah,1                    ; get console status
+        pushf                           ; simulate INT to old handler
+        cli
+        call    [OldKbdHandler]
+        cli                             ; subfunction 1 unconditionally sets IF
+        jnz     LocalRead               ; go read character
+        mov     ax,cs
+        mov     bx,OFFSET KeySem
+        mov     cs:byte ptr [bx],0FFh   ; set keyboard semaphore
+        xor     cx,cx
+        mov     dx,9                    ;; ProcBlock
+        call    [DosFunction]           ; sleep until a char is typed
+        jmp     DoLocalRd1
+LocalRead:
+        pop     dx
+        pop     cx
+        pop     bx
+        pop     ax
+        jmp     [OldKbdHandler]         ; read the character and return
+KeyBoardHandler endp
+ENDIF   ;CONSFLAG
+SUBTTL  Aux driver
+;------------------------------------------------------
+;
+;       A U X - AUXILARY DEVICE DRIVER
+;
+AUXDEV  LABEL   WORD                    ;HEADER FOR DEVICE "AUX"
+        DW      PRNDEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      AUX0$IN
+        DB      'AUX     '
+        PUBLIC  COM1DEV
+COM1DEV LABEL   WORD
+        DW      LPT1DEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      AUX0$IN
+        DB      'COM1    '
+COM2DEV LABEL   WORD
+        DW      -1,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      AUX1$IN
+        DB      'COM2    '
+AUXBUF  DB      0,0
+;-------------------------------------------------------
+;
+;       READ FROM AUXILARY DEVICE
+;
+AUX$READ:
+        JCXZ    EXVEC2
+        CALL    GETBX
+        XOR     AX,AX
+        XCHG    AL,[BX]         ;Get character and zero buffer
+        OR      AL,AL
+        JNZ     AUX2
+AUX1:   CALL    AUXIN
+AUX2:   STOSB                   ;STORE CHARACTER
+        LOOP    AUX1
+EXVEC2: JMP     StatusComplete
+AUXIN:  MOV     AH,2            ;INDICATES A READ
+        CALL    AUXOP           ;READ THE AUXILIARY PORT
+        TEST    AH,0EH          ;Check framing, parity, overrun
+        JZ      AROK
+        POP     AX              ;Clean up the stack
+        MOV     AL,0BH          ;READ ERROR
+        JMP     StatusPartialXfer
+AROK:   RET
+;--------------------------------------------------------
+;
+;       AUX NON-DESTRUCTIVE READ, NO WAITING
+;
+AUX$RDND:
+        CALL    GETBX
+        MOV     AL,[BX]         ;GET KEY AND ZERO BUFFER
+        OR      AL,AL
+        JNZ     AUXRDX          ;KEY IN BUFFER?
+        CALL    AUXSTAT
+        TEST    AH,00000001B            ;TEST DATA READY
+        JZ      AUXBUS
+        TEST    AL,00100000B            ;TEST DATA SET READY
+        JZ      AUXBUS
+        CALL    AUXIN
+        CALL    GETBX
+        MOV     [BX],AL     ;GET AND SAVE KEY
+AUXRDX: JMP     StatusComplete
+AUXBUS: JMP     StatusDevReady
+;----------------------------------------------------------
+;
+;       AUX OUTPUT STATUS
+;
+AUX$WRST:
+        CALL    AUXSTAT
+        TEST    AL,00100000B    ;TEST DATA SET READY
+        JZ      AUXBUS
+        TEST    AH,00100000B    ;TEST CLEAR TO SEND
+        JZ      AUXBUS
+        JMP     EXVEC2
+AUXSTAT:
+        MOV     AH,3
+AUXOP:  CALL    GETDX
+        INT     14H
+        RET
+;---------------------------------------------------------
+;
+;       FLUSH AUX INPUT BUFFER
+;
+AUX$FLSH:
+        CALL    GETBX
+        MOV     BYTE PTR [BX],0
+        JMP     EXVEC2
+;---------------------------------------------------------
+;
+;       WRITE TO AUXILARY DEVICE
+;
+AUX$WRIT:
+        JCXZ    EXVEC2
+AUX$LOOP:
+        MOV     AL,ES:[DI]      ;GET CHAR
+        INC     DI              ;POINT TO NEXT ONE
+        MOV     AH,1            ;INDICATES A WRITE
+        CALL    AUXOP           ;SEND CHARACTER OVER AUX PORT
+        TEST    AH,80H          ;CHECK FOR ERROR
+        JZ      AWOK
+        MOV     AL,10           ;INDICATE WRITE FAULT
+        JMP     StatusPartialXfer
+AWOK:   LOOP    AUX$LOOP
+        JMP     EXVEC2
+GETBX:  CALL    GETDX
+        MOV     BX,DX
+        ADD     BX,OFFSET AUXBUF
+        RET
+SUBTTL  Printer driver
+;-------------------------------------------------------------
+;
+;       P R N - PRINTER DEVICE
+;
+PRNDEV  LABEL   WORD                    ;HEADER FOR DEVICE "PRN"
+        DW      TIMDEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      PRN0$IN
+        DB      'PRN     '
+LPT1DEV LABEL   WORD
+        DW      LPT2DEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      PRN0$IN
+        DB      'LPT1    '
+LPT2DEV LABEL   WORD
+        DW      LPT3DEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      PRN1$IN
+        DB      'LPT2    '
+LPT3DEV LABEL   WORD
+        DW      COM2DEV,BIOSEG
+        DW      1000000000000000B
+        DW      STRATEGY
+        DW      PRN2$IN
+        DB      'LPT3    '
+ERRFLG  DB      0
+;----------------------------------------------------------
+;
+;       WRITE TO PRINTER DEVICE
+;
+PRN$WRIT:
+        JCXZ    EXVEC3
+PRN$LOOP:
+        MOV     AL,ES:[DI]      ;GET CHAR INTO AL
+        INC     DI              ;POINT TO NEXT CHAR
+        MOV     [ERRFLG],0      ;INITIALIZE RETRY FLAG
+PRETRY: XOR     AH,AH           ;AH=0
+        CALL    PRNOP           ;TO INDICATE PRINT CHAR IN AL
+ERRCHK: JZ      PROK
+        XOR     [ERRFLG],1            ;DO 1 AUTOMATIC RETRY
+        JNZ     PRETRY
+PMESSG: JMP     StatusPartialXfer         ;RETURN WITH THE ERROR
+PROK:   LOOP    PRN$LOOP
+EXVEC3: JMP     StatusComplete
+;--------------------------------------------------------
+;
+;       PRINTER STATUS ROUTINE
+;
+PRN$STAT:
+        CALL    PRNSTAT         ;DEVICE IN DX
+        JNZ     PMESSG
+        TEST    AH,10000000B
+        JNZ     EXVEC3
+        JMP     StatusDevReady
+PRNSTAT:
+        MOV     AH,2
+PRNOP:  CALL    GETDX
+        INT     17H
+        MOV     AL,2
+        TEST    AH,0001B        ;TEST FOR NOT READY
+        JNZ     PRNOP2
+        MOV     AL,10           ;WRITE FAULT CODE
+        TEST    AH,1000B        ;TEST FOR I/O ERROR
+        JZ      PRNOP2
+        TEST    AH,00100000B    ;OUT-OF-PAPER?
+        JZ      PRNOP1
+        MOV     AL,9            ;OUT OF PAPER CODE
+PRNOP1: OR      AL,AL           ;SET NZ FLAG
+PRNOP2: RET
+SUBTTL Timer (clock) driver
+        PAGE
+;**     Time Functions
+;
+;       Uses clock with 1000 ticks per second. User sees only
+;       time in hours, minutes, seconds, and 1/100 second, in registers
+;       CH, CL, DH, DL respectively. (Each is a binary number.)
+;             Modified for 4.0. The ROM bios timer routines are completely
+;       replaced with code on this page. This provides a better time base
+;       for the scheduler.
+        EXTRN   Floppydevice:NEAR
+TIMDEV  LABEL   WORD
+        DW      Floppydevice,BIOSEG
+        DW      1000000000001000B
+        DW      STRATEGY
+        DW      TIM$IN
+        DB      'CLOCK$  '
+DAYCNT  DW      0
+;--------------------------------------------------------------------
+;
+; Settime sets the current time
+;
+; On entry ES:[DI] has the current time:
+;
+;       number of days since 1-1-80     (WORD)
+;       minutes (0-59)                  (BYTE)
+;       hours (0-23)                    (BYTE)
+;       hundredths of seconds (0-99)    (BYTE)
+;       seconds (0-59)                  (BYTE)
+;
+; Each number has been checked for the correct range.
+TIM$WRIT:
+        PUSH    BX
+        MOV     AX,ES:[DI]
+        MOV     DAYCNT,AX
+        MOV     CX,ES:[DI+2]
+        MOV     AL,60
+        MUL     CH              ;Hours to minutes
+        MOV     CH,0
+        ADD     AX,CX           ;Total minutes
+        MOV     CX,60000        ;60*1000
+        MUL     CX              ;Convert to milliseconds
+        MOV     SI,AX
+        MOV     BX,DX           ; Save hours, min in Msecs in BX:SI
+        MOV     AL,ES:[DI+5]    ; Get # seconds
+        MOV     CX,100
+        MUL     CL              ; Get seconds in 1/100s
+        MOV     CL,ES:[DI+4]    ; Hundredths of second
+        ADD     AX,CX           ; Now have seconds and 1/100ths
+        MOV     CL,10
+        MUL     CX              ; Get DX:AX = milliseconds
+        ADD     AX,SI
+        MOV     CS:TickLow,AX
+        ADC     BX,0
+        MOV     CS:TickHigh,BX  ; Set time in milliseconds
+        POP     BX
+        JMP     StatusComplete
+;***************************************
+;
+; Gettime reads date and time
+; and returns the following information:
+;
+;       ES:[DI]  =count of days since 1-1-80
+;       ES:[DI+2]=minutes
+;       ES:[DI+3]=hours
+;       ES:[DI+4]=hundredths of seconds
+;       ES:[DI+5]=seconds
+;
+;***************************************
+        PUBLIC  TIM$READ
+TIM$READ:
+        PUSH    BX
+        MOV     AX,DayCnt
+        STOSW                   ; return day
+        MOV     DX,CS:TickHigh
+        MOV     AX,CS:TickLow   ; Get current time
+        MOV     CX,60000        ; # milliseconds in a minute
+        DIV     CX              ; Get AX= minutes, DX = seconds&msecs
+        MOV     BX,DX           ; Save seconds and fraction
+        XOR     DX,DX
+        MOV     CX,60           ; # minutes/hour
+        DIV     CX              ; Get AX= hour, DX= minute
+        xchg    ax,dx
+        STOSB                   ; Return minutes
+        xchg    ax,dx
+        STOSB                   ; Return hours
+        MOV     AX,BX
+        XOR     DX,DX
+        MOV     CX,1000
+        DIV     CX              ; Get AX= seconds, DX= milliseconds
+        xchg    ax,bx           ; (bx) = seconds
+        MOV     AX,DX
+        XOR     DX,DX
+        MOV     CX,10
+        DIV     CX              ; Get hundredths of second
+        STOSB                   ; Return hundredths of second
+        xchg    ax,bx
+        STOSB                   ; Return second
+        POP     BX
+        JMP     StatusComplete
+SUBTTL  Clock interrupt and replacement for ROM code
+PAGE
+COMMENT *
+   The clock code in the ROM is replaced with the following code which
+provides the clock interface to the scheduler and a 1 ms time base. The
+1AH interrupt is simulated to return the approximate time for those
+routines which still call 1AH. The time period for motor start up is
+preserved since that code has not yet been rewritten.
+        *
+RomData SEGMENT AT 040H
+        ORG     03FH
+Motor_Status    DB      1 DUP(?)
+Motor_Count     DB      1 DUP(?)
+RomData ENDS
+TickLow         DW      ?               ; Low part of time in Msec
+TickHigh        DW      ?               ; High part of time in msec
+MotorFlag       DB      0               ; There is an active motor
+MotorTick       DB      MOTORCOUNT      ; # ticks until 1/18.2 secs
+SchedTick       DB      SCHEDCOUNT      ; Scheduler countdown
+; Interrupt 8H -        timer interrupt
+    ASSUME      DS:NOTHING
+TimerInterrupt  PROC    FAR
+        PUSH    AX
+        INC     TickLow
+        JNZ     NoOverflow
+        INC     TickHigh
+NoOverFlow:
+        CMP     TickHigh,1318           ; Close to 24 hours?
+        JNZ     NotDay                  ; No
+        CMP     TickLow,23552           ; Reach 24 hours?
+        JNZ     NotDay                  ; No
+; Have reached a day, bump day count
+        INC     DayCnt
+        XOR     AX,AX
+        MOV     TickHigh,AX
+        MOV     TickLow,AX              ; Reset time of day
+NotDay:
+;;      DEC     MotorTick               ; Time to decrement motor?
+;;      JNZ     CheckSched                      ; No
+;;      MOV     MotorTick,MOTORCOUNT    ; Reset 1/18 sec worth of msecs
+;;      PUSH    DS
+;;      MOV     AX,RomData
+;;      MOV     DS,AX
+;;    ASSUME    DS:RomData
+;;      TEST    MotorFlag,0FFH          ; Active motor timer?
+;;      JZ      CheckMotor              ; No, see if new one
+;;      DEC     Motor_Count
+;;      JNZ     CheckMotor              ; Not time to shut down
+;;      AND     Motor_Status,0F0H       ; Turn off motor running bits
+;;      MOV     AL,0CH
+;;      PUSH    DX
+;;      MOV     DX,03F2H
+;;      OUT     DX,AL                   ; Turn off the motors
+;;      POP     DX
+;;      MOV     MotorFlag,0             ; No motor timeout running
+;;      POP     DS
+;;      JMP     CheckSched              ; Go see if time to sched
+;;CheckMotor:
+;;      MOV     AL,Motor_Count
+;;      POP     DS
+;;      JNZ     CheckSched              ; Motor already active
+;;      OR      AL,AL                   ; Need to start countdown?
+;;      JZ      CheckSched              ; No
+;;      MOV     MotorFlag,0FFH          ; Yes, set flag
+;;      MOV     MotorTick,MOTORCOUNT    ; 1/18.2 sec later
+; The scheduler is called every 10ms, rather than every 1 ms to see if
+; it should switch tasks.
+CheckSched:
+; First reset the timer so will interrupt again
+        MOV     AL,36H
+        OUT     43H,AL
+        MOV     AL,169
+        OUT     40H,AL
+        MOV     AL,4
+        OUT     40H,AL                  ; Set 1 msec delay
+        MOV     AL,20H
+        OUT     20H,AL                  ; Tell 8259 interrupt done
+; Now see if should call scheduler
+        DEC     SchedTick               ; Time to call scheduler?
+        JNZ     NoSched                 ; No, all done
+        MOV     SchedTick,SCHEDCOUNT    ; Reset countdown
+csch1:  POP     AX                      ; Stack is now clean
+        INT     32H                     ; Save all regs
+        CMP     WORD PTR (DosFunction+2),0      ; Dos installed?
+        JE      NoSchedActive           ; Not yet, don't call sched
+        sub     dx,dx                   ; (dx) = 0 = tic subfunction
+        mov     ax,SCHEDCOUNT           ; 10 milliseconds per tic
+        CALL    DosFunction             ; Do the tick
+    EXTRN       FloppyTimer:FAR
+        CALL    FloppyTimer             ; timer service for floppy disk also
+NoSchedActive:
+        IRET                            ; All done
+NoSched:
+        POP     AX
+INTRET: IRET                            ; All done
+TimerInterrupt  ENDP
+; INT 1AH -     Get/Set time based in 55msec tick
+TimeOfDay       PROC    FAR
+        OR      AH,AH                   ; Function 0: Read time?
+        JZ      ReadOld                 ; Yes
+        DEC     AH                      ; Function 1: Write time?
+        JZ      WriteOld                ; Yes
+        IRET                            ; No, bad function code
+; Read old( 1/18.2 second tick ) time
+ReadOld:
+        MOV     AX,TickHigh
+        xor     dx,dx
+        MOV     CX,MOTORCOUNT           ; # milliseconds in 1/18.2 secs
+        DIV     CX                      ; Get value in old ticks
+        push    ax
+        MOV     AX,TickLow
+        div     cx
+        pop     cx                      ; get high order count
+        XOR     AL,AL                   ; Never have oveflow
+        IRET                            ; Return the time
+; Set time using old resolution
+WriteOld:
+        MOV     AX,DX
+        push    bx
+        MOV     BX,MOTORCOUNT           ; Conversion factor
+        MUL     BX
+        MOV     TickLow,AX              ; Set low part of time
+        mov     ax,cx
+        mov     cx,dx
+        MUL     BX
+        pop     bx
+        ADD     AX,CX                   ; Combine high parts
+        MOV     TickHigh,AX             ; Set time
+        IRET                            ; Return with new time set
+TimeOfDay       ENDP
+;++++
+memsizmsg       db      13,10,'Error - Interrupt 12',13,10,0
+memsizint       dd      0
+memsizhandler   proc    far
+        push    ax
+        push    bx
+        push    si
+        push    ds
+        push    cs
+        pop     ds
+        mov     SI,offset CS:memsizmsg
+        call    WRMSG
+        pop     ds
+        pop     si
+        pop     bx
+        pop     ax
+        jmp     memsizint
+memsizhandler   endp
+;++++
+;----------------------------------------------
+;       WRITE OUT MESSAGE POINTED TO BY [SI]
+;
+WRMSG:  LODSB                   ;GET THE NEXT CHARACTER OF THE MESSAGE
+        AND     AL,7FH          ;SEE IF END OF MESSAGE
+        JZ      WRMRET
+        MOV     BX,7
+        MOV     AH,14           ;WRITE CHARACTER
+        INT     10H             ;SEND THE CHARACTER
+        JMP     SHORT WRMSG
+WRMRET: RET
+.xlist
+        INCLUDE BUGCODE.INC
+.list
+Code    ENDS
+SUBTTL  Diskette driver -- now used only for bootup
+;-----------------------------------------------------------------
+;
+;       DISK INTERFACE ROUTINES
+;
+BiosInit        SEGMENT PARA PUBLIC     'CODE'
+DRVMAX  DB        4
+    ASSUME      CS:BiosSeg
+MAXERR  =       5
+LSTDRV  =       504H
+WRTVERIFY LABEL WORD
+RFLAG   DB      2       ;2 for read, 3 for write
+VERIFY  DB      0       ;1 if verify after write
+SINGLE  DB      0       ;1 if single drive system
+SWPFLG  DB      0       ;1 if BIOS swapped out
+SECCNT  DW      0
+HARDNUM DB      99      ;logical drive number of first hardfile
+RESSEC  =       3
+DRVLIM  =       8       ;Number of sectors on device
+SECLIM  =       13      ;MAXIMUM SECTOR
+HDLIM   =       15      ;MAXIMUM HEAD
+HIDSEC  =       17      ;NUMBER OF HIDDEN SECTORS
+;WARNING - preserve order of drive and curhd! -c.p.
+DRIVE   DB      0       ;PHYSICAL DRIVE CODE
+CURHD   DB      0       ;CURRENT HEAD
+CURSEC  DB      0       ;CURRENT SECTOR
+CURTRK  DW      0       ;CURRENT TRACK
+ERRIN:  ;DISK ERRORS RETURNED FROM THE IBM ROM
+        DB      80H             ;NO RESPONSE
+        DB      40H             ;Seek failure
+        DB      10H             ;BAD CRC
+        DB      8               ;DMA OVERRUN
+        DB      4               ;SECTOR NOT FOUND
+        DB      3               ;WRITE ATTEMPT TO WRITE-PROTECT DISK
+LSTERR  DB      0               ;ALL OTHER ERRORS
+ERROUT: ;RETURNED ERROR CODES CORRESPONDING TO ABOVE
+        DB      2               ;NO RESPONSE
+        DB      6               ;SEEK FAILURE
+        DB      4               ;BAD CRC
+        DB      4               ;DMA OVERRUN
+        DB      8               ;SECTOR NOT FOUND
+        DB      0               ;WRITE ATTEMPT ON WRITE-PROTECT DISK
+        DB      12              ;GENERAL ERROR
+NUMERR= ERROUT-ERRIN
+;---------------------------------------------------------------------
+SPSAV   DW      0       ;SAVE THE STACK POINTER
+;
+GETBP:  PUSH    AX
+        PUSH    CX
+        PUSH    DX
+        PUSH    BX
+        MOV     CL,AH           ;SAVE MEDIA
+        AND     CL,0F8H         ;NORMALIZE
+        CMP     CL,0F8H         ;COMPARE WITH GOOD MEDIA BYTE
+        JZ      GOODID
+        MOV     AH,0FEH         ;DEFAULT TO 8-SECTOR, SINGLE-SIDED
+GOODID: MOV     DI,OFFSET CS:HDRIVE
+        CMP     AL,[HARDNUM]
+        JZ      GETRET
+        JB      GETBP1
+        MOV     DI,OFFSET CS:DRIVEX
+        JMP     SHORT GETRET
+GETBP1: MOV     AL,1            ;SET NUMBER OF FAT SECTORS
+        MOV     BX,64*256+8     ;SET DIR ENTRIES AND SECTOR MAX
+        MOV     CX,40*8         ;SET SIZE OF DRIVE
+        MOV     DX,01*256+1     ;SET HEAD LIMIT AND SEC/ALL UNIT
+        MOV     DI,OFFSET CS:FDRIVE
+        TEST    AH,00000010B    ;TEST FOR 8 OR 9 SECTOR
+        JNZ     HAS8            ;NZ = HAS 8 SECTORS
+        INC     AL              ;INC NUMBER OF FAT SECTORS
+        INC     BL              ;INC SECTOR MAX
+        ADD     CX,40           ;INCREASE SIZE
+HAS8:   TEST    AH,00000001B    ;TEST FOR 1 OR 2 HEADS
+        JZ      HAS1            ;Z = 1 HEAD
+        ADD     CX,CX           ;DOUBLE SIZE OF DISK
+        MOV     BH,112          ;INCREASE NUMBER OF DIRECTORY ENTRIES
+        INC     DH              ;INC SEC/ALL UNIT
+        INC     DL              ;INC HEAD LIMIT
+HAS1:   MOV     CS:[DI].2,DH
+        MOV     CS:[DI].6,BH
+        MOV     CS:[DI].8,CX
+        MOV     CS:[DI].10,AH
+        MOV     CS:[DI].11,AL
+        MOV     CS:[DI].13,BL
+        MOV     CS:[DI].15,DL
+GETRET: POP     BX
+RET88:  POP     DX
+        POP     CX
+        POP     AX
+        RET
+;*********************************************************************
+;       "FDRIVE" IS A FLOPPY DISK, VARIOUS PARAMETERS ARE PATCHED
+;       BY GETBP TO REFLECT THE TYPE OF MEDIA INSERTED
+FDRIVE:
+        DW      512             ;Physical sector size in bytes
+        DB      1               ;Sectors/allocation unit
+        DW      1               ;Reserved sectors for DOS
+        DB      2               ;No. allocation tables
+        DW      64              ;Number directory entries
+        DW      9*40            ;Number sectors (at 512 bytes ea.)
+        DB      11111100B       ;Media descriptor
+        DW      2               ;Number of FAT sectors
+        DW      9               ;Sector limit
+        DW      1               ;Head limit
+        DW      0               ;Hidden sector count
+;------------------------------------------------------------
+;
+;       DISK I/O HANDLER
+;
+;       AL = DRIVE NUMBER (0-3)
+;       AH = MEDIA DESCRIPTOR
+;       CX = SECTOR COUNT
+;       DX = FIRST SECTOR
+;       ES:DI = TRANSFER ADDRESS
+;       [RFLAG]=OPERATION (2=READ, 3=WRITE)
+;       [VERIFY]=1 FOR VERIFY AFTER WRITE
+;
+;       IF SUCCESSFUL CARRY FLAG = 0
+;         ELSE CF=1 AND AL CONTAINS ERROR CODE
+;
+DISKRD:
+        debug   1,4,<DISKRD: $x $x $x $x:$x\n>,<ax,cx,dx,es,di>
+        MOV     [RFLAG],2
+DISKIO:
+        CLC
+        JCXZ    IORET
+        MOV     [TIM_DRV],AL            ;SAVE DRIVE LETTER
+        MOV     [SPSAV],SP              ;SAVE SP
+        XCHG    BX,DI                   ;ES:BX = TRANSFER ADDRESS
+        CALL    GETBP                   ;CS:DI = PTR TO B.P.B
+        MOV     SI,DX
+        ADD     SI,CX
+        ADD     DX,CS:[DI].HIDSEC       ;ADD IN THE HIDDEN SECTORS
+        CMP     SI,CS:[DI].DRVLIM       ;COMPARE AGAINST DRIVE MAX
+        JBE     INRANGE
+        MOV     AL,8
+STCRET: STC
+IORET:  RET
+INRANGE:CMP     AL,[HARDNUM]
+        JB      NOTHARD
+        MOV     AL,CS:[HARDDRV] ;SET DRIVE NUMBER OF HARDFILE
+        JZ      RDWR
+        INC     AL
+        JMP     SHORT RDWR
+NOTHARD:CMP     [SINGLE],1      ;SINGLE FLOPPY INSTALLED?
+        JNZ     RDWR
+        CALL    SWPDSK          ;ASK USER FOR CORRECT DISK
+RDWR:
+        MOV     [DRIVE],AL
+        MOV     [SECCNT],CX     ;SAVE SECTOR COUNT
+        XCHG    AX,DX           ;SETUP LOGICAL SECTOR FOR DIVIDE
+        XOR     DX,DX
+        DIV     WORD PTR CS:[DI].SECLIM ;DIVIDE BY SEC PER TRACK
+        INC     DL
+        MOV     [CURSEC],DL               ;SAVE CURRENT SECTOR
+        MOV     CX,CS:[DI].HDLIM        ;GET NUMBER OF HEADS
+        XOR     DX,DX           ;DIVIDE TRACKS BY HEADS PER CYLINDER
+        DIV     CX
+        MOV     [CURHD],DL      ;SAVE CURRENT HEAD
+        MOV     [CURTRK],AX     ;SAVE CURRENT TRACK
+        debug   1,4,< Drv $b  Hd $b  Trk $x  Sec $b\n>,<<word ptr DRIVE>,<word ptr CURHD>,CURTRK,<word ptr CURSEC>>
+        MOV     AX,[SECCNT]
+        MOV     SI,ES           ;Check for 64k boundary error
+        SHL     SI,1
+        SHL     SI,1
+        SHL     SI,1
+        SHL     SI,1            ;Segment converted to absolute address
+        ADD     SI,BX           ;Combine with offset
+        ADD     SI,511          ;Add sector size and see if overflow
+        JC      BUFIO           ;Must handle special if so
+        XCHG    BX,SI
+        SHR     BH,1
+        MOV     AH,128          ;Max. sectors in 64K
+        SUB     AH,BH           ;Number of sectors left in this 64K
+        XCHG    BX,SI
+        CMP     AH,AL           ;Does it exceed total request?
+        JBE     FIRBLK
+        MOV     AH,AL           ;If so, limit transfer to the request
+FIRBLK:
+;At this point, AL=total number of sectors to be read, AH=number
+;  of sectors that can be read before 64K boundary error. AH<=AL.
+;    ES:BX points to load area, DS:DI points to B.P.B
+        PUSH    AX
+        MOV     AL,AH           ;No. of sectors to read at once (<>0)
+        CALL    BLOCK           ;Transfer portion before boundary
+        POP     AX
+        SUB     AL,AH
+        JZ      DONE
+BUFIO:
+        PUSH    AX
+        PUSH    ES
+        PUSH    BX              ;SAVE CURRENT TRANSFER ADDRESS
+        CALL    SWAP            ;SWAP BUFFER WITH BIOS CODE
+        ADD     BH,2            ;POINT TO TEMP BUFFER
+        CALL    DISK1           ;Perform disk operation
+        POP     BX              ;RECALL TRANSFER ADDRESS
+        POP     ES
+        POP     AX
+        CALL    SWAP            ;SWAP BACK
+        DEC     AL              ;Dec sectors to read by 1
+        ADD     BH,2            ;Add 200H to transfer address
+        CALL    BLOCK           ;Read the remaining sectors
+DONE:
+        debug   1,4,< DISKIO DONE\n>
+        CLC                     ;No error
+        RET                     ;From subroutine DISKIO
+;       Swap 512 bytes of BIOS with transfer address
+SWAP:   PUSH    DI
+        PUSH    BX
+        PUSH    AX
+        MOV     DI,BX           ;ES:DI POINTS TO USER BUFFER
+        ADD     BH,2
+        MOV     SI,BX           ;ES:SI POINTS TO TEMP BUFFER
+        CLD
+        debug   1,4,< SWAP $x:$x <==> $x:$x\n>,<es,di,es,si>
+        MOV     CX,256                  ;256 WORDS TO SWAP
+SWAP1:  MOV     BX,WORD PTR ES:[DI]     ;GET USER WORD
+        MOV     AX,WORD PTR ES:[SI]     ;GET SCRATCH WORD
+        MOV     WORD PTR ES:[SI],BX     ;PUT SCRATCH WORD
+        STOSW                           ;PUT BIOS WORD
+        INC     SI
+        INC     SI
+        LOOP    SWAP1
+        XOR     [SWPFLG],1              ;TOGGLE SWAPPED FLAG
+        POP     AX
+        POP     BX
+        POP     DI
+RETZ:   RET
+;Read the number of sectors specified in AL, handling track boundaries
+BLOCK:  OR      AL,AL           ;See if any sectors to read
+        JZ      RETZ
+        MOV     AH,CS:[DI].SECLIM       ;Sectors per track
+        INC     AH
+        SUB     AH,[CURSEC]     ;Number of sectors left on this track
+        CMP     AH,AL           ;Compare with no. of sectors needed
+        JBE     DOIO
+        MOV     AH,AL           ;Limit to only those requested
+DOIO:
+        PUSH    AX
+        MOV     AL,AH           ;Put count where ROM needs it
+        CALL    DISK            ;Call ROM and trap errors
+        POP     AX
+        SUB     AL,AH           ;Reduce request by amount just done
+        SHL     AH,1            ;AH * 2^8 = no. of bytes
+        ADD     BH,AH           ;Bump address pointer
+        JMP     BLOCK
+;Perform disk I/O with retries
+; AL = number of sectors (1-8, all on one track)
+; ES:BX = Transfer address (must not cross a 64K physical boundary)
+; [RFLAG] = 2 if read, 3 if write
+; [VERIFY] = 0 for normal, 1 for verify after write
+DISK1:  MOV     AL,1            ;Only one sector for buffered I/O
+DISK:   MOV     SI,MAXERR
+        MOV     AH,RFLAG        ;Get read/write indicator
+RETRY:  PUSH    AX
+CALLROM:MOV     DX,[CURTRK]     ;Load current cylinder
+        MOV     CL,6            ;move high bits of cyl to sec
+        SHL     DH,CL
+        OR      DH,[CURSEC]
+        MOV     CX,DX
+        XCHG    CH,CL                    ;CL = sector, CH = cylinder
+        MOV     DX,WORD PTR [DRIVE]      ;Load physical drive number
+                                         ;and current head number
+;;      debug   1,4,< CALLROM $x $x $x $x  $x\n>,<ax,bx,cx,dx,es>
+        INT     13H                      ;Request disk read/write
+        JC      DSKERR
+        POP     AX              ;Restore sector count
+        PUSH    AX
+        CMP     WRTVERIFY,103H  ;Check for write and verify
+        JNZ     NOVERIFY
+        MOV     AH,4            ;Request verify
+        INT     13H
+        JC      DSKERR
+NOVERIFY:
+;;      debug   1,4,< back from ROM\n>,<>
+        POP     AX
+        AND     CL,03FH         ;Eliminate cylinder bits from sector
+        XOR     AH,AH
+        SUB     [SECCNT],AX     ;Reduce count of sectors to go
+        ADD     CL,AL           ;Next sector
+        MOV     [CURSEC],CL
+        CMP     CL,CS:[DI].SECLIM       ; Reached limit?
+        JBE     RET1
+        MOV     [CURSEC],1      ;Start with first sector of next track
+        MOV     DH,[CURHD]
+        INC     DH
+        CMP     DH,CS:[DI].HDLIM
+        JB      NOXOR
+        XOR     DH,DH
+        INC     [CURTRK]        ;NEXT TRACK
+NOXOR:  MOV     [CURHD],DH
+RET1:   RET
+DSKERR:
+        debug   1,4,< DSKERR $x >,<ax>
+        PUSH    AX              ;Save error code
+        MOV     AH,0            ;Ask for disk reset
+        INT     13H
+        POP     AX              ;Restore error code
+        DEC     SI              ;decrement retry count
+        JZ      HARDERR
+        CMP     AH,80H          ;Timeout?
+        JZ      HARDERR         ;***
+DSKERR1:POP     AX              ;Restore sector count
+        JMP     RETRY
+HARDERR:
+        CMP     [SWPFLG],0      ;If BIOS swapped out
+        JZ      HARD1
+        POP     BX              ;Get disk1 return address
+        POP     BX              ;Get low part of transfer address
+        POP     ES              ;Get high part of transfer address
+        CALL    SWAP            ;swap it back in
+HARD1:  PUSH    CS
+        POP     ES              ;Make ES the local segment
+        MOV     AL,AH           ;Put error code in AL
+        MOV     [LSTERR],AL     ;Terminate list with error code
+        MOV     CX,NUMERR       ;Number of possible error conditions
+        MOV     DI,OFFSET CS:ERRIN ;Point to error conditions
+        REPNE   SCASB
+        MOV     AL,es:NUMERR-1[DI] ;Get translation
+        MOV     CX,SECCNT       ;Get count of sectors to go
+        MOV     SP,[SPSAV]      ;Recover entry stack pointer
+        STC                     ;Flag error condition
+        RET                     ;and return
+INITAB  DW      FDRIVE
+        DW      FDRIVE
+        DW      FDRIVE
+        DW      FDRIVE
+INITABH DW      HDRIVE
+        DW      DRIVEX
+RomData SEGMENT AT 040H
+        ORG     03EH
+Seek_Status     DB      1 DUP(?)
+RomData ENDS
+;-------------------------------------------------
+;
+;  ASK TO SWAP THE DISK IN DRIVE A:
+;
+SWPDSK: PUSH    DS
+        XOR     SI,SI           ;Select segment 0
+        MOV     DS,SI
+        MOV     AH,AL                   ;Make copy of drive number
+        XCHG    AH,DS:LSTDRV            ;Xchange with last drive used
+        CMP     AL,AH           ;See if same as last drive
+        JZ      RDWR0
+;Using a different drive in a one drive system so request the user change disks
+        ADD     AL,"A"          ;Add "A" to convert to drive letter
+        MOV     CS:DRVLET,AL
+        push    cs
+        pop     ds
+        MOV     SI,OFFSET CS:SNGMSG
+        PUSH    BX
+        CALL    WRMSG           ;Print disk change message
+        XOR     AH,AH
+        INT     16H             ;Wait for a keyboard character
+        POP     BX
+RDWR0:
+        POP     DS
+        XOR     AL,AL           ;Always use drive 0
+        RET
+SNGMSG  DB      CR,LF,"Insert diskette for drive "
+DRVLET  DB      "A: and strike",CR,LF,"any key when ready",CR,LF,LF,0
+HNUM    DB      0               ;NUMBER OF HARDFILES
+;**     End of Permanently Resident BIOS
+HARDDRV DB      80H     ;Physical drive number of first hardfile
+;**********************************************************************
+;       "HDRIVE" IS A HARD DISK WITH 512 BYTE SECTORS
+;*********************************************************************
+HDRIVE:
+        DW      512
+        DB      1               ;Sectors/allocation unit
+        DW      1               ;Reserved sectors for DOS
+        DB      2               ;No. of allocation tables
+        DW      16              ;Number of directory entries
+        DW      0000            ;Number of sectors (at 512 bytes each)
+        DB      11111000B       ;Media descriptor
+        DW      1               ;Number of FAT sectors
+        DW      00              ;Sector limit
+        DW      00              ;Head limit
+        DW      00              ;Hidden sector count
+;**********************************************************************
+;       "DRIVEX " IS AN EXTRA TYPE OF DRIVE USUALLY RESERVED FOR AN
+;       ADDITIONAL HARD FILE
+;*********************************************************************
+DRIVEX:
+        DW      512
+        DB      00              ;Sectors/allocation unit
+        DW      1               ;Reserved sectors for DOS
+        DB      2               ;No. of allocation tables
+        DW      0000            ;Number of directory entries
+        DW      0000            ;Number of sectors (at 512 bytes each)
+        DB      11111000B       ;Media descriptor
+        DW      0000            ;Number of FAT sectors
+        DW      00              ;Sector limit
+        DW      00              ;Head limit
+        DW      00              ;Hidden sector count
+SUBTTL  Bios initialization
+;*********************************************************
+;       SYSTEM INITIALIZATION
+;
+;       THE ENTRY CONDITIONS ARE ESTABLISHED BY THE BOOTSTRAP
+;       LOADER AND ARE CONSIDERED UNKNOWN. THE FOLLOWING JOBS
+;       WILL BE PERFORMED BY THIS MODULE:
+;
+;       1.      ALL DEVICE INITIALIZATION IS PERFORMED
+;       2.      A LOCAL STACK IS SET UP AND DS:SI ARE SET
+;               TO POINT TO AN INITIALIZATION TABLE. THEN
+;               AN INTER-SEGMENT CALL IS MADE TO THE FIRST
+;               BYTE OF THE DOS
+;       3.      ONCE THE DOS RETURNS FROM THIS CALL THE DS
+;               REGISTER HAS BEEN SET UP TO POINT TO THE START
+;               OF FREE MEMORY. THE INITIALIZATION WILL THEN
+;               LOAD THE COMMAND PROGRAM INTO THIS AREA
+;               BEGINNING AT 100 HEX AND TRANSFER CONTROL TO
+;               THIS PROGRAM.
+;
+;********************************************************
+DRVFAT  DW      0000            ;DRIVE AND FAT ID OF DOS
+BIOS$   DW      0000            ;FIRST SECTOR OF DATA
+DOSCNT  DW      0000            ;HOW MANY SECTORS TO READ
+BootBufr        EQU     17C0H   ; High memory scratch area
+    ASSUME      DS:NOTHING,ES:NOTHING
+INIT:   mov     dx,1000h
+        MOV     SS,DX
+        MOV     SP,7C00h        ;LOCAL STACK  1000:7C00
+        STI
+        PUSH    CX              ;Save number of floppies
+        MOV     [BIOS$],BX
+        PUSH    AX              ;Save Drive info
+        MOV     AL,EOI
+        OUT     AKPORT,AL       ;TURN ON THE TIMER
+        MOV     SI,OFFSET LPT3DEV
+        CALL    PRINT_INIT              ;INIT LPT3
+        MOV     SI,OFFSET LPT2DEV
+        CALL    PRINT_INIT              ;INIT LPT2
+        MOV     SI,OFFSET LPT1DEV
+        CALL    PRINT_INIT              ;INIT LPT1
+        MOV     SI,OFFSET COM2DEV
+        CALL    AUX_INIT                ;INIT COM2
+        MOV     SI,OFFSET COM1DEV
+        CALL    AUX_INIT                ;INIT COM1
+;*      Can't do any DEBUG prints till now
+        debug   1,1,<AUX and PRN devices initialized\n>,<>
+        XOR     DX,DX
+        MOV     DS,DX                   ;TO INITIALIZE PRINT SCREEN VECTOR
+        MOV     ES,DX
+        MOV     AX,CS                                   ;FETCH SEGMENT
+IF      CONSFLAG
+        MOV     WORD PTR DS:BRKADR,OFFSET BREAK
+        MOV     DS:BRKADR+2,AX                  ;VECTOR FOR BREAK
+        MOV     WORD PTR DS:(CHROUT*4),OFFSET OUTCHR
+        MOV     DS:(CHROUT*4+2),AX
+ENDIF
+        MOV     WORD PTR DS:DSKADR,SEC9         ;DISK PARAMETERS
+        MOV     DS:DSKADR+2,ES
+        MOV     DI,4
+        MOV     BX,OFFSET INTRET                ; Rest just return
+        XCHG    AX,BX
+        STOSW                                           ;Location 4
+        XCHG    AX,BX
+        STOSW                           ;INT 1          ;Location 6
+        ADD     DI,4
+        XCHG    AX,BX
+        STOSW                                           ;Location 12
+        XCHG    AX,BX
+        STOSW                           ;INT 3          ;Location 14
+        XCHG    AX,BX
+        STOSW                                           ;Location 16
+        XCHG    AX,BX
+        STOSW                           ;INT 4          ;Location 18
+; Set up some vectors for scheduler and change rom interrupts
+;
+        CLI                             ; Disable, changing int vectors
+        ADD     DI,3*4                  ; Move up to INT 8
+        MOV     CX,OFFSET TimerInterrupt
+        XCHG    AX,CX
+        STOSW
+        XCHG    AX,CX
+        STOSW                           ; Set new INT 8: Timer
+IF      CONSFLAG
+        MOV     CX,DS:[DI]              ; Save old addr to hook to
+        MOV     WORD PTR OldKeyInterrupt,CX
+        MOV     CX,DS:2[DI]
+        MOV     WORD PTR (OldKeyInterrupt+2),CX
+        MOV     CX,OFFSET KeyboardInterrupt
+        XCHG    AX,CX
+        STOSW
+        XCHG    AX,CX
+        STOSW                           ; Set new keyboard interrupt
+ELSE
+        ADD     DI,4
+ENDIF
+        XCHG    AX,BX
+        STOSW
+        XCHG    AX,BX                   ; INT 0A unused
+        STOSW
+        XCHG    AX,BX
+        STOSW
+        XCHG    AX,BX                   ; INT 0B unused
+        STOSW
+        add     di,4*6                  ; skip 0C - 11
+        MOV     CX,DS:[DI]              ; Save INT 12 addr to hook to
+        MOV     WORD PTR memsizint,CX
+        MOV     CX,DS:2[DI]
+        MOV     WORD PTR (memsizint+2),CX
+        mov     cx,offset memsizhandler
+        xchg    ax,cx
+        stosw
+        xchg    ax,cx
+        stosw
+        add     di,4*2                  ; skip 13 - 14
+        STI
+; End of new 3.0 vectors
+        XCHG    AX,BX
+        STOSW                           ;INT 15         ;Location 60
+        XCHG    AX,BX
+        STOSW                                           ;Location 62
+IF      CONSFLAG
+        MOV     CX,DS:[DI]              ; Save INT 16 addr to hook to
+        MOV     WORD PTR OldKbdHandler,CX
+        MOV     CX,DS:2[DI]
+        MOV     WORD PTR (OldKbdHandler+2),CX
+        MOV     CX,OFFSET KeyboardHandler
+        XCHG    AX,CX
+        STOSW
+        XCHG    AX,CX                   ; Set new keyboard Handler
+        STOSW
+; Set new get/set time vector, time base changed
+        ADD     DI,4*3                  ; skip 17 - 19
+ELSE
+        ADD     DI,4*4                  ; skip 16 - 19
+ENDIF   ;CONSFLAG
+        MOV     CX,OFFSET TimeOfDay
+        XCHG    AX,CX
+        STOSW                           ; setup 1A to TimeofDay
+        XCHG    AX,CX
+        STOSW
+        ADD     DI,4*23                 ; skip 1B - 31
+        XCHG    AX,BX
+        STOSW                           ; no-op INT 32 until Sched:SchedInit
+        XCHG    AX,BX
+        STOSW
+        debug   1,1,<Interrupt vectors initialized\n>,<>
+        MOV     DS:WORD PTR 500H,DX     ;SET PRINT SCREEN & BREAK =0
+        MOV     DS:WORD PTR LSTDRV,DX   ;clean out last drive spec
+        MOV     DI,SEC9                 ;location of drive table
+        MOV     AX,02DFH                ;Stuff the disk speedup/9 sector
+        STOSW                                   ;code
+        MOV     AX,0225H
+        STOSW
+        MOV     AX,2A09H
+        STOSW
+        MOV     AX,50FFH
+        STOSW
+        MOV     AX,00F6H
+        STOSW
+        MOV     AL,2
+        STOSB
+        pushf                           ;simulate int 12h
+        call    memsizint               ;Get memory size--1K blocks in AX
+        MOV     CL,6
+        SHL     AX,CL                   ;Convert to 16-byte blocks(segment no.)
+        POP     CX                      ;Recall drive info
+        MOV     [DRVFAT],CX             ;SAVE DRIVE TO LOAD DOS
+        MOV     DX,SEG SYSINIT
+        MOV     DS,DX
+    ASSUME      DS:SEG SYSINIT
+        MOV     MEMORY_SIZE,AX
+        INC     CL
+        MOV     DEFAULT_DRIVE,CL         ;SAVE DEFAULT DRIVE SPEC
+        add     dx,SYSIZE
+        MOV     CURRENT_DOS_LOCATION,dx                 ; load address of DOS
+        MOV     FINAL_DOS_LOCATION,SEG BiosInit
+        debug   1,2,<DOS will load at $x, will move to $x\n>,<dx,FINAL_DOS_LOCATION>
+        MOV     WORD PTR DEVICE_LIST,OFFSET CONDEV        ;DS:SI = ptr to device list
+        MOV     AX,CS
+        MOV     WORD PTR DEVICE_LIST+2,AX
+;**************************************************************
+;       WILL INITIALIZE THE NUMBER OF DRIVES
+;       AFTER THE EQUIPMENT CALL (INT 11H) BITS 6&7 WILL TELL
+;       THE INDICATIONS ARE AS FOLLOWS:
+;
+;       BITS    7       6       DRIVES
+;               0       0       1
+;               0       1       2
+;               1       0       3
+;               1       1       4
+;**************************************************************
+        PUSH    CS
+        PUSH    CS
+        POP     DS
+        POP     ES
+    ASSUME      DS:BiosSeg,ES:BiosSeg
+        INT     11H                     ;GET EQUIPMENT STATUS
+        AND     AL,11000000B    ;MASK DRIVE BITS
+        JNZ     NOTSNGL         ;Zero means single drive system
+        INC     [SINGLE]        ;REMEMBER THIS
+NOTSNGL:
+        POP     AX                      ;BOOT specifies number of floppies
+        MOV     [HARDNUM],AL    ;Remember which drive is hard disk
+        MOV     [DRVMAX],AL     ;And set initial number of drives
+        MOV     AH,8
+        MOV     DL,80H
+        INT     13H             ;Request number of hardfiles attached
+        JC      ENDDRV          ;Carry indicates old rom, so no hardfile
+        MOV     [HNUM],DL
+ENDDRV:
+        MOV     DL,80H
+        MOV     DI,OFFSET CS:HDRIVE
+        CMP     [HNUM],0
+        JLE     ITSOK1
+        CALL    SETHRD          ;SET UP FIRST HARDFILE
+        MOV     DL,81H          ;SET UP FOR NEXT CALL
+        MOV     DI,OFFSET CS:DRIVEX
+        JC      NOTOK
+        CMP     [HNUM],2
+        JZ      SETIT
+        JMP     SHORT ITSOK
+NOTOK:  MOV     [HARDDRV],DL
+        MOV     DI,OFFSET CS:HDRIVE
+        DEC     [HNUM]
+        CMP     [HNUM],0
+        JZ      ITSOK1
+SETIT:  CALL    SETHRD          ;SET UP SECOND HARDFILE
+        JNC     ITSOK
+        DEC     [HNUM]
+; End of drive initialization
+ITSOK:  MOV     AL,[HNUM]
+        OR      AL,AL
+        JZ      ITSOK1
+        ADD     AL,[HARDNUM]
+        MOV     [DRVMAX],AL
+        MOV     AL,[HNUM]
+        JMP     SHORT ITSOK2            ;GO SET DESTINATION SEGMENT
+ITSOK1: CMP     BYTE PTR [SINGLE],1
+        JMP     SHORT GOINIT
+    ASSUME      DS:BiosSeg
+ITSOK2:
+        DEC     AL
+GOINIT:
+        debug   1,1,<hardnum/hnum  $x  drvfat $x\n>,<<word ptr hnum>,drvfat>
+        PUSH    CS
+        POP     DS
+    ASSUME      DS:BiosSeg,ES:NOTHING
+        CALL    GETFAT          ;READ IN THE FAT SECTOR
+        XOR     DI,DI
+        MOV     AL,ES:[DI]              ;GET FAT ID BYTE
+        MOV     BYTE PTR DRVFAT+1,AL    ;SAVE FAT BYTE
+        debug   1,2,< FAT ID: $b ds:$x\n>,<ax,ds>
+        MOV     AX,[DRVFAT]
+        CALL    GETBP                   ;GET DISK POINTER
+        MOV     CL,[DI+2]               ;GET SECTORS/CLUSTER
+        MOV     AX,[DI].HIDSEC          ;GET NUMBER OF HIDDEN SECTORS
+        SUB     [BIOS$],AX              ;SUBTRACT HIDDEN SECTOR OFFSET
+        XOR     CH,CH                   ;CX = SECTORS/CLUSTER
+        PUSH    DS
+        XOR     DI,DI
+        MOV     DS,DI
+;
+;       THE BOOT PROGRAM HAS LEFT THE DIRECTORY AT 0:500
+;
+        MOV     BX,DS:WORD PTR 53AH     ;GET FIRST CLUSTER OF DOS
+        POP     DS                      ;BX = FIRST CLUSTER OF DOS
+LOADIT: MOV     AX,SEG SYSINIT
+        add     ax,SYSIZE
+        MOV     ES,AX                   ;ES:DI POINTS TO LOAD LOCATION
+        CALL    GETCLUS                 ;READ IN A CLUSTER
+        CMP     BX,0FFFH
+        JNZ     LOADIT                  ;END OF FILE?
+        EXTRN   Disk_Init:NEAR
+        call    Disk_Init               ; do some device driver initialization
+        debug   1,2,<System loaded, going to sysinit\n>,<>
+        JMP     SYSINIT
+SUBTTL  Routines for reading in MSDOS
+;
+;       READ A FAT SECTOR INTO 17C0:0
+;
+GETFAT: debug   1,2,<GETFAT.>,<>
+        XOR     DI,DI
+        MOV     CX,1
+        MOV     DX,CX
+        MOV     AX,BootBufr
+        MOV     ES,AX
+        MOV     AL,BYTE PTR DRVFAT
+        MOV     AH,0FCH
+        JMP     DISKRD
+;
+;       READ A BOOT RECORD INTO 17C0:0
+;
+GETBOOT:debug   1,2,<GETBOOT.>,<>
+        MOV     CX,1
+        MOV     AX,0201H
+        MOV     BX,BootBufr
+        MOV     ES,BX
+        XOR     BX,BX
+        MOV     DH,BH
+        INT     13H
+        JC      SETRET
+        CMP     WORD PTR ES:[1FEH],0AA55H
+        JNZ     SETRET
+        RET
+;
+;       SETUP VARIABLE SIZED HARDFILE
+;       ON ENTRY DL=DRIVE NUMBER (80 OR 81)
+;                DI=PTR TO B.P.B
+;
+SETHRD: PUSH    DX
+        MOV     AH,8            ;GET DRIVE PARAMETERS
+        INT     13H
+        INC     DH
+        MOV     [DI].HDLIM,DH
+        POP     DX
+        JC      SETRET
+        AND     CL,3FH
+        MOV     [DI].SECLIM,CL
+        CALL    GETBOOT         ;GET THE BOOT RECORD
+        JC      SETRET
+        MOV     BX,1C2H
+SET1:   CMP     BYTE PTR ES:[BX],1
+        JZ      SET2
+        ADD     BX,16
+        CMP     BX,202H
+        JNZ     SET1
+SETRET: STC                     ;NOT FOUND SO USE DEFAULTS
+        RET
+SET2:   MOV     AX,ES:[BX+4]
+        MOV     DS:[DI].HIDSEC,AX       ;SET HIDDEN SECTOR COUNT
+        MOV     AX,ES:[BX+8]
+        CMP     AX,64                   ;HAS TO BE AT LEAST 32K
+        JB      SETRET
+        MOV     DS:[DI].8,AX            ;SAVE LOGICAL SECTOR COUNT
+        MOV     CX,0100H                ;SET CLUS SIZE AND SHIFT COUNT
+        MOV     DX,64                   ;SET NUMBER OF DIR ENTRIES
+        CMP     AX,512
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        MOV     DX,112
+        CMP     AX,2048
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        MOV     DX,256
+        CMP     AX,8192
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        ADD     DX,DX
+        CMP     AX,32680        ;NOT 32768! MAX NUMBER OF CLUSTERS=4085
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        ADD     DX,DX
+SET3:
+;
+;       DX=NUMBER OF DIR ENTRIES, CH=NUMBER OF SECTORS PER CLUSTER
+;                                 CL=LOG BASE 2 OF CH
+;
+;       NOW CALCULATE SIZE OF FAT TABLE
+;
+        MOV     [DI].6,DX               ;SAVE NUMBER OF DIR ENTRIES
+        MOV     [DI].2,CH               ;SAVE SECTORS PER CLUSTER
+        XOR     BX,BX
+        MOV     BL,CH
+        DEC     BX
+        ADD     BX,AX
+        SHR     BX,CL                   ;DIVIDE BY SECTORS/CLUSTER
+        INC     BX
+        AND     BL,11111110B            ;MAKE SURE COUNT IS EVEN
+        MOV     SI,BX
+        SHR     BX,1
+        ADD     BX,SI                   ;MULTIPY BY 1.5
+        ADD     BX,511
+        SHR     BH,1
+        MOV     [DI].11,BH              ;SAVE NUMBER OF FAT SECTORS
+        CLC
+        RET
+;
+;  READ CLUSTER SPECIFIED IN BX
+;  CX = SECTORS PER CLUSTER
+;  DI = LOAD LOCATION
+;
+GETCLUS:debug   1,2,<GETCLUS bx $x cx $x es:di $x:$x  >,<bx,cx,es,di>
+        PUSH    CX
+        PUSH    DI
+        MOV     [DOSCNT],CX     ;SAVE NUMBER OF SECTORS TO READ
+        MOV     AX,BX
+        DEC     AX
+        DEC     AX
+        MUL     CX              ;CONVERT TO LOGICAL SECTOR
+        ADD     AX,[BIOS$]      ;ADD IN FIRST DATA SECTOR
+        MOV     DX,AX           ;DX = FIRST SECTOR TO READ
+GETCL1: CALL    UNPACK          ;SI = BX, BX = NEXT ALLOCATION UNIT
+        SUB     SI,BX
+        CMP     SI,-1           ;one apart?
+        JNZ     GETCL2
+        ADD     [DOSCNT],CX
+        JMP     GETCL1
+GETCL2: PUSH    BX
+        MOV     AX,[DRVFAT]     ;GET DRIVE AND FAT SPEC
+        MOV     CX,[DOSCNT]
+        CALL    DISKRD          ;READ THE CLUSTERS
+        POP     BX
+        POP     DI
+        MOV     AX,[DOSCNT]     ;GET NUMBER OF SECTORS READ
+        XCHG    AH,AL           ;MULTIPLY BY 256
+        SHL     AX,1            ;TIMES 2 EQUAL 512
+        ADD     DI,AX           ;UPDATE LOAD LOCATION
+        POP     CX              ;RESTORE SECTORS/CLUSTER
+        RET
+;
+;       GET THE FAT ENTRY AT BX, WHEN FINISHED SI=ENTRY BX
+;
+UNPACK: PUSH    DS
+        PUSH    BX
+        MOV     SI,BootBufr
+        MOV     DS,SI
+        MOV     SI,BX
+        SHR     SI,1
+        MOV     BX,[SI+BX]
+        JNC     HAVCLUS
+        SHR     BX,1
+        SHR     BX,1
+        SHR     BX,1
+        SHR     BX,1
+HAVCLUS:AND     BX,0FFFH
+        POP     SI
+        POP     DS
+        RET
+;
+; SI POINTS TO DEVICE HEADER
+;
+PRINT_INIT:
+        MOV     BH,1
+        MOV     DL,17H
+        JMP     SHORT DEV_INIT
+AUX_INIT:
+        MOV     BX,RSINIT
+        MOV     DL,14H
+DEV_INIT:
+        MOV     CS:[INTNUM],DL
+        MOV     AL,CS:[SI+13]   ;GET DEVICE NUMBER FROM THE NAME
+        SUB     AL,"1"
+        CBW
+        MOV     DX,AX
+        MOV     AX,BX           ;SET THE CALL
+        DB      0CDH            ;INT 17H
+INTNUM  DB      17H
+        RET
+END$:
+BiosInit        ENDS
+        END
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.OBJ b/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.OBJ
new file mode 100644
index 0000000..28d0720
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMBIO.OBJ
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.ASM b/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.ASM
new file mode 100644
index 0000000..47869d0
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.ASM
@@ -0,0 +1,2551 @@
+TITLE   DISK - MS-DOS 4.0 disk drivers for IBM
+NAME    DISK
+        PAGE    ,132
+;DEBUGFLG=1
+.xlist
+        INCLUDE DEFDBUG.INC
+.list
+; Constants
+ErrLim=         5                       ; Number of retries on error
+; Floppy delay constants
+DelayLoad=      35                      ; 35 milliseconds to load head
+; Constants for floppy disk controller
+Rate99=         000H            ; Step rate 96tpi disk in 96tpi drive
+Rate49=         001H            ; Step rate 48tpi disk in 96tpi drive
+Rate44=         002H            ; Step rate 48tpi disk in 48tpi drive
+; Commands to floppy disk controller
+FD_CRESET=      007H            ; Recalibrate drive
+FD_CSENSE=      008H            ; Sense interrupt status
+FD_CSEEK=       00FH            ; Seek to another track
+FD_CREAD=       046H            ; MFM read, skip deleted data
+FD_CWRITE=      045H            ; MFM write, skip deleted data
+FD_CSPEC=       003H            ; Special - step rate, head load/unload
+; Status codes
+FD_SDIO=        01000000B       ; Transfer direction (0 -> controller)
+FD_SRQM=        10000000B       ; Controller ready for next data
+; Hard disk controller commands
+HD_CSENS=       03H             ; request sense block
+HD_CREAD=       08H             ; read
+HD_CWRITE=      0AH             ; write
+HDcontrolbyte=  05H             ; step rate = 70 us.
+; I/O ports
+FD_PSEL=        03F2H           ; Controls drive select and motors
+FD_PDAT=        03F5H           ; Data transfer to/from controller
+FD_PSTAT=       03F4H           ; Controller status
+FD_PCMD=        03F7H           ; Controller command register
+HD_PDAT=        0320H           ; read/write data
+HD_PSTAT=       0321H           ; controller status
+HD_PSEL=        0322H           ; controller select
+HD_PMSK=        0323H           ; DMA and interrupt mask bits
+PDMA=           0               ; Base of ports for DMA control
+PDMAX=          7FH             ; Address extension regs for DMA
+                                ;NOTE base address suitable for ch. 2 & 3 only
+FD_DMA=         2               ; floppy disk DMA channel
+HD_DMA=         3               ; hard disk DMA channel
+DMA_READ=       44H             ; DMA read command
+DMA_WRITE=      48H             ; DMA write command
+; Misc
+DORmask=        00CH            ; Not reset, enable DMA & interrupt
+SUBTTL  Data for performing requests
+PAGE    +
+;*      Dos Request Packet structure
+DosPacket   STRUC
+        RqCmdLen DB     0               ; Length of this command
+        RqUnit  DB      0               ; Unit in this driver
+        RqCmd   DB      0               ; Command to do
+        RqStatus DW     0               ; Status of request
+                DD      0
+                DD      0               ; Not used
+        RqMedia DB      0               ; Media descriptor
+        RqAddr  DW      0               ; Offset of data
+                DW      0               ; Segment of data
+        RqCount DW      0               ; Number of sectors
+        RqFirst DW      0               ; First sector to do
+DosPacket       ENDS
+;       The disk drivers work as a state machine performing the various actions
+;  that make up disk I/O.
+; Driver states
+;       The following states are common to both drivers
+Start=  0                       ; Starting I/O
+Calc=   1                       ; Calculate position on disk
+Done=   7                       ; I/O is done
+Idle=   8                       ; Drive is inactive
+Error=  9                       ; Have an error
+;       The following states are used by the floppy driver only
+Select= 2                       ; Select drive, start motor, seek
+Recal=  3                       ; Drive was just recalibrated
+Seek=   4                       ; Seek just finished
+Settle= 5                       ; Head has settled
+RdWri=  6                       ; Read/write is done
+;       The following states are used by the fixed driver only
+Verify= 6                       ; Start verify portion of write
+DeviceStruc STRUC
+        State   DW      Idle            ; Current drive state
+        Current DW      -1              ; Current active drive
+        ErrCnt  DB      0               ; # of errors in doing request
+        Flags   DB      0               ; Various bit flags, see below
+        DOR     DB      0               ; Copy of select/motor reg
+; Following values are set by Setup from the request packet and are
+; updated after each transfer is completed.
+        Unit    DB      0               ; Unit
+        First   DW      0               ; 1st sector of request
+        RealAddr DD     0               ; Real addr of data when Addr is
+                                        ; scratch buffer.
+        Count   DW      0               ; Number of sectors to xfer
+; Following values are set by MapSector.
+        Cyl     DW      0               ; Cylinder
+        Sector  DB      0               ; Sector - zero based
+        Head    DB      0               ; Head
+        NumSectors DW   0               ; Number of sectors to do
+        NumBytes DW     0               ; Number of bytes
+        Addr    DD      0               ; Pointer to data buffer
+; Device dependent data
+        ST0     DB      0               ; floppy controller ST0
+        ST1     DB      0               ; floppy controller ST1
+        ST2     DB      0               ; floppy controller ST2
+        CHRN    DB      0,0,0,0         ; other floppy status returns
+DeviceStruc     ENDS
+        DCB     EQU     ST0             ; Fixed disk Device Control Block
+; Bits in Flags
+    Factive=            1               ; Actively working on something
+    F2step=             2               ; Must double step when seeking
+    Fwrite=             4               ; This is a write, not a read
+    Fverify=            8               ; This is a verify, not a rd/wr
+    Fwrap1=             010H            ; We are currently using ScratchBuffer
+    Fwrap2=             020H            ; We have used ScratchBuffer in this req
+BiosSeg GROUP   Code,BiosInit
+Code    SEGMENT BYTE PUBLIC     'CODE'
+    ASSUME      CS:BiosSeg
+IFDEF   DEBUGFLG
+        EXTRN   BUGBITS:BYTE,DPRINTF:NEAR
+ENDIF
+SUBTTL  Device data
+PAGE    +
+Floppy  DeviceStruc     <>
+Fixed   DeviceStruc     <>
+;*      Per drive information, including BPBs
+DriveStruc  STRUC
+        BPBsecsiz       DW      512     ; Physical sector size
+        BPBsecpau       DB      1       ; Sectors/Allocation unit
+        BPBressec       DW      1       ; Reserved sectors for DOS
+        BPBnfat         DB      2       ; # of allocation tables
+        BPBndir         DW      64      ; # of directory entries
+        BPBnsec         DW      9*40    ; Number of sectors
+        BPBmediab       DB      0FCH    ; Media descriptor
+        BPBnfatsec      DW      2       ; # of FAT sectors
+        BPBtrksiz       DW      9       ; # of sectors/track
+        BPBnhead        DW      1       ; # of heads
+        BPBhidsec       DW      0       ; Hidden sector count
+        Timer           DB      0       ; Countdown for motor off
+        DrvFlag         DB      1       ; Per-drive flags, see below
+        TPI             DB      0       ; Drive TPI= Not present, 48, 96
+        CurCyl          DW      -1      ; Current cylinder
+DriveStruc      ENDS
+;   DrvFlag values
+Frestor=        1                       ; restore needed
+Fmotoron=       2                       ; motor is on
+DriveA  DriveStruc      <>              ; floppy drive 0
+DriveB  DriveStruc      <>              ; floppy drive 1 or 0
+DriveC  DriveStruc      <>              ; hard drive 0 or floppy drive 2
+DriveD  DriveStruc      <>              ; hard drive 1 or floppy drive 3
+FDinfo  DW      DriveA
+        DW      DriveB
+HDinfo  DW      DriveC
+        DW      DriveD
+; Structure of parameter block for floppy pointed to by 0:4*1E
+FloppyParameter STRUC
+        Spec1   DB      0               ;  0  1st byte for specify cmd
+        Spec2   DB      0               ;  1  2nd byte for specify cmd
+        DelayOff DB     0               ;  2  # of Ticks(1/18.2) until
+                                        ;       motor shut off
+        SectorSize DB   0               ;  3  Sector size(128,256,512,1024)
+                                        ;       = (O,1,2,3 are put here)
+        CylSize DB      0               ;  4  Number of sectors/cylinder
+        DataGap DB      0               ;  5  Gap length of read/write
+        ValueDTL DB     0               ;  6  Data length (ignored)
+        FormatGap DB    0               ;  7  Gap for format operation
+        FormatFill DB   0               ;  8  Fill char for format
+        DelaySettle DB  0               ;  9  Head settle time in msec
+        DelayMotor DB   0               ; 10  Motor start time in 1/8 sec
+FloppyParameter ENDS
+ScratchBuffer   DB 512 DUP(?)   ; Scratch buffer for when DMA fails
+                                        ; Hope we don't handle >512 sector
+                                        ; size
+;*      Miscellaneous data
+Single          DB      0               ; non-zero if 1 floppy disk system
+                                        ;    in this case, NumFloppy will be 2
+SUBTTL  Data for interface to 4.0
+PAGE    +
+        EXTRN   DosFunction:DWORD       ; Addr of DOS function routine
+; Dos helper functions used by disk driver
+    PullRequest =       2               ; Pull a request from the queue
+    PushRequest =       4               ; Add a request to the queue
+    BlockProcess =      9               ; Block process until I/O done
+    ContinueProcess =  10               ; I/O done, continue process
+int_savregs=    32H                     ; interrupt routine which saves all regs
+SwapSem1        DB      0               ; non-zero if waiting to swap disks
+SwapSem2        DB      0               ; non-zero if waiting to prompt for swap
+ScratchBufSem   DB      0               ; semaphore controlling ScratchBuffer
+SEM_WANT=       2
+SEM_BUSY=       1
+SemWait Macro   wchan
+local   l1,l2
+        pushf
+l1:     cli
+        test    wchan,SEM_BUSY          ;;semaphore busy?
+        jz      l2                      ;;no
+        or      wchan,SEM_WANT          ;;say we want it
+        mov     ax,cs
+        mov     bx,OFFSET wchan
+        xor     cx,cx
+        mov     dx,BlockProcess
+        call    [DosFunction]           ;;wait till semaphore released
+        jmp     l1
+l2:     or      wchan,SEM_BUSY          ;;claim semaphore
+        popf
+        endm
+SemSig  Macro   wchan
+local   l
+        test    wchan,SEM_WANT          ;;anyone waiting on semaphore?
+        jz      l
+        mov     ax,cs
+        mov     bx,OFFSET wchan
+        mov     dx,ContinueProcess
+        call    [DosFunction]
+l:      and     wchan,NOT (SEM_WANT+SEM_BUSY)
+        endm
+FloppyQueue     DD  0                   ; List of requests for floppy
+FixedQueue      DD  0                   ; List of requests for fixed disk
+; Device driver headers
+      PUBLIC    FloppyDevice
+FloppyDevice    LABEL   WORD
+        DD      FixedDevice             ; Next device is hard disk
+        DW      100000B                 ; This is 4.0 driver
+        DW      JustReturn              ; Strategy does nothing
+        DW      FloppyRequest           ; Interrupt does the work
+NumFloppy       DB      4               ; Handle 4 floppys maximum
+        DB      0                       ; can be addressed as word also
+        EXTRN   Com1Dev:NEAR
+FixedDevice     LABEL   WORD
+        DD      Com1Dev                 ; Next device is comm port 1
+        DW      100000B                 ; This is 4.0 driver
+        DW      JustReturn              ; Strategy does nothing
+        DW      FixedRequest            ; Interrupt does work (misnomer)
+NumFixed        DB      0               ; Handle 2 hard disks maximum
+; Utility routines which reside in the BIOS main module
+        EXTRN   Interrupt:NEAR          ; BIOS interrupt routine(misnomer)
+        EXTRN   CmdErr:NEAR
+        EXTRN   StatusDevReady:NEAR
+        EXTRN   StatusComplete:NEAR
+        EXTRN   StatusError:NEAR
+        EXTRN   SetStatus:NEAR
+JustReturn      PROC    FAR
+        RET
+JustReturn      ENDP
+FloppyRequest   PROC    FAR
+        debug   4,2,<FloppyRequest, es:bx $x:$x, cmd $d\n>,<es,bx,<word ptr es:[bx.RqCmd]>>
+        PUSH    SI
+        LEA     SI,FloppyFunction       ; 4.0 function routines
+        JMP     Interrupt               ; Let BIOS figure out what to do
+FloppyRequest   ENDP
+; Dispatch table for actions of the floppy requested by 4.0
+FloppyFunction  LABEL   WORD
+        DW      FloppyInit              ;  0  Initialize
+        DW      FloppyCheck             ;  1  Check media
+        DW      FloppyBuild             ;  2  Build BPB
+        DW      CmdErr                  ;  3  IOCTL input
+        DW      FloppyRead              ;  4  Read
+        DW      StatusDevReady          ;  5  Non-destructive read
+        DW      StatusComplete          ;  6  Input status
+        DW      StatusComplete          ;  7  Input flush
+        DW      FloppyWrite             ;  8  Write
+        DW      FloppyWriteV            ;  9  Write with verify
+        DW      CmdErr                  ; 10  Output status
+        DW      CmdErr                  ; 11  Output flush
+        DW      CmdErr                  ; 12  IOCTL output
+        DW      CmdErr                  ; 13  Device open
+        DW      CmdErr                  ; 14  Device close
+        DW      CmdErr                  ; 15  Removable media
+        DW      CmdErr                  ; 16  Generic IOCTL request
+FixedRequest    PROC    FAR
+        debug   8,2,<FixedRequest, es:bx $x:$x, cmd $d\n>,<es,bx,<word ptr es:[bx.RqCmd]>>
+        PUSH    SI
+        LEA     SI,FixedFunction        ; 4.0 function routines
+        JMP     Interrupt               ; Let BIOS figure out what to do
+FixedRequest    ENDP
+; Dispatch table for actions of the hard disk requested by 4.0
+FixedFunction   LABEL   WORD
+        DW      FixedInit               ;  0  Initialize
+        DW      FixedCheck              ;  1  Check media
+        DW      FixedBuild              ;  2  Build BPB
+        DW      CmdErr                  ;  3  IOCTL input
+        DW      FixedRead               ;  4  Read
+        DW      StatusDevReady          ;  5  Non-destructive read
+        DW      StatusComplete          ;  6  Input status
+        DW      StatusComplete          ;  7  Input flush
+        DW      FixedWrite              ;  8  Write
+        DW      FixedWriteV             ;  9  Write with verify
+        DW      CmdErr                  ; 10  Output status
+        DW      CmdErr                  ; 11  Output flush
+        DW      CmdErr                  ; 12  IOCTL output
+        DW      CmdErr                  ; 13  Device open
+        DW      CmdErr                  ; 14  Device close
+        DW      CmdErr                  ; 15  Removable media
+        DW      CmdErr                  ; 16  Generic IOCTL request
+SUBTTL  Data for routines that make direct Int 13 requests
+PAGE    +
+RealInt13Vec    dw      0               ; Used to make Int 13 requests
+                dw      0
+OldIntDVec      dw      0               ; Must be reset when Int 13's on hard
+                dw      0               ;  disk.
+OldIntEVec      dw      0               ; Must be reset when Int 13's on floppy
+                dw      0               ;  disk.
+SemDiskIO       db      0               ; Semaphore controlling disk io
+SemInt13        db      0               ; Semaphore controlling Int 13's
+SUBTTL  4.0 device driver routines (system entry points)
+PAGE    +
+BiosInit        SEGMENT PARA PUBLIC     'CODE'
+    ASSUME      CS:BiosSeg
+        PUBLIC  Disk_Init
+Disk_Init       PROC
+;**************************************************************
+;       This routine performs device dependent initialization
+;       during the BIOS initialization.  Not to be confused
+;       with the device initialization entry points which are
+;       called later on and perform different functions.
+;
+;       AFTER THE EQUIPMENT CALL (INT 11H) BITS 6&7 WILL TELL
+;       THE NUMBER OF FLOPPY DISKS IN THE SYSTEM.
+;       THE INDICATIONS ARE AS FOLLOWS:
+;
+;       BITS    7       6       DRIVES
+;               0       0       1
+;               0       1       2
+;               1       0       3
+;               1       1       4
+;**************************************************************
+        debug   12,1,<Performing disk driver pre-DOS initialization\n>,<>
+        PUSH    CS
+        POP     DS
+    ASSUME      DS:BiosSeg
+        INT     11H                     ;GET EQUIPMENT STATUS
+        rol     al,1                    ; rotate around to low order bits
+        rol     al,1
+        AND     AL,11B                  ;MASK DRIVE BITS
+        JNZ     NOTSNGL         ;Zero means single drive system
+        INC     [SINGLE]        ;REMEMBER THIS
+        inc     al              ; make it look like two-drive system
+NOTSNGL:
+        inc     al
+        MOV     [NumFloppy],AL          ;Remember how many drives
+        MOV     AH,8
+        MOV     DL,80H
+        INT     13H             ;Request number of hardfiles attached
+        JC      ENDDRV          ;Carry indicates old rom, so no hardfile
+        MOV     [NumFixed],DL
+        test    dl,dl                   ; any specified?
+        jz      ENDDRV                  ; no
+        cmp     NumFloppy,2             ; too many floppies?
+        jbe     ENDDRV
+        mov     NumFloppy,2             ; limit to two floppies max.
+ENDDRV:
+;*      Initialize the hard disk BPBs
+        MOV     DL,80H
+        MOV     DI,OFFSET DriveC
+        CMP     [NumFixed],0
+        JLE     ITSOK
+        CALL    SETHRD          ;SET UP FIRST HARDFILE
+        MOV     DL,81H          ;SET UP FOR NEXT CALL
+        MOV     DI,OFFSET DriveD
+        JC      NOTOK
+        CMP     [NumFixed],2
+        JZ      SETIT
+        JMP     SHORT ITSOK
+NOTOK:
+        MOV     DI,OFFSET DriveC
+        DEC     [NumFixed]
+        CMP     [NumFixed],0
+        JZ      ITSOK
+SETIT:  CALL    SETHRD          ;SET UP SECOND HARDFILE
+        JNC     ITSOK
+        DEC     [NumFixed]
+ITSOK:
+        cmp     [NumFixed],0    ; any hard disks found?
+        jnz     itsok2          ; yes
+        mov     ax,[FixedDevice]  ; no, patch device chain to skip fixed disk
+        mov     [FloppyDevice],ax
+itsok2:
+        push    es                      ; Install Int 13 handler and save the
+        xor     ax,ax                   ;  old value of the interrupt vector.
+        mov     es,ax
+        mov     ax,es:[4*13h]
+        mov     [RealInt13Vec],ax
+        mov     ax,OFFSET Int13Handler
+        mov     es:[4*13H],ax
+        mov     ax,es:[4*13h+2]
+        mov     [RealInt13Vec+2],ax
+        mov     es:[4*13H+2],cs
+        mov     ax,es:[4*0dh]           ; Save original Int D vector
+        mov     [OldIntDVec],ax
+        mov     ax,es:[4*0dh+2]
+        mov     [OldIntDVec+2],ax
+        mov     ax,es:[4*0eh]           ; Save original Int E vector
+        mov     [OldIntEVec],ax
+        mov     ax,es:[4*0eh+2]
+        mov     [OldIntEVec+2],ax
+        pop     es
+        ret
+Disk_Init       ENDP
+;
+;       READ A BOOT RECORD INTO Scratch buffer
+;
+GETBOOT:
+        MOV     CX,1
+        MOV     AX,0201H
+        push    CS
+        pop     es
+        mov     BX,OFFSET ScratchBuffer
+        xor     DH,DH
+        INT     13H
+        JC      SETRET
+        CMP     WORD PTR ES:[BX+1FEH],0AA55H
+        JNZ     SETRET
+        RET
+;
+;       SETUP VARIABLE SIZED HARDFILE
+;       ON ENTRY DL=DRIVE NUMBER (80 OR 81)
+;               DI=PTR TO B.P.B
+;
+SETHRD: PUSH    DX
+        MOV     AH,8            ;GET DRIVE PARAMETERS
+        INT     13H
+        INC     DH
+        MOV     BYTE PTR [DI].BPBnhead,DH
+        POP     DX
+        JC      SETRET
+        AND     CL,3FH
+        MOV     BYTE PTR [DI].BPBtrksiz,CL
+        CALL    GETBOOT         ;GET THE BOOT RECORD
+        JC      SETRET
+        add     BX,1C2H
+        mov     cx,4
+SET1:   CMP     BYTE PTR ES:[BX],1
+        JZ      SET2
+        ADD     BX,16
+        loop    SET1
+SETRET: STC                     ;NOT FOUND SO USE DEFAULTS
+        debug   8,3,<Sethrd err rtn: drive $x stat $x\n>,<dx,ax>
+        RET
+SET2:   MOV     AX,ES:[BX+4]
+        MOV     DS:[DI].BPBhidsec,AX    ;SET HIDDEN SECTOR COUNT
+        MOV     AX,ES:[BX+8]
+        CMP     AX,64                   ;HAS TO BE AT LEAST 32K
+        JB      SETRET
+        MOV     DS:[DI].BPBnsec,AX      ;SAVE LOGICAL SECTOR COUNT
+        MOV     CX,0100H                ;SET CLUS SIZE AND SHIFT COUNT
+        MOV     DX,64                   ;SET NUMBER OF DIR ENTRIES
+        CMP     AX,512
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        MOV     DX,112
+        CMP     AX,2048
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        MOV     DX,256
+        CMP     AX,8192
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        ADD     DX,DX
+        CMP     AX,32680        ;NOT 32768! MAX NUMBER OF CLUSTERS=4085
+        JBE     SET3
+        ADD     CH,CH
+        INC     CL
+        ADD     DX,DX
+SET3:
+;
+;       DX=NUMBER OF DIR ENTRIES, CH=NUMBER OF SECTORS PER CLUSTER
+;                                 CL=LOG BASE 2 OF CH
+;
+;       NOW CALCULATE SIZE OF FAT TABLE
+;
+        MOV     [DI].BPBndir,DX         ;SAVE NUMBER OF DIR ENTRIES
+        MOV     [DI].BPBsecpau,CH       ;SAVE SECTORS PER CLUSTER
+        XOR     BX,BX
+        MOV     BL,CH
+        DEC     BX
+        ADD     BX,AX
+        SHR     BX,CL                   ;DIVIDE BY SECTORS/CLUSTER
+        INC     BX
+        AND     BL,11111110B            ;MAKE SURE COUNT IS EVEN
+        MOV     SI,BX
+        SHR     BX,1
+        ADD     BX,SI                   ;MULTIPY BY 1.5
+        ADD     BX,511
+        SHR     BH,1
+        MOV     BYTE PTR [DI].BPBnfatsec,BH     ;SAVE NUMBER OF FAT SECTORS
+        MOV     [DI].BPBmediab,0F8H     ; set media byte
+        CLC
+        RET
+BiosInit        ENDS
+    ASSUME      CS:BiosSeg,DS:NOTHING,ES:NOTHING
+FloppyInit      PROC
+        debug   4,3,<Diskette initialization>,<>
+        push    ds                      ; install floppy interrupt routine
+        xor     ax,ax
+        mov     ds,ax
+        mov     ax,OFFSET FloppyInterrupt
+        mov     ds:[4*0eH],ax
+        mov     ds:[4*0eH+2],cs
+        pop     ds
+        call    Rst765
+        mov     ah,[NumFloppy]
+        mov     di,OFFSET FDinfo
+DBBEG   4,3
+        jmp     SHORT iniret
+DBEND
+        jmp     bpbret
+ELSE
+        jmp     SHORT bpbret
+ENDIF
+FloppyInit      ENDP
+FixedInit       PROC
+        debug   8,3,<Hard disk initialization>,<>
+        push    ds                      ; install fixed disk interrupt routine
+        xor     ax,ax
+        mov     ds,ax
+        mov     ax,OFFSET FixedInterrupt
+        mov     ds:[4*0dH],ax
+        mov     ds:[4*0dH+2],cs
+        pop     ds
+        in      al,21H                  ; unmask fixed disk interrupts
+        and     al,0DFH
+        out     21H,al
+        mov     dx,HD_PMSK              ; set interrupt and DMA mask bits
+        mov     al,3
+        out     dx,al
+        mov     ah,[NumFixed]
+        mov     di,OFFSET HDinfo
+DBBEG   8,3
+iniret: debug   12,3,< - Num=$x BPB table=$x:$x\n>,<ax,cs,di>
+DBEND
+ENDIF
+        jmp     SHORT bpbret
+FixedInit       ENDP
+FloppyBuild     PROC
+        mov     ah,byte ptr es:[di]
+        call    FDGetBPB
+bpbret: mov     [bx.RqMedia],ah
+        mov     [bx.RqCount],di
+        mov     [bx.RqCount+2],CS
+        jmp     StatusComplete
+FloppyBuild     ENDP
+FixedBuild      PROC
+        mov     ah,byte ptr es:[di]
+        call    HDGetBPB
+        jmp     SHORT bpbret
+FixedBuild      ENDP
+;***    FloppyCheck - check to see if the disk may have been changed.
+;
+;       ENTRY   AL = unit #
+;               AH = media byte
+;       EXIT    Return value in request header set to one of:
+;                       1       Media may have been changed
+;                       0       Media not changed
+;                       -1      Media was probably changed
+;
+FloppyCheck     PROC
+        MOV     DL,1                    ; Assume not changed
+        cmp     AH,0f8H                 ; Is disk removable?
+        JE      FloppyCheckDone         ; No, can't be changed then
+        cmp     Single,0                ; single drive system?
+        je      flchk1                  ; no, check drive state
+        cmp     Floppy.Unit,al          ; unit = current drive?
+        je      flchk1                  ; yes, check drive state
+        mov     DL,-1                   ; say media changed for sure
+        jmp     FloppyCheckDone
+flchk1: MOV     CX,AX
+        XOR     CH,CH
+        MOV     SI,CX
+        ADD     SI,SI
+        MOV     SI,FDinfo[SI]           ; Get pointer to drive info
+        TEST    CS:[SI].DrvFlag,Fmotoron        ; Is motor on?
+        JNZ     FloppyCheckDone         ; Yes, media not changed then
+        XOR     DL,DL                   ; No, might have been changed
+FloppyCheckDone:
+        MOV     BYTE PTR DS:[BX].RqAddr,DL
+        JMP     StatusComplete          ; Return whether media changed
+FloppyCheck     ENDP
+FixedCheck      PROC
+        MOV     DL,1
+        JMP     FloppyCheckDone
+FixedCheck      ENDP
+;***    FloppyRead, FloppyWrite, FloppyWriteV - Basic I/O entry points
+;
+;       FloppyRead, FloppyWrite and FloppyWriteV are the basic I/O
+;       routines used by the DOS.  They really do not do much except
+;       queue the request and start the device if it is idle.
+;       For single drive floppy systems, they also handle the
+;       switching of disks when I/O changes from A to B or vice-versa.
+;
+;       ENTRY   DS:BX   Packet address
+;               ES:DI   Transfer address
+;               AL      Unit #
+;               AH      Media Byte
+;               CX      # of sectors
+;               DX      Starting sector
+;
+;       EXIT    DS:BX   Packet Addr
+;               CX      # of sectors left to do
+;
+;       USES    SI
+FloppyRead      LABEL   NEAR
+FloppyWrite     LABEL   NEAR
+FloppyWriteV    PROC
+        debug   4,2,<Fl rd/wt/ver  Req $x:$x  unit $b  sec $d  nsec $d\n>,<ds,bx,ax,dx,cx>
+        call    BlockIfLocked
+        push    di
+        call    FDGetBPB                ; cs:di => BPB
+        mov     si,dx
+        add     si,cx                   ; compute last sector + 1
+        cmp     si,cs:[di.BPBnsec]
+        mov     si,di
+        pop     di
+        jbe     flrw1
+        mov     al,8                    ; ERROR - Sector not found
+        jmp     StatusError
+flrw1:  OR      CX,CX                   ; Anything to do?
+        JNZ     flrw2                   ; Yes
+        JMP     StatusComplete          ; No, all done now
+flrw2:
+        CMP     Single,0                ; Is this a single drive system?
+        JE      flrw3                   ; No, don't check for drive change
+        CALL    FloppyChange            ; See if should change disks
+flrw3:
+        call    CheckWrap
+        push    ds
+        pop     es                      ; ES:BX = Request addr
+        push    cs
+        pop     ds
+        LEA     SI,FloppyQueue          ; DS:SI = ptr to head of queue
+        MOV     DX,PushRequest
+        CALL    DosFunction             ; Add request to list
+        push    es
+        pop     ds                      ; Back to DS:BX is request
+        pushf
+        cli                             ; interrupts off while testing state
+        TEST    Floppy.Flags,Factive    ; Is driver active?
+        JNE     FloppyActive            ; Yes, driver will get to it
+        PUSH    DS
+        PUSH    BX                      ; Save some regs
+        OR      Floppy.Flags,Factive
+        MOV     Floppy.State,Start      ; Want to start I/O
+        CALL    FloppyExecute           ; Start up the driver
+        POP     BX
+        POP     DS                      ; Restore regs
+flrw4:  test    DS:[BX].RqStatus,0100H  ; IO completed?
+        JNZ     FloppyIOdone            ; yes
+FloppyActive:
+        MOV     AX,DS                   ; AX:BX = request
+        xor     cx,cx
+        push    bx
+        MOV     DX,BlockProcess
+        CALL    DosFunction             ; Block until I/O is done
+        pop     bx
+        jmp     flrw4                   ; test completion status again
+FloppyIOdone:
+        popf
+        MOV     AX,DS:[BX].RqStatus     ; Need AX = status
+        MOV     CX,DS:[BX].RqCount      ; Need CX = count left to do
+        debug   4,2,<Fl rd/wt/ver DONE  Req $x:$x  stat $x  resid $d\n>,<ds,bx,ax,cx>
+        JMP     SetStatus               ; Return to DOS with results
+FloppyWriteV    ENDP
+FixedRead       LABEL   NEAR
+FixedWrite      LABEL   NEAR
+FixedWriteV     PROC
+        debug   8,2,<Fix rd/wt/ver  Req $x:$x  unit $b  sec $d  nsec $d\n>,<ds,bx,ax,dx,cx>
+        call    BlockIfLocked
+        push    di
+        call    HDGetBPB                ; cs:di => BPB
+        mov     si,dx
+        add     si,cx                   ; compute last sector + 1
+        cmp     si,cs:[di.BPBnsec]
+        mov     si,di
+        pop     di
+        jbe     fxrw1
+        mov     al,8                    ; ERROR - Sector not found
+        jmp     StatusError
+fxrw1:  OR      CX,CX                   ; Anything to do?
+        JNZ     fxrw2                   ; Yes
+        JMP     StatusComplete          ; No, all done now
+fxrw2:
+        call    CheckWrap
+        push    ds
+        pop     es                      ; ES:BX = Request addr
+        push    cs
+        pop     ds
+        LEA     SI,FixedQueue           ; DS:SI = ptr to head of queue
+        MOV     DX,PushRequest
+        CALL    DosFunction             ; Add request to list
+        push    es
+        pop     ds                      ; Back to DS:BX is request
+        pushf
+        cli                             ; interrupts off while testing state
+        TEST    Fixed.Flags,Factive     ; Is driver active?
+        JNE     FixedActive             ; Yes, driver will get to it
+        PUSH    DS
+        PUSH    BX                      ; Save some regs
+        OR      Fixed.Flags,Factive
+        MOV     Fixed.State,Start       ; Want to start I/O
+        CALL    FixedExecute            ; Start up the driver
+        POP     BX
+        POP     DS                      ; Restore regs
+fxrw4:  test    DS:[BX].RqStatus,0100H  ; IO completed?
+        JNZ     FixedIOdone             ; yes
+FixedActive:
+        MOV     AX,DS                   ; AX:BX = request
+        xor     cx,cx
+        push    bx
+        MOV     DX,BlockProcess
+        CALL    DosFunction             ; Block until I/O is done
+        pop     bx
+        jmp     fxrw4                   ; test completion status again
+FixedIOdone:
+        popf
+        MOV     AX,DS:[BX].RqStatus     ; Need AX = status
+        MOV     CX,DS:[BX].RqCount      ; Need CX = count left to do
+        debug   8,2,<Fx rd/wt/ver DONE  Req $x:$x  stat $x  resid $d\n>,<ds,bx,ax,cx>
+        JMP     SetStatus               ; Return to DOS with results
+FixedWriteV     ENDP
+;***    CheckWrap - check whether a request crosses a 64Kb boundary
+;
+;       CheckWrap will check whether the request given in DS:BX
+;       crosses a 64Kb boundary.  A portion of such requests must
+;       be done using ScratchBuffer for a single sector transfer.
+;       This routine ensures that only one such request is put into
+;       either of the request queues at any time.
+;
+;       ENTRY   DS:BX   Request header
+;               ES:DI   Transfer address
+;               CS:SI   Pointer to BPB
+;               CX      Sector count
+;       EXIT    When it's safe to proceed.
+;       USES    AX,BP
+CheckWrap       PROC
+        push    dx
+        push    cx
+        mov     ax,cx
+        mul     cs:[si.BPBsecsiz]
+        mov     dx,es                   ; compute offset
+        mov     cl,4
+        shl     dx,cl
+        add     dx,di
+        clc                             ; now see if offset+nbytes overflows
+        add     dx,ax
+        jnc     chkw8
+        debug   12,10h,<CheckWrap $x $x:$x      >,<ax,es,di>
+        push    bx
+        SemWait ScratchBufSem           ; wait for ScratchBuffer to be available
+        pop     bx
+chkw8:  pop     cx
+        pop     dx
+        ret
+CheckWrap       ENDP
+;***    FloppyChange - check whether floppy disk must be changed
+;
+;       FloppyChange is called on a single drive system to simulate a
+;       two drive system.  The current request for I/O is checked against
+;       what the driver considers to be the current drive.  If they are
+;       the same, FloppyChange just returns.  Otherwise, SwapSem2 is set
+;       and the current process is blocked on SwapSem2.  Any process that
+;       attempts I/O while SwapSem2 is set is blocked on SwapSem1.  When
+;       SwapSem2 is cleared, these processes are continued.  When the
+;       driver becomes idle and SwapSem2 is set, the Idle state continues
+;       the blocked process.  This process then puts out the message about
+;       switching disks and waits for a user reply.  When it is given,
+;       FloppyChange clears SwapSem1 and causes the I/O to be started.
+;
+;       ENTRY   DS:BX   Pointer to I/O request
+;
+;       USES    AX,DX
+;
+FloppyChange    PROC
+        push    cx
+        pushf
+        push    bx
+        SemWait SwapSem1                ; Currently waiting to switch disk?
+        pop     bx
+flcha1: and     SwapSem1,NOT SEM_BUSY   ; reset BUSY for now
+        MOV     AL,DS:[BX].RqUnit       ; Get desired unit
+        CMP     AL,Floppy.Unit          ; Switching A and B drive?
+        JE      flcha7                  ; No, keep using this drive
+        CLI                             ; ** Disable interrupts
+        OR      SwapSem1,SEM_BUSY       ; Flag waiting to switch
+        test    Floppy.Flags,Factive    ; Is driver idle?
+        JE      flcha2                  ; Yes, don't need to wait
+        push    bx
+        SemWait SwapSem2
+        pop     bx
+        jmp     flcha1
+flcha2:
+        popf                            ; restore interrupt state
+        pushf
+        ADD     AL,"A"                  ; Convert to drive letter
+        MOV     CS:DriveLetter,AL       ; Set the letter
+        PUSH    DS
+        PUSH    SI
+        push    bx
+        push    cs
+        pop     ds
+        LEA     SI,SwitchMsg
+flcha4:
+        LODSB
+        OR      AL,AL                   ; End of message?
+        JZ      flcha5                  ; Yes
+        INT     29H                     ; No, output char
+        JMP     flcha4                  ; Put out whole msg
+flcha5:
+        mov     ah,1                    ; Flush keyboard input
+        int     16H
+        jz      flcha5
+        XOR     AH,AH
+        INT     16H                     ; Wait for a char
+        pop     bx
+        POP     SI
+        POP     DS
+flcha7:
+        push    bx
+        SemSig  SwapSem1                ; Allow blocked processes to continue
+        pop     bx
+flcha8:
+        popf
+        pop     cx
+        RET
+FloppyChange    ENDP
+SwitchMsg       LABEL   WORD
+        DB      13,10,"Insert diskette for drive "
+DriveLetter     LABEL   BYTE
+        DB      "A: and strike",13,10,"any key when ready",13,10,10,0
+Int13Handler    Proc    Far
+        push    dx                      ; Save regs used in local processing
+        push    cx
+        push    bx
+        push    ax
+        pushf
+LockCheck:
+        cli                             ; If any Int 13 request is already
+        cmp     SemInt13,0              ;  pending, block this process until
+        jz      NotLocked               ;  the previous one finishes.
+        mov     ax,cs
+        mov     bx,offset SemInt13
+        xor     cx,cx
+        mov     dx,BlockProcess
+        call    DosFunction
+        jmp     LockCheck
+NotLocked:
+        mov     SemInt13,1              ; Lock out other disk requests
+        popf
+        pushf
+BusyCheck:
+        cli
+        cmp     SemDiskIO,0             ; If the disks are busy, block this
+        jz      DiskFree                ;  process till they free up.
+        mov     ax,cs
+        mov     bx,offset SemDiskIO
+        xor     cx,cx
+        mov     dx,BlockProcess
+        call    DosFunction
+        jmp     BusyCheck
+DiskFree:
+        popf
+        sti
+        pop     ax                      ; Restore regs for call
+        pop     bx
+        pop     cx
+        pop     dx
+        push    dx
+        push    cx
+        push    bx
+        pushf
+        call    dword ptr [RealInt13Vec]
+        mov     SemInt13,0
+        push    ax
+        pushf
+        mov     ax,cs                   ; Unblock anything that is waiting
+        mov     bx,offset SemInt13
+        mov     dx,ContinueProcess
+        call    DosFunction
+        popf                            ; Restore user regs
+        pop     ax
+        pop     bx
+        pop     cx
+        pop     dx
+        ret     2
+Int13Handler    endp
+SUBTTL  Fixed disk startup routine
+PAGE    +
+;       FixedExecute processes a disk request after it has been set up.  When the
+;  disk is inactive (State = Idle), it is called to start the device.  For all
+;  subsequent events, it is called on the disk interrupt which signaled the
+;  completion of that subfunction.  Some states do not involve waiting for an
+;  interrupt to occur.  This routine runs entirely off the 'Fixed' data structure
+FixedDispatch   LABEL   WORD
+        DW      FxExStart
+        DW      FxExCalc
+        DW      FxExError               ;; BUGBUG really error in state machine
+        DW      FxExError               ;; BUGBUG really error in state machine
+        DW      FxExError               ;; BUGBUG really error in state machine
+        DW      FxExError               ;; BUGBUG really error in state machine
+        DW      FxExVerify
+        DW      FxExDone
+        DW      FxExIdle
+        DW      FxExError
+FixedExecute    PROC
+        push    cs                      ; CS -> DS
+        pop     ds
+    ASSUME      DS:BiosSeg
+        MOV     BX,Fixed.State          ; Get current state
+        debug   8,4,<FxEx state $d      >,<bx>
+        ADD     BX,BX
+        JMP     FixedDispatch[BX]       ; Dispatch to correct routine
+;*      Fixed state Start
+;
+;       Do setup calculations to figure out sector, start
+;  up motor, advance to Calc state.
+;
+;  Entered on initially picking up a new request to do and on error retries.
+;  If error retries start here, then multiple sector requests will always start
+;  at the beginning rather than at the point of the error! Why?
+FxExStart:
+        mov     si,OFFSET Fixed         ; SI = pointer to per-device info.
+        les     bx,FixedQueue           ; ES:BX = pointer to current request
+        mov     al,es:[bx].RqUnit
+        call    HDGetBPB                ; DI = drive parameters
+        CALL    Setup                   ; Do setup calculations
+        MOV     Fixed.State,Calc        ; Advance to next state
+        JMP     FixedExecute            ; Now return to do Calc code
+;*      Fixed state Calc
+;
+;       Calculate cylinder, head and sector, wait for motor
+;  start or head load, advance to Select state.
+;
+;  Entered after Start state and also on further sectors of a multiple sector
+;  request.
+FxExCalc:
+        mov     si,OFFSET Fixed         ; SI = pointer to per-device info.
+        les     bx,FixedQueue           ; ES:BX = pointer to current request
+        mov     al,es:[bx].RqUnit
+        call    HDGetBPB                ; DI = drive parameters
+        CALL    MapSector               ; Get head, cylinder and sector
+        test    Fixed.Flags,Fwrite
+        jnz     fxxc1
+        mov     al,DMA_read
+        mov     Fixed.DCB,HD_CREAD
+        jmp     SHORT fxxc2
+fxxc1:  mov     al,DMA_write
+        mov     Fixed.DCB,HD_CWRITE
+fxxc2:  mov     ah,HD_DMA
+        call    DMAsetup                ; set up DMA transfer
+        mov     al,Fixed.Unit
+        mov     cl,5
+        shl     ax,cl
+        or      al,Fixed.Head
+        mov     Fixed.DCB+1,al          ; set head/unit
+        mov     ax,Fixed.cyl
+        mov     Fixed.DCB+3,al          ; set low cylinder
+        shr     ax,1
+        shr     ax,1
+        and     al,0C0H
+        or      al,Fixed.Sector
+        mov     Fixed.DCB+2,al          ; set high cylinder/sector
+        mov     al,BYTE PTR Fixed.Numsectors
+        mov     Fixed.DCB+4,al          ; set sector count
+        mov     Fixed.DCB+5,HDcontrolbyte       ;BUGBUG - what do we want here?
+        mov     al,3
+        call    HDCommand
+        mov     al,Done                 ; assume next state is Done
+        test    Fixed.Flags,Fverify
+        jz      fxxc3
+        mov     al,Verify
+fxxc3:  mov     BYTE PTR Fixed.State,al         ; set next state
+        ret
+;*      Fixed state Verify
+;
+;       Have executed a write function, must now verify.
+; BUGBUG        For now just go to done state.
+FxExVerify:
+        mov     Fixed.State,Done
+        jmp     FixedExecute
+;*      Fixed state Done
+;
+;       If whole request is now complete, mark the request
+;  as done and then start the next one if there is one.  If the request is not
+;  yet done, adjust values to show the amount of the request done and then go
+;  back to the Calc state to do next part.
+FxExDone:
+        MOV     AL,Fixed.Flags
+        AND     AL,Fwrite+Fwrap1        ; Only interested in these bits
+        CMP     AL,Fwrap1               ; Just read into scratch?
+        JNE     fxxd1                   ; No
+        PUSH    DS
+        PUSH    ES
+        MOV     CX,Fixed.NumBytes       ; CS = # bytes to write from scr
+        LES     DI,Fixed.RealAddr       ; ES:DI = real buffer
+        LDS     SI,Fixed.Addr           ; DS:SI = scratch buffer
+        CLD
+  REP   MOVSB                           ; Copy into real buffer
+        POP     ES
+        POP     DS
+fxxd1:
+        MOV     AX,Fixed.NumSectors     ; AX = # of sectors we did
+        SUB     Fixed.Count,AX          ; Adjust count to number left
+        JZ      fxxd3           ; Request is done, tell DOS
+        ADD     Fixed.First,AX          ; Advance sector number
+        MOV     AX,Fixed.NumBytes       ; Number of bytes handled
+        ADD     WORD PTR Fixed.RealAddr,AX ; Advance data address
+        MOV     Fixed.State,Calc        ; Go to Calc state
+fxexj4: JMP     FixedExecute
+fxxd3:
+        mov     DI,OFFSET Fixed
+        mov     SI,OFFSET FixedQueue    ; DS:SI = head of queue
+        call    DoneRequest
+        JMP     fxexj4
+;*      Fixed state Idle
+;
+;       Nothing hapenning, become inactive.
+FxExIdle:
+        and     Fixed.Flags,NOT Factive
+        RET
+;*      Fixed state Error
+;
+;       Entered when a non-recoverable error is detected.
+;       A sense block has been requested and put into the
+;       DCB.
+FxExError:
+        MOV     Fixed.State,Done        ; Request is done
+; Set error bits in request packet
+        MOV     AL,Fixed.DCB            ; Get status byte
+        mov     bl,al                   ; isolate error type as word address
+        and     bx,0030h
+        mov     cl,3
+        shr     bx,cl
+        mov     bx,HDErrType[BX]        ; index into error table by type
+        and     ax,0Fh                  ; get error code
+        cmp     al,ds:[bx]              ; outside range of table?
+        jae     fxxe1
+        add     bx,ax
+        mov     ah,ds:[bx+1]            ; translate error code
+        jmp     SHORT fxxe2
+fxxe1:
+        mov     ah,12
+fxxe2:  dbbeg   8,4
+        mov     di,OFFSET Fixed.DCB
+        debug   8,4,<HD error: sense $b$b$b$b code $x\n>,<<[di]>,<[di+1]>,<[di+2]>,<[di+3]>,ax>
+        dbend
+        endif
+        PUSH    ES
+        LES     DI,FixedQueue           ; Get ptr to request
+        MOV     AL,ah
+        MOV     AH,10000001B
+        MOV     ES:[DI].RqStatus,AX     ; Set error and code
+        POP     ES
+        JMP     fxxd3           ; Advance to Done state
+FixedExecute    ENDP
+;*      Traslation of controller error codes to DOS error codes
+HDErrType       DW      HDErrTyp0
+                DW      HDErrTyp1
+                DW      HDErrTyp2
+                DW      HDErrTyp3
+HDErrTyp0       DB      9, 12, 2, 6,10, 2,12, 6,12, 6
+HDErrTyp1       DB      10, 4, 4, 8,12, 8, 6,12,12, 4, 6
+HDErrTyp2       DB      2,  3, 8
+HDErrTyp3       DB      3,  4, 4, 4
+    ASSUME      CS:BiosSeg,DS:NOTHING,ES:NOTHING
+FixedInterrupt  PROC    FAR
+        debug   8,8,<FxIntr\n>,<>
+        cmp     word [SemDiskIO],0001h
+        jnz     fxinot13
+        cmp     SemInt13,0              ; If a direct Int13 request is being
+        jz      fxinot13                ;  made call the ROM floppy interrupt
+        cmp     SemDiskIO,0             ;  routine to handle it.
+        jnz     fxinot13
+        int     int_savregs
+;;      in      al,21H                  ; Mask fixed disk interrupts
+;;      or      al,20h
+;;      out     21H,al
+        pushf
+        call    dword ptr [OldIntDVec]
+        in      al,21H                  ; Unmask fixed disk interrupts
+        and     al,0DFH
+        out     21H,al
+        mov     dx,HD_PMSK              ; set interrupt and DMA mask bits
+        mov     al,3
+        out     dx,al
+        iret
+fxinot13:
+        TEST    Fixed.Flags,Factive     ; device active?
+        JZ      fxinret                 ; no, go away
+        INT     int_savregs             ; save registers
+        mov     dx,HD_PDAT
+        in      al,dx                   ; get status reg.
+;;      mov     ah,al
+;;      mov     dx,HD_PMSK
+;;      xor     al,al
+;;      out     dx,al                   ; turn off intr. and DMA.
+;;      test    ah,02h                  ; error bit set?
+        test    al,02h                  ; error bit set?
+        jz      fxin4                   ; no
+;* error occurred.  see if retry, else get error code.
+        push    cs
+        pop     ds
+    ASSUME      ds:BiosSeg
+        CMP     Fixed.ErrCnt,ErrLim     ; Reach error limit?
+        JAE     fxin0                   ; Yes, request fails
+        INC     Fixed.ErrCnt            ; We are doing another try
+        MOV     Fixed.State,Start       ; Restart the request
+        JMP     fxin4
+fxin0:  mov     Fixed.DCB,HD_CSENS      ; send sense command
+        xor     al,al                   ; reset intr. & DMA masks
+        call    HDCommand
+        push    cs
+        pop     es
+        mov     di,OFFSET Fixed.DCB
+        mov     cx,5
+fxin1:  call    HDWaitReq               ; get the sense block back
+        mov     dx,HD_PDAT
+        in      al,dx
+        stosb
+        loop    fxin1
+        mov     Fixed.State,Error
+    ASSUME      ds:NOTHING
+fxin4:  CALL    FixedExecute
+fxinret: push   ax
+        MOV     AL,20H                  ; send EOI to 8259
+        OUT     20H,AL
+        pop     ax
+        IRET
+FixedInterrupt  ENDP
+SUBTTL  Floppy disk startup routine
+PAGE    +
+;       FloppyExecute processes a disk request after it has been set up.
+;       When the disk is inactive (State = Idle), it is called to start
+;       the device.  For all subsequent events, it is called on the disk
+;       interrupt which signaled the completion of that subfunction.
+;       Some states do not involve waiting for an interrupt to occur.
+;       This routine runs entirely off the 'Floppy' data structure
+FloppyDispatch  LABEL   WORD
+        DW      FlExStart
+        DW      FlExCalc
+        DW      FlExSelect
+        DW      FlExRecal
+        DW      FlExSeek
+        DW      FlExSettle
+        DW      FlExRdWri
+        DW      FlExDone
+        DW      FlExIdle
+        DW      FlExError
+FloppyExecute   PROC
+        push    cs                      ; CS -> DS
+        pop     ds
+    ASSUME      DS:BiosSeg
+        MOV     BX,Floppy.State         ; Get current state
+        debug   4,4,<FlEx state $d      >,<bx>
+        ADD     BX,BX
+        JMP     FloppyDispatch[BX]      ; Dispatch to correct routine
+;*      Floppy state Start
+;
+;       Do setup calculations to figure out sector, start
+;  up motor, advance to Calc state.
+;
+;  Entered on initially picking up a new request to do and on error retries.
+;  If error retries start here, then multiple sector requests will always start
+;  at the beginning rather than at the point of the error! Why?
+FlExStart:
+        mov     si,OFFSET Floppy        ; SI = pointer to per-device info.
+        les     bx,FloppyQueue          ; ES:BX = pointer to current request
+        mov     al,es:[bx].RqUnit
+        mov     ah,es:[bx].RqMedia
+        call    FDGetBPB                ; DI = drive parameters
+        CALL    Setup                   ; Do setup calculations
+        MOV     DX,FD_PCMD
+        MOV     AL,Rate44
+        OUT     DX,AL                   ; Set step rate
+        MOV     Floppy.State,Calc       ; Advance to next state
+flexj1: JMP     FloppyExecute           ; Now return to do Calc code
+;*      Floppy state Calc
+;
+;       Calculate cylinder, head and sector, wait for motor
+;  start or head load, advance to Select state.
+;
+;  Entered after Start state and also on further sectors of a multiple sector
+;  request.
+FlExCalc:
+        mov     si,OFFSET Floppy        ; SI = pointer to per-device info.
+        les     bx,FloppyQueue          ; ES:BX = pointer to current request
+        mov     al,es:[bx].RqUnit
+        mov     ah,es:[bx].RqMedia
+        call    FDGetBPB                        ; DI = drive parameters
+        CALL    MapSector               ; Get head, cylinder and sector
+        MOV     Floppy.State,Select     ; Will advance to Select state
+        CALL    Sel765                  ; Select the drive and maybe wait
+        JNC     FloppyExecute           ; Did select with no waiting
+        RET                             ; Have set a timer, get out
+;*      Floppy state Select
+;
+;       Recalibrate the drive if needed.  If Seek is
+;  needed, start it and advance to Seek state.  Otherwise advance to Settle
+;  state.
+FlExSelect:
+        call    GetDrivePtr
+        OR      [BX].DrvFlag,Fmotoron   ; we've been selected, so motor is on
+        TEST    [BX].DrvFlag,Frestor    ; Is a restore needed?
+        JE      NoRestore               ; No
+        call    SetTimer2               ; set a sanity/motor stop timer
+        MOV     Floppy.State,Recal      ; Next state will be recalibrate
+        CALL    Rcl765                  ; Start the recalibrate
+        RET                             ; Done until floppy interrupt arrives
+NoRestore:                              ; Start the seek if any
+        CALL    Seek765                 ; Start the seek to cylinder
+        JNC     SeekOK                  ; Already on correct cylinder
+        MOV     Floppy.State,Seek       ; Next state is Seek
+        call    GetDrivePtr
+        call    SetTimer2               ; set sanity timer
+        RET                             ; Done until interrupt on seek done
+;*      Floppy state Recal
+;
+;       If error, set state is Error.  Else, load drive
+;  specs into controller and advance to Select state.
+FlExRecal:
+        CALL    Sense765
+        OR      AX,AX                   ; Error in recal?
+        JNZ     SeekErr                 ; Yes
+RecalOK:
+        CALL    Spec765                 ; Load drive specs
+        MOV     Floppy.State,Select     ; Back to select state now
+flexj2: JMP     flexj1
+;*      Floppy state Seek
+;
+;       If error, advance to Error state.  Otherwise, wait
+;  for head to settle and advance to Settle state.
+FlExSeek:
+        CALL    Sense765                ; Get status of seek
+        OR      AX,AX                   ; Any error?
+        JZ      SeekOK                  ; No
+SeekErr:
+        CALL    GetDrivePtr
+        OR      [BX].DrvFlag,Frestor    ; flag restore needed
+        MOV     Floppy.State,Error      ; Yes, next state is Error
+        or      Floppy.ST1,8            ; indicate seek error in an unused bit
+        JMP     flexj2
+SeekOK:
+        MOV     Floppy.State,Settle     ; Next state is Settle
+        MOV     AL,DelaySettle
+        CALL    GetFloppyParam          ; Get the settle time in Msecs
+        xor     ah,ah
+        CALL    SetTimer1               ; Set the timer
+        JNC     flexj2
+        RET
+;*      Floppy state Settle
+;
+;       Start the read/write request and advance to the RdWri state.
+FlExSettle:
+        MOV     Floppy.State,RdWri      ; Advance to read/write state
+        CALL    RdWr765                 ; Start the I/O
+        call    GetDrivePtr
+        call    SetTimer2               ; set sanity timer
+        RET                             ; Done until floppy interrupt
+;*      Floppy state RdWri
+;
+;       If error, next state is Error.  Otherwise next state is Done.
+FlExRdWri:
+        CALL    Fini765                 ; Get status of I/O
+        OR      AX,AX                   ; Any error?
+        JZ      RdWriOK                 ; No
+        MOV     Floppy.State,Error      ; Yes, go to error state
+        JMP     flexj2
+RdWriOK:
+        MOV     Floppy.State,Done       ; I/O is done
+flexj3: JMP     flexj2
+;*      Floppy state Done
+;
+;       If whole request is now complete, mark the request
+;  as done and then start the next one if there is one.  If the request is not
+;  yet done, adjust values to show the amount of the request done and then go
+;  back to the Calc state to do next part.
+FlExDone:
+        MOV     AL,Floppy.Flags
+        AND     AL,Fwrite+Fverify+Fwrap1        ; Only interested in these bits
+        CMP     AL,Fwrap1               ; Just read into scratch?
+        JNE     DoneNotWrap             ; No
+        PUSH    DS
+        PUSH    ES
+        MOV     CX,Floppy.NumBytes      ; CS = # bytes to write from scr
+        LES     DI,Floppy.RealAddr      ; ES:DI = real buffer
+        LDS     SI,Floppy.Addr          ; DS:SI = scratch buffer
+        CLD
+  REP   MOVSB                           ; Copy into real buffer
+        POP     ES
+        POP     DS
+DoneNotWrap:
+        AND     AL,Fwrite+Fverify       ; Just want to see these bits
+        CMP     AL,Fwrite+Fverify       ; Just do write part of write+verify?
+        JNE     DoneNotWritePart        ; No
+        AND     Floppy.Flags,NOT Fwrite ; Yes, do verify next
+        mov     Floppy.State,Settle     ;   don't need to calc or seek
+        jmp     flexj3
+DoneNotWritePart:
+        CMP     AL,Fverify              ; Just do verify part of write+verify?
+        JNE     DoneNotVerify           ; No
+        OR      Floppy.Flags,Fwrite     ; Yes, flip write back up for next
+DoneNotVerify:
+        MOV     AX,Floppy.NumSectors    ; AX = # of sectors we did
+        SUB     Floppy.Count,AX         ; Adjust count to number left
+        JZ      flxd3           ; Request is done, tell DOS
+        ADD     Floppy.First,AX         ; Advance sector number
+        MOV     AX,Floppy.NumBytes      ; Number of bytes handled
+        ADD     WORD PTR Floppy.RealAddr,AX ; Advance data address
+        MOV     Floppy.State,Calc       ; Go to Calc state
+flexj4: JMP     flexj3
+flxd3:
+        mov     di,OFFSET Floppy
+        mov     SI,OFFSET FloppyQueue   ; DS:SI = head of floppy queue
+        call    DoneRequest
+        JMP     flexj4
+;*      Floppy state Idle
+;
+;       Nothing hapenning except possible motor off timeout.
+FlExIdle:
+        call    GetDrivePtr
+        CALL    SetTimer2               ; Set the motor timer
+        and     Floppy.Flags,NOT Factive
+        SemSig  SwapSem2                ; someone waiting to switch drive?
+        RET
+;*      Floppy state Error
+;
+;       If error count not exceeded, restore the drive and start
+;  the request over again.  Otherwise set error in the packet and
+;  advance to the Done state.
+FlExError:
+        CALL    Rst765                  ; Reset the controller
+        CMP     Floppy.ErrCnt,ErrLim    ; Reach error limit?
+        JAE     FloppyFails             ; Yes, request fails
+        INC     Floppy.ErrCnt           ; We are doing another try
+        MOV     Floppy.State,Start      ; Restart the request
+        JMP     flexj4          ; Back to state machine loop
+FloppyFails:
+        call    GetDrivePtr
+        OR      CS:[BX].DrvFlag,Frestor ; Set drive needs a restore
+        MOV     Floppy.State,Done       ; Request is done
+; Set error bits in request packet
+        MOV     AX, WORD PTR Floppy.ST0 ; Get ST0, ST1
+        mov     BL,2                    ; Drive not ready?
+        test    AL,0cH
+        jne     ErrorFound
+        MOV     BL,6                    ; Bad seek?
+        TEST    AH,8
+        JNE     ErrorFound
+        MOV     BL,4                    ; CRC error?
+        TEST    AH,30H
+        JNE     ErrorFound
+        MOV     BL,8                    ; Sector not found?
+        TEST    AH,85H
+        JNE     ErrorFound
+        MOV     BL,0                    ; Write protect?
+        TEST    AH,2
+        JNE     ErrorFound
+        MOV     BL,12                   ; Catch-all error
+ErrorFound:
+        debug   4,4,<FD error: status $x code $b\n>,<ax,bx>
+        PUSH    ES
+        LES     DI,FloppyQueue          ; Get ptr to request
+        MOV     AL,BL
+        MOV     AH,10000001B
+        MOV     ES:[DI].RqStatus,AX     ; Set error and code
+        POP     ES
+        JMP     flxd3                   ; Advance to Done state (via shortcut)
+FloppyExecute   ENDP
+    ASSUME      CS:BiosSeg,DS:NOTHING,ES:NOTHING
+FloppyInterrupt PROC    FAR
+        debug   4,8,<FlIntr\n>,<>
+        cmp     SemInt13,0              ; If a direct Int13 request is being
+        jz      flinot13                ;  made call the ROM floppy interrupt
+        cmp     SemDiskIO,0             ;  routine to handle it.
+        jnz     flinot13
+        int     int_savregs
+        pushf
+        call    dword ptr [OldIntEVec]
+        iret
+flinot13:
+        TEST    Floppy.Flags,Factive    ; device active?
+        JZ      flinret                 ; no, go away
+        INT     int_savregs             ; save registers
+        CALL    FloppyExecute
+flinret: push   ax
+        MOV     AL,20H                  ; send EOI to 8259
+        OUT     20H,AL
+        pop     ax
+        IRET
+FloppyInterrupt ENDP
+SUBTTL  Timing routines for floppy disk
+PAGE    +
+;*  Data for timers
+TimerActive     DB      0               ; bit flags for active timers
+TimerConv       DB      50              ; conversion factor for ms => ticks
+Timer1  DB      0                       ; One-shot time till restart intr. rtn.
+Timer2  DB      0                       ; Repetitive 1 Hz timer
+Timer2count     =       20              ; Reload value for timer2
+MOFFDELAY=      2                       ; turn off motor after 2 sec. inactivity
+;***    SetTimer1 - Arm timer 1
+;
+;       SetTimer1 will arm the Timer1.  Input parameter
+;       values in milliseconds will be converted to timer
+;       ticks.
+;
+;       ENTRY   AX = delay value in milliseconds
+;       EXIT    AL = timer ticks
+;               CF set if timer armed
+;               CF clear if zero count passed
+;       USES    AX
+SetTimer1       PROC
+        TEST    AX,AX                   ; zero count?
+        JNZ     sett10                  ; no
+        CLC
+        RET
+sett10: DIV     TimerConv
+        TEST    AH,AH                   ; remainder?
+        JZ      sett11
+        INC     AL                      ; yes, round up
+sett11: MOV     Timer1,AL
+        OR      TimerActive,1
+        debug   4,8,<SetTimer1 $b\n>,<ax>
+        STC
+        RET
+SetTimer1       ENDP
+;***    SetTimer2 - Arm timer 2
+;
+;       SetTimer2 will set a motor off timeout for the
+;       drive whose parameter block is pointed to by
+;       CS:BX
+;
+;       ENTRY   CS:BX = pointer to per drive info.
+;       EXIT
+;       USES    NONE
+SetTimer2       PROC
+        TEST    TimerActive,2
+        JNZ     sett21
+        MOV     Timer2,Timer2Count
+        OR      TimerActive,2
+sett21: MOV     CS:[BX].Timer,MOFFDELAY
+        debug   4,8,<SetTimer2\n>,<>
+        RET
+SetTimer2       ENDP
+;       FloppyTimer is called every scheduler tick to perform
+;  time related services for the floppy driver.  There are
+;  two services performed; rescheduling of interrupt time
+;  service after a head load or motor startup delay, and
+;  a motor turn off service when a drive is not active.
+;
+;  It's assumed that all registers have been saved by the
+;  caller.
+        ASSUME  CS:BiosSeg,DS:NOTHING,ES:NOTHING
+        PUBLIC  FloppyTimer
+FloppyTimer     PROC    FAR
+        TEST    TimerActive,0ffH        ; any timers active?
+        JNZ     fltim1                  ; yes
+        RET                             ; no, return quickly
+fltim1: TEST    TimerActive,1           ; Timer1 active?
+        JZ      fltim3                  ; no
+        DEC     Timer1                  ; Timer1 expired?
+        JNZ     fltim3                  ; no
+;*  Perform Timer1 service
+        debug   4,8,<Timer 1 expired\n>,<>
+        AND     TimerActive,NOT 1
+        CALL    FloppyExecute           ; push the states around a while
+        RET                             ; don't do Timer2 service this time.
+fltim3: TEST    TimerActive,2           ; Timer2 active?
+        JZ      fltim4                  ; no
+        DEC     Timer2                  ; 1 Hz clock time?
+        JZ      fltim5                  ; no
+fltim4: JMP     fltim9
+fltim5:
+        debug   4,8,<Timer 2 expired\n>,<>
+        MOV     BL,Timer2count          ; reload the counter
+        MOV     Timer2,BL
+;*  Perform Timer2 service
+        XOR     CH,CH                   ; No active timeouts seen
+        XOR     DI,DI                   ; Start with drive A
+TimeOutLoop:
+        MOV     BX,DI
+        ADD     BX,BX
+        MOV     BX,FDinfo[BX]           ; Get ptr to drive info
+        TEST    CS:[BX].DrvFlag,Fmotoron        ; motor on?
+        JZ      fltim8                  ; no
+        CMP     CS:[BX].Timer,0         ; Is timer active for drive?
+        JZ      fltim8                  ; No
+        DEC     CS:[BX].Timer           ; Yes, another tick has passed
+        JNZ     fltim7
+        cmp     di,Floppy.Current       ; Current drive?
+        jnz     fltim6                  ; no
+        test    Floppy.Flags,Factive    ; device active?
+        jz      fltim6                  ; no, go ahead
+        mov     Floppy.State,Error
+        mov     Floppy.ErrCnt,ErrLim    ; don't retry this one
+        mov     Floppy.ST0,048H         ; set not ready error
+        call    FloppyExecute           ; oops, sanity timeout
+        jmp     fltim9
+fltim6:
+        AND     CS:[BX].DrvFlag,NOT Fmotoron    ; stop drive motor
+        MOV     AX,DI
+        MOV     CL,AL
+        ADD     CL,4
+        MOV     AL,1
+        SHL     AL,CL                   ; Get bit mask for motor on
+        TEST    Floppy.DOR,AL           ; Is motor already off?
+        JE      fltim8                  ; Yes, go on to next drive
+        NOT     AL                      ; Get all bits except this motor
+        AND     Floppy.DOR,AL           ; Clear this motor on
+        MOV     DX,FD_PSEL
+        MOV     AL,Floppy.DOR
+        OUT     DX,AL                   ; Turn off motor
+;;      cmp     di,Floppy.Current       ; Current drive?
+;;      jnz     fltim8                  ; no
+;;      test    Floppy.Flags,Factive    ; device active
+;;      jz      fltim8                  ; no, go on to next drive
+;;      call    DumpRegs                ; oops, sanity timeout
+fltim7: INC     CH                      ; Flag still active
+fltim8: INC     DI                      ; Advance to next drive
+        CMP     DI,WORD PTR NumFloppy   ; Any more to check?
+        JNE     TimeOutLoop             ; Yes, do them
+        OR      CH,CH                   ; Need to keep timer active?
+        JNZ     fltim9                  ; Yes
+        AND     TimerActive,NOT 2       ; No, clear timeout is active
+fltim9: RET
+FloppyTimer     ENDP
+IFDEF   DEBUGFLG
+DumpRegs        PROC
+        push    cs
+        pop     ds
+        debug   4,0fh,<Sanity Timeout!!\n>,<>
+        mov     di,OFFSET Floppy
+        debug   4,0fh,<Floppy struct\n  $x $x $x $x  $x $x $x $x\n>,<[di],[di.2],[di.4],[di.6],[di.8],[di.10],[di.12],[di.14]>
+        debug   4,0fh,<  $x $x $x $x  $x $x $x $x\n>,<[di.10h],[di.12h],[di.14h],[di.16h],[di.18h],[di.1ah],[di.1ch],[di.1eh]>
+        call    GetDrivePtr
+        debug   4,0fh,<Drive struct\n  $x $x $x $x  $x $x $x $x\n>,<[bx],[bx.2],[bx.4],[bx.6],[bx.8],[bx.10],[bx.12],[bx.14]>
+        debug   4,0fh,<  $x $x $x $x\n>,<[bx.16],[bx.18],[bx.20],[bx.22]>
+        debug   4,0fh,<  IMR IRR ISR    8259 status\n>,<>
+        mov     al,0ah
+        out     20h,al
+        in      al,20h
+        mov     bl,al
+        mov     al,0bh
+        out     20h,al
+        in      al,20h
+        mov     cl,al
+        in      al,21h
+        debug   4,0fh,<  $b  $b  $b\n>,<ax,bx,cx>
+        debug   4,0fh,<765 status, data\n>,<>
+        mov     dx,FD_PSTAT
+        in      al,dx
+        mov     bl,al
+        mov     dx,FD_PDAT
+        in      al,dx
+        debug   4,0fh,<     $b      $b\n>,<bx,ax>
+        sti
+dmpr0:  jmp     dmpr0
+DumpRegs        ENDP
+ENDIF   ;DEUBGFLAG
+SUBTTL  Routines shared between Floppy and Hard disk drivers
+PAGE    +
+;***    Setup - Set request parameters into local structure.
+;
+;       Setup sets the Unit, First, Addr, Count and Flags fields in the
+;       device structure which are used to drive the I/O.  The following
+;       flags are affected:
+;               Fwrite  This is a write request, not a read
+;               Fverify This is a write with verify (verify when write
+;                       is cleared).
+;       Other fields are copied from the DOS request packet.
+;
+;       ENTRY   SI      Pointer to device variables
+;               ES:BX   Current request
+;               AL      Unit number
+;               DI      BPB for drive
+;               DS      CS
+;
+;       EXIT    The following variables are set
+;                       [SI].Unit
+;                       [SI].First      The hidden sectors are added
+;                       [SI].RealAddr
+;                       [SI].Count
+;                       [SI].Flags
+    ASSUME      CS:BiosSeg,DS:BiosSeg
+Setup   PROC
+        MOV     AX,ES:[BX].RqCount
+        MOV     [SI].Count,AX           ; Set number of sectors to do
+        MOV     AX,ES:[BX].RqAddr
+        MOV     WORD PTR [SI].RealAddr,AX
+        MOV     AX,ES:[BX].RqAddr+2
+        MOV     WORD PTR [SI].RealAddr+2,AX  ; Copy data address
+        MOV     AL,ES:[BX].RqUnit       ; Get unit number
+        MOV     [SI].Unit,AL            ; Set drive needed
+        MOV     AX,ES:[BX].RqFirst      ; Get the starting sector number
+        ADD     AX,[DI].BPBhidsec       ; Add # of hidden sectors
+        MOV     [SI].First,AX           ; Set 1st sector of I/O
+        and     [SI].Flags,Factive+F2step       ; mask excess flags
+        CMP     ES:[BX].RqCmd,4         ; Is this a read?
+        JE      SetupDone               ; Yes, all done
+        OR      [SI].Flags,Fwrite       ; No, flag this is a read
+        CMP     ES:[BX].RqCmd,9         ; Write with verify?
+        JNE     SetupDone               ; No, just write
+        OR      [SI].Flags,Fverify      ; Yes, set to verify too
+SetupDone:
+        RET
+Setup   ENDP
+;***    MapSector - compute head, sector, cylinder
+;
+;       MapSector takes the fields set up by Setup and figures out the
+;       head, cylinder and sector involved.  If the request involves
+;       multiple sectors, it figures out how many can be done at once
+;       based on the number of sectors left on the track and that the
+;       target address' offset does not wrap around 64k (the DMA on the
+;       PC uses a 20 bit address, but the high 4 bits do not change when
+;       the low 16 cycle back to 0).  If the request wraps around 64k, it
+;       is split into 2 or 3 pieces which are all data before wrap, after
+;       wrap and the wrap itself.  The wrap itself is transferred via a temp
+;       buffer (ScratchBuffer).
+;
+;       ENTRY   SI      Pointer to device variables
+;               ES:BX   Current request
+;               AL      Unit number
+;               DI      BPB for drive
+;               DS      CS
+;       EXIT    The following variables are set
+;                       [SI].Flags
+;                       [SI].Head
+;                       [SI].Cyl
+;                       [SI].Sector
+;                       [SI].NumSectors
+;                       [SI].NumBytes
+;                       [SI].Addr
+;       USES    AX,CX,DX,DI
+;
+MapSector       PROC
+        PUSH    ES
+        les     CX,[SI].RealAddr
+        MOV     WORD PTR [SI].Addr,CX           ; copy RealAddr to Addr
+        MOV     WORD PTR [SI].Addr+2,ES
+        AND     [SI].Flags,NOT Fwrap1           ; Clear buffer wrap flag
+; Calculate the head, cylinder and sector of the start of the request
+; from [SI].First
+        POP     ES
+        MOV     AX,[SI].First
+        XOR     DX,DX
+        DIV     [DI].BPBtrksiz          ; Divide by sectors/track
+;;      INC     DL
+        MOV     [SI].Sector,DL          ; Set sector to start at
+        XOR     DX,DX
+        DIV     [DI].BPBnhead           ; Divide by number of heads
+        MOV     [SI].Head,DL            ; Set head number
+        MOV     [SI].Cyl,AX             ; Set cylinder number
+        debug   8,4,<Cyl $d  Hd $b  Sec $b      >,<ax,dx,<word ptr [SI].Sector>>
+;
+; Now see how many sectors of request can be done.  The floppy
+; controller will not advance tracks, but will allow reading or
+; writing the remaining sectors on the track.
+;
+        MOV     AX,[DI].BPBtrksiz
+        SUB     AL,[SI].Sector          ; AL = # of sectors left on
+                                        ; track after desired.
+        XOR     AH,AH
+;;      inc     ax
+        CMP     AX,[SI].Count           ; Is whole request on this cyl?
+        JB      maps2           ; No, can only do what is left
+        MOV     AX,[SI].Count           ; Yes, use the actual # wanted
+maps2:
+        MOV     [SI].Numsectors,AX      ; Set number to do this time
+;
+; Now have to normalize offset (add in paragraph) and then see if adding
+; [SI].Numsectors causes overflow.  If it does, DMA will trash memory, so
+; decrement Numsectors and loop.
+;
+        MOV     AX,WORD PTR([SI].Addr+2)
+        MOV     CL,4
+        SHL     AX,CL                   ; Convert para to offset
+        ADD     AX,WORD PTR [SI].Addr   ; Add in offset
+        MOV     CX,AX                   ; Save offset of buffer
+maps4:
+        MOV     AX,[DI].BPBsecsiz
+        MUL     [SI].NumSectors         ; Get # bytes in transfer
+        MOV     [SI].NumBytes,AX        ; Set # bytes involved
+        ADD     AX,CX                   ; Get final offset
+        JAE     maps6                   ; No overflow, DMA will be ok
+        OR      [SI].Flags,Fwrap2       ; Flag we will be using scratch
+        DEC     [SI].NumSectors         ; Overflow, try using one less
+        JNZ     maps4
+;
+; If we got here, no sectors can be transferred before the 64K
+; boundary.  One sector must be transferred through a scratch buffer.
+;
+        debug   12,10h,<MapSector $x $x >,<ax,cx>
+        INC     [SI].NumSectors         ; Doing 1 sector of I/O
+        OR      [SI].Flags,Fwrap1       ; Flag we are using scratch
+        MOV     AX,CS
+        MOV     DI,OFFSET ScratchBuffer
+        MOV     WORD PTR([SI].Addr),DI
+        MOV     WORD PTR([SI].Addr+2),AX  ; Change buffer to scratch
+        TEST    [SI].Flags,Fwrite       ; Doing a write?
+        JE      maps6                   ; No, All done
+        PUSH    ES
+        PUSH    DS
+        PUSH    SI
+        MOV     ES,AX                   ; ES:DI = scratch buffer
+        mov     cx,[SI].NumBytes
+        LDS     SI,[SI].RealAddr        ; DS:SI = Data buffer
+        CLD
+REP     MOVSB                           ; Copy the write buffer
+        POP     SI
+        POP     DS
+        POP     ES
+maps6:
+        RET
+MapSector       ENDP
+;***    DMAsetup - Set the DMA channel up to do the I/O
+;
+;       ENTRY   AL = DMA mode
+;               AH = DMA channel number (2 or 3 only)
+;               SI = pointer to device parameters
+;       USES    AX,CX,DX
+;
+DMAsetup        PROC
+        PUSH    AX
+        XCHG    AH,AL
+        OR      AL,4
+        OUT     PDMA+10,AL              ; set channel's mask bit
+        OUT     PDMA+12,AL              ; clear byte pointer F/F
+        pop     ax
+        push    ax                      ; restore AH, AL
+        OR      AL,AH                   ; add channel number to command
+        OUT     PDMA+11,AL              ; Set DMA mode
+        MOV     DX,PDMA
+        ROL     AH,1
+        ADD     DL,AH
+        MOV     AX,WORD PTR [SI].Addr+2 ; Get segment of addr
+        MOV     CL,4
+        ROL     AX,CL                   ; Convert para to bytes
+        MOV     CH,AL                   ; CH = 4 bits ROLed around
+        AND     AL,0F0H                 ; Lose high bits rotated around
+        ADD     AX,WORD PTR [SI].Addr   ; Add in offset value
+        ADC     CH,0                    ; Add in any carry
+        OUT     DX,AL                   ; Output low byte of address
+        MOV     AL,AH
+        OUT     DX,AL                   ; Output high byte of address
+        inc     dx                      ; address `word' count register
+        MOV     AX,[SI].NumBytes        ; # bytes in request
+        dec     ax
+        OUT     DX,AL
+        MOV     AL,AH
+        OUT     DX,AL                   ; Tell DMA how many bytes
+        pop     ax                      ; get back channel number
+        mov     dl,PDMAX
+        add     dl,ah
+        MOV     AL,CH
+        AND     AL,0FH                  ; Only 4 bits are good
+        OUT     DX,AL                   ; Output highest 4 bits of address
+        MOV     AL,AH                   ; Channel to start
+        OUT     PDMA+10,AL              ; Clear channel's mask bit
+        RET
+DMAsetup        ENDP
+;***    DoneRequest - Mark a request complete, setup to start next one
+;
+;       DoneRequest does common processing needed when a request
+;       has been completed.  It will reset the device state,
+;       dequeue the request, mark it complete, restart the
+;       process and restart any process waiting on ScratchBuffer
+;       if this request had reserved it.
+;
+;       ENTRY   SI      Pointer to head of queue
+;               DI      Pointer to device information
+;       EXIT    ES:BX   Next request
+;       USES    AX,BX,DX,BP,ES
+DoneRequest     PROC
+        push    cs
+        pop     ds
+    ASSUME      ds:BiosSeg
+        MOV     [DI].ErrCnt,0           ; Reset error count
+        MOV     [DI].State,Idle         ; Assume will be idle
+        MOV     DX,PullRequest
+        CALL    DosFunction             ; Pull the current request out
+        JZ      dnrq2                   ; Nothing really completed
+        MOV     AX,[DI].Count           ; Get I/O left to do
+        SUB     ES:[BX].RqCount,AX      ; Adjust requested count by residual
+        OR      ES:[BX].RqStatus,0100h  ; set done bit
+        MOV     AX,ES                   ; AX:BX = Request completed
+        MOV     DX,ContinueProcess
+        CALL    DosFunction             ; Make process run again
+        CMP     WORD PTR [SI]+2,0       ; Is there another request to do?
+        JZ      dnrq2                   ; No, let device shut down
+        MOV     [DI].State,Start        ; Yes, start up next request
+dnrq2:
+        test    [DI].Flags,Fwrap2       ; had this request used ScratchBuffer?
+        jz      dnrq4                   ; no
+        SemSig  ScratchBufSem           ; let anyone waiting proceed
+        and     [DI].Flags,NOT Fwrap2
+dnrq4:                                  ; If both the fixed and floppy drivers
+        push    bx                      ;  are idle, reset the busy flag and
+        cmp     Floppy.State,Idle       ;  continue any processes that were
+        jne     dnrq5                   ;  waiting for it.
+        cmp     Fixed.State,Idle
+        jne     dnrq5
+        mov     SemDiskIO,0
+        mov     ax,ds
+        mov     bx,offset SemDiskIO
+        mov     dx,ContinueProcess
+        call    DosFunction
+dnrq5:
+        pop     bx
+        ret
+DoneRequest     ENDP
+;       FDGetBPB returns a pointer to the floppy disk BPB for the
+;  selected media byte.  The BPB contains various drive parameters
+;  such as physical disk dimensions and the size of FATs and the
+;  root directory.
+;
+;  Input:       AH =    Media byte
+;               AL =    Drive number
+;  Destroys:    None
+;  Output:      CS:DI = Pointer to BPB
+        ASSUME  DS:NOTHING,ES:NOTHING
+FDGetBPB        PROC
+        PUSH    AX
+        PUSH    BX
+        PUSH    CX
+        PUSH    DX                      ; Save regs
+        MOV     CL,AH                   ; Copy media value
+        AND     CL,0F8H                 ; Look at just top 5 bits
+        CMP     CL,0F8H                 ; Valid media byte?
+        JE      BPBGood                 ; Yes
+        MOV     AH,0FEH                 ; No, make it 8 sector 1 sided
+BPBgood:
+        MOV     BL,AL                   ; Get pointer to per drive info.
+        XOR     BH,BH
+        ADD     BX,BX
+        MOV     DI,CS:FDinfo[BX]
+        CMP     AH,CS:[DI].BPBmediab    ; already set?
+        JE      BPBdone                 ; yes, don't bother rebuilding
+        MOV     AL,1                    ; Assume will have 1 FAT sector
+        MOV     BX,64*256+8             ; Assume # dir = 64,  8 sector
+        MOV     CX,40*8                 ; Assume 320 sectors/disk
+        MOV     DX,1*256+1              ; Assume 1 head, 1 sector/allocate
+        TEST    AH,2                    ; Is drive 8 or 9 sector?
+        JNZ     BPBKnowSectors          ; It's 8, we assumed right
+        INC     AL                      ; 9 sector, incr # of FAT sectors
+        INC     BL                      ; Set we have 9 sectors/cylinder
+        ADD     CX,40                   ; Increase size to 360 sectors
+BPBKnowSectors:
+        TEST    AH,1                    ; Is disk double sided?
+        JE      BPBKnowHeads            ; No, we guessed right
+        ADD     CX,CX                   ; Double size of disk
+        MOV     BH,112                  ; Increase # of directory entries
+        INC     DH                      ; Set 2 sectors/allocation unit
+        INC     DL                      ; Set 2 heads
+BPBKnowHeads:
+        MOV     CS:[DI].BPBsecpau,DH            ; Set sectors/allocation unit
+        MOV     BYTE PTR CS:[DI].BPBndir,BH     ; Set # of directory entries
+        MOV     CS:[DI].BPBnsec,CX              ; Set size of disk in sectors
+        MOV     CS:[DI].BPBmediab,AH            ; Set media byte
+        MOV     BYTE PTR CS:[DI].BPBnfatsec,AL  ; Set number of FAT sectors
+        MOV     BYTE PTR CS:[DI].BPBtrksiz,BL   ; Set sectors/track
+        MOV     BYTE PTR CS:[DI].BPBnhead,DL    ; Set # of heads
+BPBdone:
+        POP     DX
+        POP     CX
+        POP     BX
+        POP     AX
+        RET
+FDGetBPB        ENDP
+;       HDGetBPB returns a pointer to the hard disk BPB for the
+;  selected unit.  The BPB contains various drive parameters
+;  such as physical disk dimensions and the size of FATs and the
+;  root directory.
+;
+;  Input:       AL =    Drive number
+;  Destroys:    None
+;  Output:      CS:DI = Pointer to BPB
+        ASSUME  DS:NOTHING,ES:NOTHING
+HDGetBPB        PROC
+        PUSH    BX
+        MOV     BL,AL                   ; Get pointer to per drive info.
+        XOR     BH,BH
+        ADD     BX,BX
+        MOV     DI,CS:HDinfo[BX]
+        POP     BX
+        RET
+HDGetBPB        ENDP
+        ASSUME  DS:NOTHING,ES:NOTHING
+BlockIfLocked   Proc    Near            ; Block the current process if it has
+        pushf                           ;  been locked out by an Int 13 request.
+bifl1:  cli                             ;  Otherwise, set the busy flag to block
+        cmp     SemInt13,0              ;  out Int 13 requests.
+        jz      bifl2
+        push    dx
+        push    cx
+        push    bx
+        push    ax
+        mov     ax,cs
+        mov     bx,offset SemInt13
+        xor     cx,cx
+        mov     dx,BlockProcess
+        call    DosFunction
+        pop     ax
+        pop     bx
+        pop     cx
+        pop     dx
+        jmp     bifl1
+bifl2:
+        mov     SemDiskIO,1
+        popf
+        ret
+BlockIfLocked   endp
+SUBTTL  Routines that interface to hard disk controller
+PAGE    +
+;***    HDCommand - send a command to the hard disk controller
+;
+;       HDCommand will send the previously set up command block
+;       to the hard disk controller.
+;
+;       ENTRY   AL = value to be put in interrupt/DMA mask
+;       EXIT    AL = status port value
+;       USES    AX,CX,DX,SI
+HDCommand       PROC
+        mov     dx,HD_PSEL              ; point to select port
+        out     dx,al
+;;      mov     cx,10                   ;BUGBUG - timing prob. w/ expansion box?
+;;hdcom0: loop  hdcom0                  ;BUGBUG - timing prob. w/ expansion box?
+        inc     dx                      ; point to mask port
+        out     dx,al
+        mov     dx,HD_PSTAT
+hdcom1: in      al,dx                   ; get status
+        and     al,0FH
+        cmp     al,0DH                  ; test for busy, command/data, request
+        jnz     hdcom1
+        mov     si,OFFSET Fixed.DCB
+        mov     cx,6
+        cld
+        dec     dx                      ; point to data port
+hdcom2: lodsb
+        out     dx,al
+        loop    hdcom2
+        inc     dx
+;;      mov     cx,10                   ;BUGBUG - timing prob. w/ expansion box?
+;;hdcom3: loop  hdcom3                  ;BUGBUG - timing prob. w/ expansion box?
+        in      al,dx
+        ret
+HDCommand       ENDP
+;***    HDWaitReq - wait for request bit in status register
+;
+;       HDWaitReq will pause until the request bit in the hard disk
+;       status register is set.
+;
+;       ENTRY
+;       EXIT    AL = status byte
+;       USES    AX,DX
+HDWaitReq       PROC
+        mov     dx,HD_PSTAT
+        in      al,dx
+        test    al,01h                  ; request bit?
+        jz      HDWaitReq
+        ret
+HDWaitReq       ENDP
+SUBTTL  Routines that interface to floppy disk controller
+PAGE    +
+;***    GetDrivePtr - compute ptr to per drive info.
+;
+;       GetDrivePtr returns a pointer to the per-drive information
+;       for the current drive.  Should not be called before the
+;       current drive is set up by Sel765 in state CALC.
+;
+;       EXIT    BX = pointer to per drive table
+;       USES    BX
+GetDrivePtr     PROC
+        mov     bx,cs:Floppy.Current
+        add     bx,bx
+        mov     bx,cs:FDinfo[bx]
+        ret
+GetDrivePtr     ENDP
+;       GetFloppyParam is called to get a disk parameter from the parameter
+;  block set up by the BIOS.  This block allows disk parameters to be changed
+;  from the standard.
+;
+;  Input:       AL = parameter desired (see FloppyParam structure)
+;  Destroys:    AX
+;  Output:      AL = parameter byte desired
+GetFloppyParam  PROC
+        PUSH    DS
+        PUSH    BX
+        XOR     AH,AH
+        MOV     BX,AX
+        XOR     AX,AX
+        MOV     DS,AX                   ; Point to INT area
+        LDS     AX,DWORD PTR DS:(4*1EH) ; Get pointer to param block
+        ADD     BX,AX                   ; Add in block offset
+        MOV     AL,[BX]
+        POP     BX
+        POP     DS
+        RET
+GetFloppyParam  ENDP
+;       Recalibrate the current drive.  Clear Restore flag, set cylinder to
+;  unknown and issue command to controller.
+;
+;  Destroys:    AX,BX,DX
+;
+Rcl765  PROC
+        AND     CS:[BX].DrvFlag,NOT Frestor     ; Have restored drive
+        MOV     CS:[BX].CurCyl,-1       ; Flag don't know where we are
+        MOV     AL,FD_CRESET
+        CALL    Put765                  ; Put out reset command
+        MOV     AX,Floppy.Current       ; Get current drive
+        CALL    Put765                  ; Tell controller which drive
+        RET
+Rcl765  ENDP
+;       Reset the controller.
+;
+;  Destroys:    AX,CX,DX
+;
+Rst765  PROC
+        MOV     AL,CS:Floppy.DOR
+        AND     AL,NOT(DORmask)
+        MOV     DX,FD_PSEL
+        OUT     DX,AL
+        MOV     CX,10000
+RstDelayLoop:
+        loop    RstDelayLoop
+        OR      AL,DORmask
+        MOV     CS:Floppy.DOR,AL                ; Update value
+        OUT     DX,AL
+        RET
+Rst765  ENDP
+;       Load the drive specs into the controller.
+;
+;  Destroys:    AX,DX
+;
+Spec765 PROC
+        MOV     AL,FD_CSPEC
+        CALL    Put765
+        MOV     AL,Spec1
+        CALL    GetFloppyParam
+        CALL    Put765
+        MOV     AL,Spec2
+        CALL    GetFloppyParam
+        CALL    Put765
+        RET
+Spec765 ENDP
+;       Get the interrupt status from the controller and into AX
+;
+;  Destroys:    AX,CX,DX
+;
+Sense765        PROC
+        MOV     AL,FD_CSENSE            ; Get status
+        CALL    Put765
+        CALL    Get765                  ; Read ST0
+        PUSH    AX                      ; Save status
+        CALL    Get765                  ; Read PCN (present cylinder number)
+        POP     AX                      ; Restore status
+        MOV     CL,6
+        SHR     AL,CL                   ; Shift bits down
+        AND     AX,3                    ; Leave only error bits
+        RET
+Sense765        ENDP
+;       Select the current drive.  Return carry set if must wait until drive is
+;  ready. FloppyExecute will be called again when the drive is ready.  The
+;  code must wait either for a motor start or head load delay, otherwise it
+;  returns with carry clear.
+;
+;  Destroys:    AX,BX,CX,DX
+;
+Sel765  PROC
+        MOV     DX,FD_PSEL              ; set DX = Digital Output Register
+        MOV     CL,Floppy.Unit          ; Get unit we want to use
+        XOR     CH,CH                   ; CX = wanted unit
+        CMP     Single,0                ; Single drive system?
+        JE      Sel765Double            ; No, Unit is accurate
+        MOV     CL,CH                   ; Yes, there is only drive 0
+Sel765Double:
+        CMP     CX,Floppy.Current       ; Wanted same as current?
+        MOV     Floppy.Current,CX       ; Set new current unit
+        JNE     SelectUnit              ; No, must select new drive
+        ADD     CL,4
+        MOV     AL,1
+        SHL     AL,CL                   ; AL = Bit for drive's motor on
+        TEST    AL,Floppy.DOR           ; Is the drive's motor still on?
+        JE      SelectUnit              ; No, must turn it back on
+        MOV     AL,Floppy.DOR
+        OUT     DX,AL                   ; ? For some reason output value again
+        CLC                             ; Clear carry, don't have to wait
+        RET
+SelectUnit:
+        MOV     AL,NOT(3)               ; Drive select is low 2 bits
+        AND     AL,Floppy.DOR           ; Lose old select bits
+        OR      AL,DORmask
+        MOV     CL,BYTE PTR Floppy.Current ; get unit number
+        OR      AL,CL                   ; Put in new select bits
+        MOV     Floppy.DOR,AL           ; Save new bits
+        ADD     CL,4
+        MOV     AL,1
+        SHL     AL,CL                   ; Get bit for motor is on
+        TEST    AL,Floppy.DOR           ; Is drive's motor on?
+        JE      SelectStartMotor        ; No, must start motor
+        MOV     AL,Floppy.DOR
+        OUT     DX,AL                   ; Load the head
+        MOV     AX,DelayLoad            ; Load head delay
+        CALL    SetTimer1
+        RET
+SelectStartMotor:
+        OR      Floppy.DOR,AL           ; Add in motor start bit
+        MOV     AL,Floppy.DOR
+        OUT     DX,AL                   ; Start the motor
+        MOV     AL,DelayMotor
+        CALL    GetFloppyParam          ; Get the proper delay time in 1/8 sec
+        mov     cl,125
+        mul     cl                      ; convert to milliseconds
+        CALL    SetTimer1               ; Set timer for motor startup
+        RET
+Sel765  ENDP
+;       Seek to the correct cylinder.  Set carry if have to wait for operation
+;  to complete (we are not on right cylinder).
+;
+;  Destroys:    AX,BX,DX
+;
+Seek765 PROC
+        MOV     AX,Floppy.Cyl           ; Get cylinder wanted
+        CMP     AX,CS:[BX].CurCyl       ; Already on cylinder?
+        JE      SeekDone                ; Yes, return with carry clear
+        MOV     CS:[BX].CurCyl,AX       ; Set the new current cylinder
+        MOV     AL,FD_CSEEK
+        CALL    Put765                  ; Seek command
+        MOV     AL,Floppy.Head          ; Get head desired
+        SHL     AL,1
+        SHL     AL,1                    ; Move head # 2 bits left
+        ADD     AL,BYTE PTR Floppy.Current      ; Low 2 bits are unit (hhuu)
+        CALL    Put765                  ; Put out drive and head select
+        MOV     AX,Floppy.Cyl
+        TEST    Floppy.Flags,F2step     ; Need to double step?
+        JE      SeekNoDouble            ; No
+        ADD     AX,AX                   ; Yes, double cylinder number
+SeekNoDouble:
+        CALL    Put765                  ; Give controller the cylinder
+        STC                             ; Set carry, must wait for seek intr.
+SeekDone:
+        RET
+Seek765 ENDP
+;       Start the Read/write.  Set up the DMA channel and give a read or write
+;  command to the controller depending on flag.
+;
+;  Destroys:    AX,CX,DX
+;
+RdWr765 PROC
+        mov     ah,FD_DMA
+        mov     si,OFFSET Floppy
+        TEST    Floppy.Flags,Fwrite     ; Is this a write?
+        JNE     WriteSetup              ; Yes
+        MOV     AL,DMA_READ             ; No, read
+        CALL    DMAsetup                ; Set up the DMA
+        MOV     AL,FD_CREAD             ; Want to read
+        JMP     SHORT RdWrLoc           ; Now put out rest of command
+WriteSetup:
+        MOV     AL,DMA_WRITE
+        CALL    DMAsetup                ; Set DMA up for write
+        MOV     AL,FD_CWRITE            ; Want to write
+RdWrLoc:
+        CALL    Put765                  ; Put out command
+        MOV     AL,Floppy.Head
+        ADD     AL,AL
+        ADD     AL,AL                   ; Form HHxx Binary
+        ADD     AL,BYTE PTR Floppy.Current      ; Form HHUU
+        CALL    Put765                  ; Output unit and head
+        MOV     AX,Floppy.Cyl
+        CALL    Put765                  ; Output cylinder
+        MOV     AL,Floppy.Head
+        CALL    Put765                  ; Output head again?
+        MOV     AL,Floppy.Sector
+        inc     al
+        CALL    Put765                  ; Output sector
+        MOV     AL,SectorSize
+        CALL    GetFloppyParam          ; Get sector size code
+        CALL    Put765                  ; Tell controller sector size
+        MOV     AL,CylSize
+        CALL    GetFloppyParam          ; Get number of sectors/cylinder
+        CALL    Put765                  ; Tell controller
+        MOV     AL,DataGap              ; Gap length for read/write
+        CALL    GetFloppyParam
+        CALL    Put765                  ; Tell controller gap length
+        MOV     AL,ValueDTL
+        CALL    GetFloppyParam          ; Get value for DTL
+        CALL    Put765                  ; Since bytes/sector#0, this is a
+                                        ; meaningless value, but controller
+                                        ; wants to see something
+        RET
+RdWr765 ENDP
+;       Fini765 gets the completion status.
+;
+;  Destroys:    AX,CX,DX
+;  Returns:     AL
+;
+Fini765 PROC
+        push    es
+        push    di
+        push    cs
+        pop     es
+        mov     di,OFFSET Floppy.ST0
+        MOV     CX,7
+fini1:  CALL    Get765
+        stosb
+        loop    fini1
+        mov     al,Floppy.ST0
+        mov     cl,6
+        SHR     AL,CL
+        AND     AX,3                    ; Mask down to value to return
+        pop     di
+        pop     es
+        RET
+Fini765 ENDP
+;       Put765 writes a command to the controller.
+;
+;  Input:       AL = value
+;  Destroys:    AX,DX
+;
+Put765  PROC
+        PUSH    AX                      ; Save the value to write
+PutWaitLoop:
+        MOV     DX,FD_PSTAT
+        IN      AL,DX                   ; Get status
+        AND     AL,FD_SDIO+FD_SRQM
+        CMP     AL,FD_SRQM                      ; Controller ready for data?
+        JNE     PutWaitLoop             ; No, keep waiting
+        POP     AX                      ; Get value back
+        MOV     DX,FD_PDAT
+        OUT     DX,AL                   ; Put out value
+        RET
+Put765  ENDP
+;       Get765 gets a value back from the controller into AL.
+;
+;  Destroys:    AX,DX
+;  Returns:     AL
+;
+Get765  PROC
+        MOV     DX,FD_PSTAT
+        IN      AL,DX                   ; Get status
+        AND     AL,FD_SDIO+FD_SRQM
+        CMP     AL,FD_SDIO+FD_SRQM              ; Controller data available?
+        JNE     Get765                  ; No, wait for it
+        MOV     DX,FD_PDAT
+        IN      AL,DX                   ; Get value from controller
+        ret
+Get765  ENDP
+Code    ENDS
+        END
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.OBJ b/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.OBJ
new file mode 100644
index 0000000..daf953a
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMDSK.OBJ
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.ASM b/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.ASM
new file mode 100644
index 0000000..6cfefbe
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.ASM
@@ -0,0 +1,1424 @@
+        TITLE   MTCON - Console device driver for MT-MSDOS
+        page    ,132
+;;      TODO -
+;;              split CON and KBD
+;;              interruptible waits and unwinding
+;;              per screen keyboard buffers
+;------------------------------------------------------------------------
+;               Revision History
+;
+;       V1.00   04/10/84        M.A.Ulloa
+;               First Implementation: Only one segment used and only
+;               one screen in the color card (alpha mode).
+;
+;       V1.01   04/15/84        M.A.Ulloa
+;               Re-enabled the blocking of writing from processes not
+;               with the current screen.
+;
+;       V1.02   04/16/84        M.A.Ulloa
+;               Increased to 8 the num of screens. Added the screen
+;               blanking when reading and writing the screen data
+;               (see BLANK switch). Added screen # for writes.
+;
+;       V1.03   04/17/84        M.A.Ulloa
+;               Corrected problem with flush.
+;
+;       V1.05   04/30/84        A.R.Whitney
+;               Added conditional compilation to allow linking with
+;               resident BIOS.
+;
+;       V1.06   05/08/84        A.R.Whitney
+;               Added ANSI escape sequences.  Conditional on ANSI.
+;
+;       V1.07   05/15/84        A.R.Whitney
+;               Fixed compatibility problems with Eagle PC Turbo.
+;               Fixed BLANK conditional code to allow saving graphics
+;               mode screens.
+;               Added enable/disable 25th line to Ansi.
+;
+;       V1.08   05/22/84        A.R.Whitney
+;               Fixed problem with scrolling in screen modes other
+;               than 80x25.  Bug due to 25th line stuff.
+;
+;------------------------------------------------------------------------
+;DEBUGFLG       =       1
+.xlist
+        include DEFDBUG.INC
+.list
+FALSE   EQU     0
+TRUE    EQU     NOT FALSE
+CVERS   equ     01                      ; update version number!!
+CREV    equ     08
+BLANK   equ     TRUE                    ; blank screen during data r/w
+INBIOS  equ     TRUE                    ; link with BIOS
+ANSI    equ     TRUE                    ; include ANSI escape sequences
+  LINE25 equ    TRUE                    ;   special 25th line like VT52
+EAGLE   equ     TRUE                    ; Eagle PC ROM botches CRT_LEN
+subttl  Screen Information Block Definition
+page
+;------------------------------------------------------------------------
+;       Screen Information Block (SIB) Definition
+;
+;       This structure contains all information necessary to
+; describe the state of the screen, plus pointers to buffers
+; which contain the actual screen content.
+;
+;------------------------------------------------------------------------
+MaxSEG  equ     2                       ; NOTE: assumption is made in the
+                                        ;   code that all SIB's have same
+                                        ;   number os SEGs
+SEGst   struc
+SizeNeeded      dw      0               ; needed size for seg, (0 = unused)
+MemFlag         dw      ?               ; maintened by system (0 = in mem)
+MPointer        dd      ?               ; vaild iff MemFlag == 0
+SEGst   ends
+;------------------------------------------------------------------------
+MaxSIB  equ     8                       ; maximum number of Screens
+IF      ANSI
+TermSize        EQU     20              ; max. size of terminal emulation state
+ENDIF
+SIBst   struc
+ctlS            db      0               ; if the screen is NOT frozen = 0
+                                        ; NOTE: this field should be the
+                                        ;   FIRST of each SIB !! (see ConWrit)
+OffsetVal       dw      7               ; start of Seg Descriptors
+SegCnt          dw      MaxSeg          ; max number of Segments
+SIBlen          dw      (SIZE SIBst)    ; length of the SIB
+;--- Segments
+                db      ((SIZE SEGst) * MaxSeg) dup (?)
+;--- PC video state info
+xCRT_MODE       DB      ?
+xCRT_COLS       DW      ?
+xCRT_LEN        DW      ?
+xCRT_START      DW      ?
+xCURSOR_POSN    DW      8 DUP(?)
+xCURSOR_MODE    DW      ?
+xACTIVE_PAGE    DB      ?
+xADDR_6845      DW      ?
+xCRT_MODE_SET   DB      ?
+xCRT_PALETTE    DB      ?
+xTERM_STATE     DB      TermSize DUP(?)
+SIBst   ends
+subttl  Request packet definitions
+page
+;------------------------------------------------------------------------
+;       Request packet offset definitions
+;
+CMDLEN  =       0                       ;LENGTH OF THIS COMMAND
+UNIT    =       1                       ;SUB UNIT SPECIFIER
+CMD     =       2                       ;COMMAND CODE
+STATUS  =       3                       ;STATUS
+MEDIA   =       13                      ;MEDIA DESCRIPTOR
+TRANS   =       14                      ;TRANSFER ADDRESS
+COUNT   =       18                      ;COUNT OF BLOCKS OR CHARACTERS
+START   =       20                      ;FIRST BLOCK TO TRANSFER
+subttl  IBM-PC ROM Data area Locations
+page
+;------------------------------------------------------------------------
+;       IBM-PC ROM Data area Locations
+;
+RomData SEGMENT AT 40H
+        ORG     1AH
+BufferHead      DW      ?
+BufferTail      DW      ?
+KeyBuffer       DW      16 DUP (?)
+KeyBufLen       equ     ($-KeyBuffer)   ; length of KeyBuffer
+        ORG     49H
+CRT_MODE        DB      ?
+CRT_COLS        DW      ?
+CRT_LEN         DW      ?
+CRT_START       DW      ?
+CURSOR_POSN     DW      8 DUP(?)
+CURSOR_MODE     DW      ?
+ACTIVE_PAGE     DB      ?
+ADDR_6845       DW      ?
+CRT_MODE_SET    DB      ?
+CRT_PALETTE     DB      ?
+CrtLen          EQU     ($-CRT_MODE)    ; length of screen state area
+RomData ENDS
+MonoSc  SEGMENT AT 0B000H
+;--- 4k of screen memory
+MonoSc  ENDS
+ColorSc SEGMENT AT 0B800H
+;--- 16k of screen memory
+ColorSc ENDS
+BRKADR  equ     006CH                   ; Break vector address
+subttl  Device Header
+page
+BiosSeg         group   Code,BiosInit
+Code    Segment byte public     'CODE'
+;------------------------------------------------------------------------
+;       Device Header
+;
+assume  cs:Code,ds:NOTHING,es:NOTHING,ss:NOTHING
+        PUBLIC  CONDEV
+IF      INBIOS
+        extrn   AUXDEV:FAR
+CONDEV  dd      AUXDEV
+ELSE
+CONDEV  dw      0FFFFh,0FFFFh
+ENDIF   ;INBIOS
+;*** should ioctl bit be set for gen ioctl too?
+        dw      1100000000010011b       ; console in and out
+        dw      Strategy
+        dw      Entry
+        db      "CON     "
+;------------------------------------------------------------------------
+;       Command dispatch table
+;
+ComTbl:
+;--- 2.0
+        dw      OFFSET BiosSeg:$ConInit ; Initialization function
+        dw      StatusComplete          ; Media Check
+        dw      StatusComplete          ; Build BPB
+        dw      CmdErr                  ; IOCTL Input
+        dw      $ConRead                ; Input (Read)
+        dw      $ConRdnd                ; Non-Destructive read, no wait
+        dw      StatusComplete          ; Input Status
+        dw      $ConFlsh                ; Input Flush
+        dw      $ConWrit                ; Output (Write)
+        dw      $ConWrit                ; Output with verify
+        dw      StatusComplete          ; Output Status
+        dw      StatusComplete          ; Output Flush
+        dw      StatusComplete          ; IOCTL Output
+;--- 3.0
+        dw      StatusComplete          ; Device Open
+        dw      StatusComplete          ; Device Close
+        dw      StatusComplete          ; Removable Media
+;--- 4.0
+        dw      $GenIOCTL               ; Generic IOCTL
+        dw      $ConStop                ; Pause Device
+        dw      $ConStart               ; Continue Device
+ComTblEnd:
+CTSIZE  equ     (ComTblEnd - ComTbl)/2  ; number of table entries
+subttl  Device Data Area
+page
+;------------------------------------------------------------------------
+;       Device Data Area
+;
+SaveFlg db      0                       ; Screen being saved flag, (true = 1)
+IF      INBIOS
+        EXTRN   DosFunction:DWORD
+ELSE
+DosFunction dd  ?                       ; pointer to dos "helper" functions
+ENDIF   ;INBIOS
+AltAH   db      0                       ; Side buffer for input
+CurrSc  dw      0                       ; Current screen number
+CurrSIB dw      SIB                     ; offset to the current SIB
+SIB     SIBst   MaxSIB dup (<>)         ; allocate room for SIB's
+IF      EAGLE
+ScreenLen       db      08h             ; table of (high byte of) regen. buffer
+                db      08h             ;  len.  Indexed by screen mode.
+                db      10h             ; 80x25 text modes
+                db      10h
+                db      40h             ; graphics modes
+                db      40h
+                db      40h
+                db      10h             ; monochrome
+ENDIF
+IFDEF   DEBUGFLG
+IF      INBIOS
+        EXTRN   BUGBITS:BYTE,DPRINTF:NEAR
+ELSE
+BUGBITS db      0ffh,0ffh
+ENDIF
+ENDIF
+subttl  Device Entry Points
+page
+;------------------------------------------------------------------------
+;       2.0 Interrupt Routine (Not Used)
+;
+EntryP  proc    far
+Entry:  ret
+EntryP  endp
+;------------------------------------------------------------------------
+;       2.0 Strategy Routine, main entry point
+;
+; entry
+;       ES:BX   points to Request packet
+;
+StratP  proc    far
+Strategy:
+IF      INBIOS
+        extrn   Interrupt:NEAR
+        push    si
+        mov     si,OFFSET CS:ComTbl
+        jmp     Interrupt
+ELSE
+        push    ax                      ; save all
+        push    cx
+        push    dx
+        push    si
+        push    di
+        push    bp
+        push    ds
+        push    es                      ; DS = ES
+        pop     ds
+        push    es
+        push    bx
+        mov     al, byte ptr ds:[bx].CMD
+        cmp     al,CTSIZE               ; Command within range?
+        jae     CmdErr                  ; no must be an error
+        mov     cx, word ptr ds:[bx].COUNT
+        les     di, dword ptr ds:[bx].TRANS
+        xor     ah,ah
+        mov     si, offset ComTbl
+        add     si,ax
+        add     si,ax
+        jmp     word ptr cs:[si]        ; dispatch
+ENDIF   ;INBIOS
+StratP  endp
+subttl  Exit Routines
+page
+;------------------------------------------------------------------------
+;       Exit Routines, Common to all device functions
+;
+IF      INBIOS
+        extrn   StatusComplete:NEAR,StatusError:NEAR,StatusDevReady:NEAR
+        extrn   CmdErr:NEAR
+ELSE
+assume  ds:NOTHING,es:NOTHING
+StatusDevReady:
+        mov     ah,00000011b            ; device busy
+        jmp     short errEx
+CmdErr:
+        mov     al,3                    ; Unknown command Error
+StatusError:
+        mov     ah,10000001b
+        jmp     short errEx
+ExitP   proc    far
+StatusComplete: mov     ah,00000001b
+errEx:  pop     bx
+        pop     es
+        mov     word ptr es:[bx].STATUS,ax      ; put status out
+        pop     ds
+        pop     bp
+        pop     di
+        pop     si
+        pop     dx
+        pop     cx
+        pop     ax
+        ret
+ExitP   endp
+ENDIF   ;INBIOS
+subttl  Break - Break interrupt routine
+page
+;------------------------------------------------------------------------
+;       Break interrupt routine
+;
+assume  ds:NOTHING,es:NOTHING
+Break   PROC    NEAR
+        int     32H                     ; save registers
+        cli                             ; ints should be off, make sure!
+        mov     ax,RomData
+        mov     ds,ax
+    assume      ds:RomData
+        mov     ax,offset RomData:KeyBuffer
+        mov     [BufferHead],ax
+        mov     [BufferTail],ax
+    assume      ds:NOTHING
+        mov     ax,3                    ; send char to system
+        mov     dx,5                    ; ConsInputFilter subfunction
+        call    [DosFunction]
+        jz      brk1                    ; key was eaten by system
+        mov     [AltAH],al              ; force a ^C
+brk1:
+        iret
+Break   ENDP
+SUBTTL  Keyboard interrupt routine
+PAGE
+; Replacement for ROM keyboard interrupt, tacks on the front.
+; OldKeyInterrupt is set to original contents of INT 09H.
+; The input character is passed to the O.S. console input filter
+; to determine if any special action should be taken.  The filter
+; return value indicates if the character should be saved in the
+; type ahead buffer or if it should be discarded.  A keyboard
+; semaphore exists to indicate if a process is waiting for input.
+; If the keboard semaphore is set all of the processes sleeping on
+; it are woken up.
+OldKeyInterrupt DD      ?
+KeySem          db      0               ; non-zero if someone waiting on input
+KeyboardInterrupt       PROC FAR
+        INT     32H                     ; Save regs
+        MOV     AX,RomData
+        MOV     DS,AX
+    ASSUME      DS:RomData
+        PUSHF                           ; Save flags to simulate INT
+        CALL    CS:OldKeyInterrupt      ; Now do ROM code
+; Now tell DOS keyboard had char
+        cli                             ; interrupts off!
+        mov     bx,BufferTail           ; Get tail of queue
+        cmp     bx,BufferHead           ; Anything in keyboard queue?
+        JE      NoKey                   ; No, don't requeue then
+        dec     bx
+        dec     bx
+        cmp     bx,offset RomData:KeyBuffer
+        jae     kbi1                    ; no wrap around in buffer
+        mov     bx,offset RomData:KeyBuffer+(KeyBufLen-2)
+kbi1:
+        mov     ax,[bx]                 ; get last queued char.
+        mov     dx,5                    ; ConsInputFilter subfunction
+        call    [DosFunction]
+        jnz     kbi2                    ; key should remain in buffer
+        mov     BufferTail,bx           ; discard key from buffer
+        jmp     SHORT NoKey
+kbi2:
+        cli
+        CMP     KeySem,0                ; Outstanding request?
+        JE      NoKey                   ; No, may not be inited either
+        push    ax
+        push    bx
+        push    cx
+        push    dx
+        mov     ax,cs
+        mov     bx,OFFSET KeySem
+        mov     cs:byte ptr [bx],0      ; reset keyboard semaphore
+        mov     dx,10                   ;; ProcRun
+        call    [DosFunction]           ; awaken anyone waiting on input
+        pop     dx
+        pop     cx
+        pop     bx
+        pop     ax
+NoKey:
+        IRET
+KeyBoardInterrupt       ENDP
+;-------------------------------------------------------------
+; Keyboard INT 16 intercept routine to allow console input to sleep.
+; Only console input function 1 is intercepted, all other functions
+; are allowed to go directly to the ROM BIOS.  For the function 1
+; the input status is checked, if a character is ready the function
+; is allowed to go to the ROM BIOS.  Otherwise the keyboard semaphore
+; is set and the process is put to sleep on the address of the
+; semaphore.  When a key is typed the keyboard interrupt routine
+; will wakeup any processes sleeping on this semaphore.
+;
+;       WARNING: The following routines can be entered recursively
+;                due to the fact that the ROM BIOS routines called
+;                reenable interrupts.  It's not usually a problem
+;                since interrupts will generally be processed faster
+;                than anyone can type.
+OldKbdHandler   dd      ?
+ScrnIoOk        dd      ?
+;-------------------------------------------------------------
+KeyBoardHandler proc    far
+        or      ah,ah
+        je      DoLocalRead
+        cmp     ah,1
+        je      DoLocalStat
+OldKBint:
+        jmp     [OldKbdHandler]
+DoLocalStat:
+        push    bx
+        push    ds
+        lds     bx,ScrnIoOk
+        test    byte ptr [bx],0FFh
+        pop     ds
+        pop     bx
+        jnz     OldKBint
+        xor     ax,ax
+        ret     2
+DoInt16 LABEL   FAR             ; entry for ChrIn
+DoLocalRead:
+        push    ax
+        push    bx
+        push    cx
+        push    dx
+DoLocalRd1:
+        push    ds
+        lds     bx,ScrnIoOk
+        mov     ax,ds
+        test    byte ptr [bx],0FFh
+        pop     ds
+        jnz     DoLocalRd2
+        xor     cx,cx
+        mov     dx,9                    ;; ProcBlock
+        call    [DosFunction]           ; sleep until a screen switch
+        jmp     DoLocalRd1
+DoLocalRd2:
+        mov     ah,1                    ; get console status
+        pushf                           ; simulate INT to old handler
+        cli
+        call    [OldKbdHandler]
+        cli                             ; subfunction 1 unconditionally sets IF
+        jnz     LocalRead               ; go read character
+        mov     ax,cs
+        mov     bx,OFFSET KeySem
+        mov     cs:byte ptr [bx],0FFh   ; set keyboard semaphore
+        xor     cx,cx
+        mov     dx,9                    ;; ProcBlock
+        call    [DosFunction]           ; sleep until a char is typed
+        jmp     DoLocalRd1
+LocalRead:
+        pop     dx
+        pop     cx
+        pop     bx
+        pop     ax
+        jmp     [OldKbdHandler]         ; read the character and return
+KeyBoardHandler endp
+subttl  $ConRead - Console Input (Read)
+page
+;------------------------------------------------------------------------
+;       Console Input (Read)
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;       ES:DI = Transfer address
+;       CX = Count
+;
+assume  ds:NOTHING,es:NOTHING
+$ConRead:
+        and     cx,cx
+        jnz     jgl2
+        jmp     CRExit
+;       jcxz    CRExit                  ; no chars to read BUGBUG restore
+jgl2:   cld                             ; make sure!
+        mov     dx,word ptr ds:[bx].START       ; get screen number
+        cmp     dx,(MaxSIB-1)           ; valid number?
+        jbe     ConRLoop                ; yes, do input
+        mov     al,0BH                  ; no, READ FAULT ERROR
+        jmp     StatusError
+ConRLoop:
+        DEBUG   10h,1,<CONR:$x=$x? >,<dx,CurrSc>
+        cmp     dx,[CurrSc]
+        je      sjp0
+        call    GetSIBAdr               ; get pointer to the SIB
+        DEBUG   10h,1,<Block read wrong screen >,<>
+        call    DoPBlock                ; block the process
+        jmp     short ConRLoop          ; test flag again
+sjp0:
+        call    ChrIn
+        stosb
+;       loop    ConRLoop
+        loop    jgl3
+CRExit: jmp     StatusComplete
+jgl3:   jmp     ConRLoop
+subttl  ChrIn - Read a single character In
+page
+;------------------------------------------------------------------------
+;       Read a single character In
+;
+; exit:
+;       Character in AL
+;
+; modifies:     AX
+;
+assume  ds:NOTHING,es:NOTHING
+ChrIn:
+        DEBUG   10h,1,<in.ChrIn >,<>
+        xor     ax,ax
+        xchg    al,[AltAH]              ; Get Character & zero AltAH
+        or      al,al                   ; A char available?
+        jnz     KeyRet
+;
+;--- NOTE: The blocking on read is done at int 16h level
+;       in IBMBIO. No need to block here.
+;
+        DEBUG   10h,1,< con.do.16 >,<>
+        mov     ah,0                    ; no, do a read call
+        pushf
+        call    DoInt16
+;;      int     16h
+        DEBUG   10h,1,< con.got.$x >,<ax>
+        or      ax,ax                   ; check for non-key after BREAK
+        jnz     jgl1
+        jmp     chrin
+jgl1:   cmp     ax,7200h                ; CTRL-PRTSC ?
+        jnz     sja0
+        mov     al,10h                  ; yes, make it a ctrl-P
+sja0:   or      al,al                   ; special case?
+        jnz     KeyRet
+        mov     [AltAH],ah
+KeyRet:
+        ret
+subttl  $ConRdnd - Console non-destructive Input, no wait
+page
+;------------------------------------------------------------------------
+;       Console non-destructive Input, no wait
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+$ConRdnd:
+        mov     dx,word ptr ds:[bx].START       ; get screen number
+        cmp     dx,(MaxSIB-1)           ; valid number?
+        jbe     sjq0                    ; yes, do input
+        mov     al,0BH                  ; no, READ FAULT ERROR
+        jmp     StatusError
+sjq0:
+        DEBUG   10h,1,<CNDR:$x=$x? >,<dx,CurrSc>
+        cmp     dx,[CurrSc]
+IFDEF   DEBUGFLG
+        je      sjq1
+        jmp     ConBus
+ELSE
+        jne     ConBus                  ; not current screen, no char avail
+ENDIF
+;       call    GetSIBAdr               ; get pointer to the SIB
+;       call    DoPBlock                ; block the process
+;       jmp     short sjq0              ; test flag again
+sjq1:
+        mov     al,[AltAH]              ; char avail already?
+        or      al,al
+        jnz     rdExit
+        DEBUG   10h,1,< NRD:do.16 >,<>
+        mov     ah,1                    ; no, get status
+        int     16h
+        jz      ConBus
+        DEBUG   10h,1,< NRD:nonbus $x >,<ax>
+        or      ax,ax
+        jnz     NotBk                   ; Check for null after break
+        mov     ah,0                    ; flush the null
+        int     16h
+        jmp     $ConRdnd                ; try again
+;       jmp     short $ConRdnd          ; try again BUGBUG
+NotBk:
+        cmp     ax,7200h                ; CTRL-PRTSC ?
+        jnz     rdExit
+        mov     al,10h                  ; yes, make it a ctrl-P
+rdExit:
+        mov     byte ptr ds:[bx].MEDIA,al       ; save character
+DoExit: jmp     StatusComplete
+ConBus: DEBUG   10h,1,< ConBus - >,<>
+        jmp     StatusDevReady
+subttl  $ConFlsh - Console Flush Input
+page
+;------------------------------------------------------------------------
+;       Console Flush Input
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+$ConFlsh:
+        mov     dx,word ptr ds:[bx].START       ; get screen number
+        cmp     dx,(MaxSIB-1)           ; valid number?
+        jbe     sjr0                    ; yes, do flush
+        mov     al,0BH                  ; no, READ FAULT ERROR
+        jmp     StatusError
+sjr0:
+        cmp     dx,[CurrSc]
+        je      sjr1
+        call    GetSIBAdr               ; get pointer to the SIB
+        call    DoPBlock                ; block the process
+        jmp     short sjr0              ; test flag again
+sjr1:
+        mov     [AltAH],0               ; clear side bufer
+        push    ds
+        mov     ax,RomData
+        mov     ds,ax
+    assume      ds:RomData
+        cli                             ; Disable interrupts
+        mov     ax,offset RomData:KeyBuffer     ; Start of Rom buffer
+        mov     [BufferHead],ax
+        mov     [BufferTail],ax         ; Empty the queue
+        sti
+        pop     ds
+    assume      ds:NOTHING
+        jmp     StatusComplete
+subttl  $ConWrit - Console Output (Write)
+page
+;------------------------------------------------------------------------
+;       Console Output (Write)
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;       ES:DI = Transfer address
+;       CX = Count
+;
+assume  ds:NOTHING,es:NOTHING
+$ConWrit:
+        jcxz    CWExit
+        mov     dx, word ptr ds:[bx].START      ; get screen number
+        cmp     dx,(MaxSIB-1)           ; valid screen number?
+        jbe     sjb0
+        mov     al,0AH                  ; no, write fault error
+        jmp     StatusError
+sjb0:   push    cs
+        pop     ds
+    assume      ds:Code
+        mov     bx,[CurrSIB]
+ConWLoop:
+        cmp     dx,[CurrSc]             ; Is it to the current screen?
+        je      sjb2                    ; yes, do not block
+        call    GetSIBAdr               ; get pointer to the SIB
+sjb1:   call    DoPBlock                ; block the process
+        jmp     short ConWLoop          ; test ALL flags again
+sjb2:
+        cmp     [bx].ctlS,0             ; is the screen frozen?
+        je      sjb3
+        mov     ax,bx                   ; AX = [CurrSIB] = [CurrSIB].ctlS !!!!
+        jmp     short sjb1              ; yes, block the process
+sjb3:
+        cmp     [SaveFlg],0             ; are we in the middle of a save?
+        je      sjb4                    ; no, do write
+        mov     ax,offset SaveFlg
+        jmp     short sjb1              ; yes, block...
+sjb4:
+        mov     al,es:[di]              ; get a character
+        inc     di
+        call    CharOut
+        loop    ConWLoop
+CWExit: jmp     StatusComplete
+subttl  CharOut - Output a character to the screen
+page
+;------------------------------------------------------------------------
+;       Output a character to the screen
+;
+; entry:
+;       AL =    Character to write
+;
+; preserves:
+;       BX, CX, DX, DI, DS & ES
+;
+assume  ds:NOTHING,es:NOTHING
+IF      ANSI
+        include ansi.inc
+ELSE
+CharOut:
+        push    bx
+        push    di
+        mov     bx,7
+        mov     ah,14
+        int     10h                     ; Write Character
+        pop     di
+        pop     bx
+        ret
+ENDIF
+subttl  $GenIOCTL - Generic IOCTL
+page
+;------------------------------------------------------------------------
+;       Generic IOCTL
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;
+;--- Offsets into the request packet
+;*** Check offset are correct
+FunCode =       14                      ; Function Code
+FunCat  =       13                      ; Function Category
+;***
+RegSI   =       15                      ; Contents of SI
+RegDI   =       17                      ; Contents of DI
+DatBuf  =       19                      ; Pointer to data buffer
+;--- Code & Category definitions
+IOC_SC  =       03h                     ;--- Screen Control
+IOSC_LS =       41h                     ; Locate SIB
+IOSC_SS =       42h                     ; save segment
+IOSC_RS =       43h                     ; restore segment
+IOSC_EI =       44h                     ; re-enable i/o
+IOSC_IS =       45h                     ; initialize screen
+assume  ds:NOTHING,es:NOTHING
+$GenIOCTL:
+        cmp     byte ptr ds:[bx].FunCode,IOC_SC
+        jne     GI_BadCode              ; function not suported
+        mov     si,word ptr ds:[bx].RegSI
+        mov     al,byte ptr ds:[bx].FunCat
+        cmp     al,IOSC_LS
+        jne     sjc0
+        jmp     short do_IOSC_LS
+sjc0:   cmp     al,IOSC_SS
+        jne     sjc1
+        jmp     short do_IOSC_SS
+sjc1:   cmp     al,IOSC_RS
+        jne     sjc2
+        jmp     do_IOSC_RS
+sjc2:   cmp     al,IOSC_EI
+        jne     sjc3
+        jmp     do_IOSC_EI
+sjc3:   cmp     al,IOSC_IS
+        jne     GI_BadCode
+        jmp     do_IOSC_IS
+GI_BadCode:
+        jmp     CmdErr                  ; error exit: Command error
+subttl  do_IOSC_LS - Locate SIB
+page
+;------------------------------------------------------------------------
+;       Locate SIB
+;
+; entry:
+;       SI = SIB Number
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+do_IOSC_LS:
+        cmp     si,(MaxSIB-1)           ; index within range?
+        ja      BadNum
+        push    bx
+        push    ds
+        push    cs
+        pop     ds
+    assume      ds:Code
+        cmp     si,[CurrSc]             ; is it the current screen?
+        je      CurrLS
+        mov     [CurrSc],si             ; no, just switch curr screens
+        mov     dx,si                   ; index
+        call    GetSIBAdr               ; get pointer to SIB
+        mov     [CurrSIB],ax            ; save pointer to curr SIB
+        jmp     short retLS
+CurrLS:
+        mov     [SaveFlg],1             ; Signal we are Saving the screen
+;*** Only one segment for now
+        mov     ax,0
+        call    GetSegAdr               ; on return BX points to segment
+        mov     ax,RomData
+        mov     es,ax
+    assume      es:RomData
+IF      EAGLE
+        mov     al,es:[CRT_MODE]
+        xor     ah,ah
+        mov     si,ax
+        mov     ah,ScreenLen[si]
+        xor     al,al
+ELSE
+        mov     ax,es:[CRT_LEN]
+    assume      es:NOTHING              ; not true, but just to be safe
+ENDIF
+        mov     [bx].SizeNeeded,ax      ; save size of segment
+        mov     ax,dx                   ; pointer to current SIB
+retLS:
+        pop     ds
+        pop     bx
+    assume      ds:NOTHING
+        mov     word ptr ds:[bx].DatBuf,ax      ; offset
+        mov     word ptr ds:[bx].DatBuf+2,cs    ; segment
+        mov     word ptr ds:[bx].RegSI,0        ; operation ok
+        jmp     StatusComplete
+BadNum:
+        mov     word ptr ds:[bx].RegSI,1        ; bad SIB number error
+        jmp     StatusComplete
+subttl  do_IOSC_SS - Save Segment
+page
+;------------------------------------------------------------------------
+;       Save Segment
+;
+; entry:
+;       SI = Segment Index (into the Current SIB)
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+do_IOSC_SS:
+        cmp     si,(MaxSeg-1)           ; within range?
+BadNumJ1:
+        ja      BadNum                  ; no, somebody screwed up...
+        push    bx
+        push    ds
+        cmp     si,0                    ; first segment save?
+        jne     nfSS                    ; no, just save screen data
+;--- save screen state data
+        push    si                      ; save index
+        mov     ax,RomData
+        mov     ds,ax                   ; DS = ROM data area
+    assume      ds:RomData
+        mov     si,offset RomData:CRT_MODE
+        mov     cx,CrtLen               ; length of screen state data
+        push    cs
+        pop     es
+    assume      es:Code
+        mov     di,[CurrSIB]
+        lea     di,[di].xCRT_MODE
+        cld
+    rep movsb                           ; copy ROM info to SIB area
+IF      ANSI
+        push    cs
+        pop     ds
+    assume      ds:Code
+        mov     si,offset AnsiState     ; point to ANSI state info
+        mov     cx,AnsiSize
+    rep movsb                           ; save ANSI state info in SIB
+ENDIF
+        pop     si                      ; restore segment index
+;--- save a segment of screen data
+nfSS:
+        push    cs
+        pop     ds
+    assume      ds:Code
+        mov     ax,si
+        call    GetSegAdr               ; get adress of segment and curr SIB ptr
+        mov     cx,[bx].SizeNeeded      ; CX = Ammount to transfer
+        shr     cx,1                    ; words!
+        les     di,[bx].MPointer        ; ES:DI = Screen save area
+    assume      es:NOTHING
+;*** For now we are using only one segment
+        mov     si,dx                   ; SI points to the current SIB
+        mov     bx,ColorSc              ; assume color card
+        cmp     [si].xCRT_MODE,7        ; is this a BW monitor?
+        jne     do_save
+        mov     bx,MonoSc
+do_save:
+IF      BLANK
+        mov     dx,[si].xADDR_6845      ; point to mode register
+        add     dx,4
+        mov     al,[si].xCRT_MODE_SET   ;  and get value
+        and     al,NOT 8
+        out     dx,al                   ; turn off video
+ENDIF
+        mov     ds,bx                   ; DS points to apropiate screen area
+    assume      ds:NOTHING
+        mov     si,0
+        cld
+    rep movsw                           ; copy the screen
+IF      BLANK
+        or      al,8
+        out     dx,al                   ; turn on video
+ENDIF
+        pop     ds
+        pop     bx
+        mov     word ptr ds:[bx].RegSI,0        ; operation ok
+        jmp     StatusComplete
+subttl  do_IOSC_RS - Restore Segment
+page
+;------------------------------------------------------------------------
+;       Restore Segment
+;
+; entry:
+;       SI = Segment Index (into the Current SIB)
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+do_IOSC_RS:
+        cmp     si,(MaxSeg-1)           ; within range?
+        ja      BadNumJ1                ; no, somebody screwed up...
+        push    bx
+        push    ds
+        push    cs
+        pop     ds
+    assume      ds:Code
+        cmp     si,0                    ; first segment save?
+        jne     nfRS                    ; no, just restore screen data
+;--- restore screen state data
+        push    si                      ; save index
+        mov     si,[CurrSIB]
+        push    si
+        lea     si,[si].xCRT_MODE
+        mov     ax,RomData
+        mov     es,ax                   ; ES = ROM data area
+    assume      es:RomData
+        mov     cx,CrtLen               ; length of screen state data
+        mov     di,offset RomData:CRT_MODE
+        cld
+    rep movsb                           ; copy ROM info from SIB area
+IF      ANSI
+        push    es
+        push    cs
+        pop     es
+    assume      es:Code
+        mov     di,offset AnsiState     ; point to ANSI state info
+        mov     cx,AnsiSize
+    rep movsb                           ; restore ANSI state info from SIB
+        pop     es
+    assume      es:RomData
+ENDIF
+;--- Setup new screen state
+        pop     si
+        mov     al,[si].xCRT_MODE
+        cmp     al,7                    ; is this the BW monitor?
+        jne     sjd0
+        mov     al,2                    ; this is the "real" mode
+sjd0:
+        mov     ah,0
+        int     10h                     ; set new mode
+        mov     cx,[si].xCURSOR_MODE
+        mov     ah,1
+        int     10h                     ; set cursor type
+        mov     dx,[si].xCURSOR_POSN
+        mov     bh,[si].xACTIVE_PAGE
+        mov     ah,2
+        int     10h                     ; set cursor position
+        mov     al,[si].xACTIVE_PAGE
+        mov     ah,5
+        int     10h                     ; set page #
+        mov     dx,[si].xADDR_6845
+        add     dx,5
+        mov     al,[si].xCRT_PALETTE
+        out     dx,al                   ; set color port
+        mov     es:CRT_PALETTE,al
+        pop     si                      ; restore segment index
+;--- restore a segment of screen data
+nfRS:
+        mov     ax,si
+        call    GetSegAdr               ; get adress of segment
+        mov     cx,[bx].SizeNeeded      ; CX = Ammount to transfer
+        shr     cx,1                    ; words!
+        lds     si,[bx].MPointer        ; DS:SI = Screen save area
+    assume      ds:NOTHING
+;*** For now we are using only one segment
+        mov     di,dx                   ; DI points to the current SIB
+        mov     bx,ColorSc              ; assume color card
+        cmp     cs:[di].xCRT_MODE,7     ; is this a BW monitor?
+        jne     do_rest
+        mov     bx,MonoSc
+do_rest:
+IF      BLANK
+        mov     dx,cs:[di].xADDR_6845   ; point to mode register
+        add     dx,4
+        mov     al,cs:[di].xCRT_MODE_SET        ;  and get value
+        and     al,NOT 8
+        out     dx,al                   ; turn off video
+ENDIF
+        mov     es,bx                   ; ES points to apropiate screen area
+    assume      es:NOTHING
+        mov     di,0
+        cld
+    rep movsw                           ; copy the screen
+IF      BLANK
+        or      al,8
+        out     dx,al                   ; turn on video
+ENDIF
+        pop     ds
+    assume      ds:NOTHING
+        pop     bx
+        mov     word ptr ds:[bx].RegSI,0        ; operation ok
+        jmp     StatusComplete
+BadNumJ:
+        jmp     BadNum
+subttl  do_IOSC_EI - Re-enable i/o
+page
+;------------------------------------------------------------------------
+;       Re-enable i/o
+;
+; entry:
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+do_IOSC_EI:
+        mov     [SaveFlg],0             ; Signal we are done Saving the screen
+        mov     ax,offset Code:SaveFlg
+        call    DoPRun                  ; ProcRun
+        mov     ax,[CurrSIB]            ; pointer to current SIB
+        call    DoPRun                  ; ProcRun any output blocked because
+                                        ;  screen was not current
+        jmp     StatusComplete
+subttl  do_IOSC_IS - Initialize Screen
+page
+;------------------------------------------------------------------------
+;       Initialize Screen
+;
+; entry:
+;       SI = SIB Number
+;       DS:BX = pointer to Request packet
+;
+assume  ds:NOTHING,es:NOTHING
+do_IOSC_IS:
+        cmp     si,(MaxSIB-1)           ; index within range?
+        ja      BadNumJ
+        push    ds
+        push    cs
+        pop     ds
+    assume      ds:Code
+        mov     [CurrSc],si             ; switch curr screens
+        mov     dx,si                   ; index
+        call    GetSIBAdr               ; get pointer to SIB
+        mov     [CurrSIB],ax            ; save pointer to curr SIB
+        mov     si,ax
+        mov     [si].ctlS,0             ; screen not frozen
+;--- set screen mode to pc mode 3 (80x25 BW)
+        mov     ax,0003                 ; Set mode 3
+        int     10h
+        pop     ds
+    assume      ds:NOTHING
+        mov     word ptr ds:[bx].RegSI,0        ; operation ok
+        jmp     StatusComplete
+subttl  $ConStop - Stop (freeze) console output
+page
+;------------------------------------------------------------------------
+;       Stop (freeze) console output
+;
+assume  ds:NOTHING,es:NOTHING
+$ConStop:
+        mov     bx,[CurrSIB]            ; pointer to current SIB
+        mov     cs:[bx].ctlS,01         ; set the freeze flag
+        jmp     StatusComplete
+subttl  $ConStart - Start (continue) console output
+page
+;------------------------------------------------------------------------
+;       Start (continue) console output
+;
+assume  ds:NOTHING,es:NOTHING
+$ConStart:
+        mov     bx,[CurrSIB]            ; pointer to current SIB
+        cmp     cs:[bx].ctlS,0          ; is it already going?
+        je      csRet                   ; yes, no need to re-enable
+        mov     cs:[bx].ctlS,0          ; reset the freeze flag
+        lea     ax,[bx].ctlS            ; get address of current ctlS
+        call    DoPRun                  ; do ProcRun
+csRet:  jmp     StatusComplete
+subttl  DoPBlock - Block the current process
+page
+;------------------------------------------------------------------------
+;       Block the current process
+;
+; entry:
+;       CS:AX = address to block on
+;
+; modifies:     AX, FLAGS
+;
+assume  ds:NOTHING,es:NOTHING
+DoPBlock:
+        push    bx
+        push    cx
+        push    dx
+        mov     bx,ax
+        mov     ax,cs                   ; AX:BX = event identifier
+        xor     cx,cx                   ; No timeout
+;;      mov     dx,0109h        ;;BUGBUG - should be interruptible wait; will
+                                ;;  give InternalError (SchedFind - not on Q)
+        mov     dx,0009h                ; PROCBLOC function
+        cli                             ; No races!
+        call    [DosFunction]
+        pop     dx                      ; on return ints are back on
+        pop     cx
+        pop     bx
+        ret
+subttl  DoPRun - Restart a process
+page
+;------------------------------------------------------------------------
+;       Restart a process
+;
+; entry:
+;       CS:AX = address to signal on (same as blocked on)
+;
+; modifies:     AX, FLAGS
+;
+assume  ds:NOTHING,es:NOTHING
+DoPRun:
+        push    bx
+        push    cx
+        push    dx
+        mov     bx,ax
+        mov     ax,cs
+        mov     dx,10                   ; PROCRUN function
+        call    [DosFunction]
+        pop     dx
+        pop     cx
+        pop     bx
+        ret
+subttl  GetSIBAdr - Return SIB address
+page
+;------------------------------------------------------------------------
+;       Returns the adress of the specified SIB
+;
+; entry:
+;       DX = index to the SIB
+;
+; exit:
+;       AX = pointer to the SIB
+;
+; preserves:    ALL
+;
+assume  ds:Code,es:NOTHING
+GetSIBAdr:
+        push    dx                      ; save screen #
+        mov     ax,dx                   ; index
+        mov     dx,(SIZE SIBst)
+        mul     dx                      ; multiply by size of SIB entry
+        pop     dx                      ; restore screen #
+        add     ax,offset SIB           ; AX = pointer to SIB for the write
+        ret
+subttl  GetSegAdr - Return segment address
+page
+;------------------------------------------------------------------------
+;       Returns the adress of a segment in the current SIB
+;
+; entry:
+;       AX = index to the segment
+;
+; exit:
+;       BX = pointer to the segment
+;       DX = pointer to the Current SIB
+;
+assume  ds:Code,es:NOTHING
+GetSegAdr:
+        mov     dx,(SIZE SEGst)
+        mul     dx                      ; multiply by size of SEG entry
+        mov     bx,[CurrSIB]            ; pointer to SIB
+        mov     dx,bx                   ; save for exit
+        mov     bx,[bx].OffsetVal       ; pointer to start of SEGs in SIB
+        add     bx,ax                   ; BX = pointer to SEG from start of SIB
+        add     bx,dx                   ; BX = absolute pointer to SEG to use
+        ret
+ifdef   DEBUGFLG
+if      NOT INBIOS
+        INCLUDE         BUGCODE.INC
+endif
+endif
+subttl  $ConInit - Initialization Routine
+page
+;------------------------------------------------------------------------
+;       Initialization Routine
+;
+;entry:
+;       DS:BX = pointer to Request packet
+;       ES:DI = Dos Functions entry point address
+;
+assume  ds:NOTHING,es:NOTHING
+$ConInit:
+IF      NOT INBIOS
+        push    ds                      ; print greeting
+        push    cs
+        pop     ds
+        mov     dx,offset Intro
+        MOV     ah,9
+        int     21h
+        pop     ds
+        mov     word ptr ds:[bx].TRANS, offset $ConInit
+        mov     word ptr ds:[bx].TRANS+2,cs
+ENDIF
+        mov     cs:Word Ptr DosFunction,di  ; Save pointer to service routines
+        mov     cs:Word Ptr DosFunction+2,es
+        mov     ax,0
+        mov     cx,1
+        mov     dx,16
+        call    [DosFunction]           ; get DOS variable ScrnIoOk
+        mov     word ptr ScrnIoOk,ax
+        mov     word ptr ScrnIoOk+2,dx
+;*      Initialize interrupt vectors.
+;;BUGBUG - we should be using Get/Set_Interrupt_Vector calls
+        xor     ax,ax                   ; initialize break interrupt handler
+        mov     es,ax                   ; points to page 0
+        mov     ax,cs
+        mov     word ptr es:BRKADR,offset Break
+        mov     word ptr es:BRKADR+2,ax ; Vector for Break
+        MOV     DI,9*4                  ; INT 9 - Keyboard interrupt vector
+        MOV     CX,es:[DI]              ; Save old addr to hook to
+        MOV     WORD PTR OldKeyInterrupt,CX
+        MOV     CX,es:2[DI]
+        MOV     WORD PTR (OldKeyInterrupt+2),CX
+        MOV     CX,OFFSET KeyboardInterrupt
+        XCHG    AX,CX
+        STOSW
+        XCHG    AX,CX
+        STOSW                           ; Set new keyboard interrupt
+        mov     di,16h*4                ; INT 16 - keyboard input
+        MOV     CX,es:[DI]              ; Save INT 16 addr to hook to
+        MOV     WORD PTR OldKbdHandler,CX
+        MOV     CX,es:2[DI]
+        MOV     WORD PTR (OldKbdHandler+2),CX
+        MOV     CX,OFFSET KeyboardHandler
+        XCHG    AX,CX
+        STOSW
+        XCHG    AX,CX                   ; Set new keyboard Handler
+        STOSW
+        jmp     StatusComplete
+IF      INBIOS
+Code    ends
+BiosInit        segment para public 'CODE'
+ENDIF
+Intro   db      "--- Installing MTCON Device Driver V"
+        db      CVERS+"0",".",CREV/10+"0"
+        db      (CREV-CREV/10*10)+"0"," ---"
+        db      13,10,"$"
+BiosInit        ends
+        END
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.OBJ b/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.OBJ
new file mode 100644
index 0000000..ed4dc74
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/IBMMTCON.OBJ
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/READ_ME b/v4.0-ozzie/bin/DISK2/BIOS/READ_ME
new file mode 100644
index 0000000..03623a4
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/READ_ME
@@ -0,0 +1,25 @@
+29 May 1984
+The object files given here are sufficient to create the BIOS
+for the IBM system.  Some sources are given as examples for
+OEM supplied device drivers.  These sources do not necessarily
+implement all the features described in the device driver
+documentation.  They have evolved in parallel with the
+documentation, so some features described in the documentation
+may not yet be present in the drivers.  Below is a summary of
+the files supplied:
+        read_me         This file.
+        ibmbio.asm      Main body of the BIOS.
+        ibmdsk.asm      Floppy and Hard disk drivers.
+        ibmmtcon.asm    Multi-screen console driver.
+        ansi.inc        ANSI X3.64 terminal emulation.
+        bugcode.inc     Module which implements debugging
+                        prints.  The routine PUTC must be
+                        modified for other devices.  See
+                        also the file DEFDBUG.INC.
+        sys*.obj        The SYSINIT program.  No source supplied.
+        biosobj.mak     Contains instructions for building the
+                        IBM BIOS.
+        bootpach.exe    Modifies a V2.0 boot sector (on A:) for
+                        the IBM to accomodate the larger BIOS.
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/SYSIMES.OBJ b/v4.0-ozzie/bin/DISK2/BIOS/SYSIMES.OBJ
new file mode 100644
index 0000000..4439f35
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/SYSIMES.OBJ
Binary files differ
diff --git a/v4.0-ozzie/bin/DISK2/BIOS/SYSINI.OBJ b/v4.0-ozzie/bin/DISK2/BIOS/SYSINI.OBJ
new file mode 100644
index 0000000..0fc06ba
--- /dev/null
+++ b/v4.0-ozzie/bin/DISK2/BIOS/SYSINI.OBJ
Binary files differ
diff --git a/v4.0-ozzie/bin/DRDOS1.IMD b/v4.0-ozzie/bin/DRDOS1.IMD
new file mode 100644
index 0000000..0a7a84f
--- /dev/null
+++ b/v4.0-ozzie/bin/DRDOS1.IMD
Binary files differ
diff --git a/v4.0-ozzie/bin/DRDOS1_IMD.img b/v4.0-ozzie/bin/DRDOS1_IMD.img
new file mode 100644
index 0000000..d6d7165
--- /dev/null
+++ b/v4.0-ozzie/bin/DRDOS1_IMD.img
Binary files differ
diff --git a/v4.0-ozzie/bin/DRDOS2.IMD b/v4.0-ozzie/bin/DRDOS2.IMD
new file mode 100644
index 0000000..972058b
--- /dev/null
+++ b/v4.0-ozzie/bin/DRDOS2.IMD
Binary files differ
diff --git a/v4.0-ozzie/bin/DRDOS2_IMD.img b/v4.0-ozzie/bin/DRDOS2_IMD.img
new file mode 100644
index 0000000..64d8395
--- /dev/null
+++ b/v4.0-ozzie/bin/DRDOS2_IMD.img
Binary files differ