MZ is back!HEADmain

1 files changed, 7587 insertions, 0 deletions

diff --git a/v4.0/src/DEV/SMARTDRV/SMARTDRV.ASM b/v4.0/src/DEV/SMARTDRV/SMARTDRV.ASM
new file mode 100644
index 0000000..3efe7c1
--- /dev/null
+++ b/v4.0/src/DEV/SMARTDRV/SMARTDRV.ASM
@@ -0,0 +1,7587 @@
+        TITLE   EXTENDED/EXPANDED MEMORY DISK CACHE
+
+PAGE    58,132
+
+;
+;; Will use IBM extended memory on PC-AT or
+;;      use Above Board on PC, XT, or AT, and
+;;          use extended, expanded, or upper extended memory on AT&T 6300 PLUS
+;
+;
+;;      device = SMARTDRV.sys [bbbb] [/a] [/u]
+;
+;               bbbb  First numeric argument, if present, is memory size
+;                       in K bytes. Default value is 256. Min is 128. Max
+;                       is 8192 (8 Meg).
+;
+;                     By default PC AT Extended Memory is to be used.
+;                       It is an error if /E is specified on a machine other
+;                       than an IBM PC AT. /E is the default.
+;                     NOTE: Information in cache in PC AT extended memory
+;                       will be lost at system re-boot (warm or cold). This is
+;                       due to the fact that the IBM PC AT ROM bootstrap code
+;                       zeroes all of memory.
+;                     NOTE: There is 1k of memory overhead. That is to say,
+;                       if there are 512k bytes of extended memory, there
+;                       will be 511k bytes available for assignment to int13.
+;                       This 1k overhead is fixed and makes int13 compatible
+;                       with RAMDRive.
+;                     NOTE: The same allocation strategy as is used in RAMDrive
+;                       is used. This allows RAMDrive and INT13 to coexist on
+;                       the same system. Mixing with IBM VDISK is NOT supported.
+;
+;               /a    Specifies that Above Board memory is to be used. It
+;                       is an error if the above board device driver is not
+;                       present.
+;                     NOTE: Information in cache in Above Board memory
+;                       will be lost at system re-boot (warm or cold). This is
+;                       due to the fact that the EMM device driver performs a
+;                       destructive test when it is installed which zeros all
+;                       of the Above Board memory.
+;;              /u      Specifies that upper extended memory will be used
+;;                      on the AT&T 6300 PLUS.  Upper extended memory
+;;                      is the memory beginning at FA0000.  It is used
+;;                      to hold the UNIX kernel when the machine is running
+;;                      Simul-Task.  However, when operating as a pure 
+;;                      MS-DOS machine, this 384K of memory is available
+;;                      for SMARTDRIVE.
+;;                      Note that it is an error to specify this switch
+;;                      if the machine is not a 6300 PLUS.
+;
+; NOTE WARNING: ALL OF THIS CODE ASSUMES THAT ALL HARDFILES ARE 512 BYTES
+;       PER SECTOR!!! All other hardfile parameters are read via INT 13, but
+;       Bytes/sector MUST be IBM standard 512.
+;
+; MODIFICATION HISTORY
+;
+;       1.00    5/10/86 ARR Initial version based on RAMDrive 1.16.
+;       1.01    5/20/86 ARR Slight re-organization of places where FLUSH_CACHE
+;                           is called to discard a track to make sure
+;                           TRACK_BUFFER is invalidated correctly.
+;       1.10    5/26/86 ARR Added Timer Int to flush cache after passage
+;                           of user setable time.
+;       1.20    5/27/86 ARR Additions at request of Neilk. /t:nnnnn /d /wb:on
+;                           /wb:off /wt:on /wt:off can be on device = line.
+;                           Lock cache function added.
+;       1.21    5/29/86 ARR Lock code made more intelligent.
+;       1.22    5/30/86 ARR /r reboot flush code added
+;       1.23    6/03/86 ARR Cache statistics added
+;       1.24    6/05/86 ARR Added /a "all cache" code
+;       1.25    6/10/86 ARR Added total used, total locked to status
+;       1.26    6/12/86 ARR /wb changed to /wc to align with docs. Discard
+;                           of track when write to locked track changed to
+;                           unlock. Discard of track when write with /wc:off
+;                           changed to immediate write through.
+;       1.27    6/17/86 ARR Bug regarding the INT 13 error which is not
+;                           an error (error 11H, ECC error corrected).
+;                           changed error handling logic to handle this
+;                           correctly (ignore it).
+;       1.28    7/31/86 ARR Default seg reg access byte changed from
+;                           82H to 92H. This was needed for 80386 functionality.
+;                           Change to LOADALL.ASM, also RAMDrive problem.
+;       1.30    8/04/86 ARR Default cache size uped to 256K
+;                           Min cache size uped to 128K
+;       1.31    8/07/86 ARR Moved SMSW SIDT SGDT set into BLKMOV code for
+;                           problem with CEMM
+;       1.32    8/27/86 ARR Added code to A20 routine to provide approp
+;                           settle time for A20 switch to occur. This will
+;                           help us on Compaq machines and faster ATs and
+;                           80386 machines. Thanks to CC of Compaq for fix.
+;       1.33    9/22/86 ARR Added more info to startup header, in particular,
+;                           tells you whether /A or /E cache.
+;
+;       SMARTDRV
+;       ------
+;
+;       1.00    5/13/87 SUNILP, GREGH, DAVIDW:
+;                           Modified INT13 to take care of multi track caching
+;                           Reduced functionality
+;                           Added two new IOCTL calls to increase/decrease
+;                           cache size, dynamically
+;
+;
+;;              7/24/87 WSH Added 6300 PLUS support.  This code is marked by
+;;                          the use of double semi-colons to make it easy to
+;;                          find.
+;
+;               8/31/87 SUNILP
+;                           New extended memory allocation scheme. 386 support.
+;                           Support for new ps/2 systems. better 286 loadall
+;                           transfer. more complete expanded memory access.
+;                           several bug fixes.
+;
+;       1.01    9/17/87 SUNILP
+;                           Removed check that was limiting tracks to 32k bytes
+;                           Tracks can be upto 64k bytes now
+;
+;       1.02    10/22/87 SUNILP
+;                           Reduced statically allocated track buffer size to
+;                           minimum required
+;
+;       1.03    10/29/87 SUNILP
+;                           Changed name reported in messages to SMARTDrive
+;
+;                1/08/88 GREGH
+;                           Added support for OMTI controller.  This code
+;                           is ifdef'd in with the OMTI keyword.
+;
+;       1.04    3/02/88  SUNILP
+;                           fix for recognition of 20MHz model 80.
+;                           fix for READ DASD int 13 dispatch.
+;
+;       1.05    5/13/88  SUNILP
+;                           fixed version checking to include dos 4.00
+;
+;       2.10    6/13/88  CHIPA  Merged in these changes for HP Vectra
+;              11/20/87  RCP
+;                           Fixed a20 enabling/disabling problems on
+;                           Vectra machines.
+;               8/24/88  MRW Merged changes from Windows tree into DOS tree
+;
+
+BREAK   MACRO   subtitle
+        SUBTTL  subtitle
+        PAGE
+ENDM
+
+.286p                           ; Use some 286 instructions in /E code
+
+DEBUG   EQU     0
+S_OLIVETTI      EQU     1       ; Flag for olivetti 6300 plus machine
+S_VECTRA        EQU     2       ; Flag for HP Vectra machines
+WINDOWS_SWITCHES EQU    1       ; 1 = uses switches for windows, 0 = all switches
+;OMTI    EQU     1               ; Used for code specific to the OMTI Controller
+
+MAX_HARD_FILES  EQU     16      ; Max number of hardfiles our data structures support
+
+MIN_CACHE_SIZE_K EQU    128     ; Minimum size for cache in K (multiple of 16)
+
+IF1
+    IFDEF OMTI
+        %out OMTI Controller release
+    ENDIF
+ENDIF
+
+IF1
+    IF DEBUG
+        %out DEBUG VERSION!!!!!!
+    ENDIF
+ENDIF
+
+;; In order to address memory above 1 MB on the AT&T 6300 PLUS, it is
+;; necessary to use the special OS-MERGE hardware to activate lines
+;; A20 to A23.  However, these lines can be disabled only by resetting
+;; the processor.  The return address offset and segment can be found 
+;; at 40:a2, noted here as RealLoc1.
+;;
+BiosSeg segment at 40h          ;; Used to locate 6300 PLUS reset address
+        org     00a2h
+RealLoc1 dd     0
+BiosSeg ends
+;
+R_Mode_IDT  segment at 0h
+R_mode_IDT  ends
+;
+.xlist
+        include devsym.asm
+        include syscall.asm
+        include mi.asm
+.list
+
+; The INT13 device driver has 2 basic configurations.
+;
+;       TYPE 1 - /E configuration using PC-AT extended memory and the LOADALL
+;               instruction.
+;;              The /U configuration using upper extended memory on the 
+;;              6300 PLUS is a special case of the type 1 configuration.
+;
+;       TYPE 2 - /A configuration using Above Board memory and EMM device
+;               driver.
+;
+; The TYPE 2 driver uses the Above Board EMM device driver via INT 67H
+;    to control access to, and to access the available memory.
+;
+; The TYPE 1 configuration uses the EMM control sector to
+;    control access to the available memory
+;
+
+        include emm.asm
+
+        include loadall.asm
+
+        include above.asm
+
+        include ab_macro.asm
+
+BREAK   <I/O Packet offset declarations>
+
+;
+; Define I/O packet offsets for useful values.
+;
+; SEE ALSO
+;       MS-DOS Technical Reference manual section on Installable Device Drivers
+;
+
+; READ/WRITE PACKET OFFSETS
+RW_COUNT        EQU     WORD PTR (SIZE SRHEAD) + 5
+RW_TRANS        EQU     DWORD PTR (SIZE SRHEAD) + 1
+RW_START        EQU     WORD PTR (SIZE SRHEAD) + 7
+
+; MEDIA CHECK PACKET OFFSETS
+MCH_RETVAL      EQU     BYTE PTR (SIZE SRHEAD) + 1
+MCH_MEDIA       EQU     BYTE PTR (SIZE SRHEAD) + 0
+
+; BUILD BPB PACKET OFFSETS
+BPB_BUFFER      EQU     DWORD PTR (SIZE SRHEAD) + 1
+BPB_MEDIA       EQU     BYTE PTR (SIZE SRHEAD) + 0
+BPB_BPB         EQU     DWORD PTR (SIZE SRHEAD) + 5
+
+; INIT PACKET OFFSETS
+INIT_NUM        EQU     BYTE PTR (SIZE SRHEAD) + 0
+INIT_BREAK      EQU     DWORD PTR (SIZE SRHEAD) + 1
+INIT_BPB        EQU     DWORD PTR (SIZE SRHEAD) + 5
+INIT_DOSDEV     EQU     BYTE PTR (SIZE SRHEAD) + 9
+
+BREAK   <Cache control structure>
+
+;
+; The cache control structure is the "management" data associated
+;   with all of the data in the cache. The cache structures are
+;   part of the device driver and they contain pointers to the
+;   actual cache memory where the data is. This is more efficient
+;   than putting the structures with the data as there is more overhead
+;   to access stuff in the data area. The structures form a double
+;   linked list in LRU order. The head points to the MRU element. The
+;   tail points to the LRU element. Scans start at MRU as this is the
+;   highest probability of a hit. Selection for bump is at LRU. All of
+;   the links are short pointers. This limits the size of the cache
+;   as the cache structures together with the device code must all
+;   fit in 64K. This is more efficient than FAR links. Each cache element
+;   contains one complete track of one of the INT 13 hard files (INT 13
+;   floppy drives are NOT cached). Cache "read ahead" is obtained by
+;   reading complete tracks into the cache even though the INT 13 user
+;   may have only requested one sector. Write behind is accomplished
+;   (if enabled) by holding tracks for a while allowing user writes
+;   on that track to "accumulate".
+;
+; The original INT 13 caching algorithm (Aaronr) is sumarized as follows:
+;
+;       If user read is in cache
+;           Perform user read from cache
+;       Else
+;           If read is full track
+;               Perform write through (if enabled)
+;               Pass Read to old INT 13 handler (no cache operation)
+;           Else
+;               Read track into cache using old INT 13 handler
+;               Perform user read out of cache
+;
+;       If user write is in cache
+;           If write buffering is enabled
+;               Perform user write into cache
+;           Else
+;               Discard cache for this track
+;               Pass write through to old INT 13 handler
+;       Else
+;           If write is full track
+;               Perform write through (if enabled)
+;               Pass Write to old INT 13 handler (no cache operation)
+;           Else
+;               If write buffering is enabled
+;                   Read track into cache using old INT 13 handler
+;                   Perform user write into cache
+;               Else
+;                   Pass write through to old INT 13 handler
+;
+;       SMARTDRV     modifications:
+;
+;       1. Write through always.
+;       2. Multi track I/O capability support.
+;       3. Direct transfer between cache and user buffer address for
+;          full tracks.
+;
+;
+;
+
+CACHE_CONTROL   STRUC
+FWD_LRU_LNK     DW      ?       ; Link to next CACHE_CONTROL, -1 if last
+BACK_LRU_LNK    DW      ?       ; Link to previous CACHE_CONTROL, -1 if first
+BASE_OFFSET     DD      ?       ; Offset releative to start of cache
+                                ;  memory of start of this track buffer
+TRACK_FLAGS     DW      ?       ; Flags
+;
+; NOTE: The next two bytes are refed as a word.
+;           MOV     DX,WORD PTR STRC.TRACK_DRIVE
+;           OR      DH,80H
+;       Puts the INT 13 drive in DL, and the head in DH which is correct
+;       for an INT 13
+;
+TRACK_DRIVE     DB      ?       ; INT 13 drive with high bit = 0
+TRACK_HEAD      DB      ?       ; INT 13 head
+TRACK_CYLN      DW      ?       ; INT 13 cylinder
+                                ;   High byte is low byte of cylinder #
+                                ;   High two bits of Low byte are high
+                                ;        two bits of cylinder #. Other bits
+                                ;        are 0. This makes it easy to load the
+                                ;        CX register for an INT 13 for this
+                                ;        track:
+                                ;                MOV    CX,STRC.CACHE_CYLN
+                                ;                OR     CL,1
+CACHE_CONTROL   ENDS
+
+;
+; TRACK_FLAGS bits
+;
+TRACK_FREE      EQU     0000000000000001B       ; Track buffer is free
+TRACK_DIRTY     EQU     0000000000000010B       ; Track needs to be written
+TRACK_LOCKED    EQU     0000000000000100B       ; Track is locked
+
+BREAK   <Device header>
+
+INT13CODE SEGMENT
+ASSUME  CS:INT13CODE,DS:NOTHING,ES:NOTHING,SS:NOTHING
+
+        IF      DEBUG
+        public  strategy,int13$in,cmderr,err$cnt,err$exit,devexit
+        public  INT13$IOCTL_Read,INT13$Read_St,INT13$Write_St,INT13$IOCTL_Write
+        public  int_1C_handler,int_13_handler,POP_NO_PROC,INVALIDATE_CACHE
+        public  CACHE_READ,CACHE_WRITE,FLUSH_PASS,FLUSH_INVALID_PASS
+        public  FLUSH_WHOLE_CACHE_SAV,FLUSH_WHOLE_CACHE,FLUSH_CACHE
+        public  WRITE_FROM_CACHE
+        public  Cache_hit
+        public  blkmov,INT_9,INT_19,RESET_SYSTEM,DO_INIT,SETBPB
+        public  PRINT,ITOA,INT13$INIT,DRIVEPARMS,GETNUM,DISK_ABORT
+        public  CTRL_IO,MM_SETDRIVE,FIND_VDRIVE,SET_RESET
+        public  AT_EXT_INIT,FIX_DESCRIPTOR,ABOVE_INIT
+        public  process_read_partial,process_block_read,pr_acc_trks
+        public  pr_acc_trks,pr_cur_trk,process_write_partial,process_block_write
+        public  check_parameters,process_regions,bytes_in_trk,sect_in_trk
+        public  not_in_mem,read_disk
+        public                not_in_memw,rd_partw,rd_part
+        public  region
+        public  SECTRKARRAY
+        ENDIF
+
+;**
+;
+;       INT13 DEVICE HEADER
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;       SEE ALSO
+;         MS-DOS Technical Reference manual section on
+;         Installable Device Drivers
+;
+
+;; The internal name of the device driver has been changed from SMARTDRV
+;; to SMARTAAR to avoid DOS name conflicts with files named SMARTDRV.*
+;;
+INT13DEV  LABEL   WORD
+        DW      -1,-1
+DEVATS  DW      DEVOPCL + CharDev + DevIOCtl
+        DW      STRATEGY
+        DW      INT13$IN
+        DB      "SMARTAAR"                      ;Name of device
+
+
+BREAK   <Command dispatch table>
+
+;**
+;
+; This is the device driver command dispatch table.
+;
+; The first byte indicates the size of the table and therefore defines
+; which device function codes are valid.
+;
+; The entries in the table are NEAR word addresses of the appropriate
+; device routine. Thus the address of the routine to handle device function
+; 3 is:
+;       WORD at ((INT13TBL + 1) + (2 * 3))
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;
+
+INT13TBL  LABEL   WORD
+        DB      15                      ; Max allowed command code
+        DW      INT13$INIT              ; Init
+        DW      CMDERR                  ; Media check
+        DW      CMDERR                  ; Build BPB
+        DW      INT13$IOCTL_Read        ; IOCTL input
+        DW      CMDERR                  ; Read
+        DW      CMDERR                  ; Non-des read no-wait
+        DW      INT13$Read_St           ; Read status
+        DW      CMDERR                  ; Read flush
+        DW      CMDERR                  ; Write
+        DW      CMDERR                  ; Write with verify
+        DW      INT13$Write_St          ; Output status
+        DW      CMDERR                  ; Output flush
+        DW      INT13$IOCTL_Write       ; IOCTL output
+        DW      DEVEXIT                 ; Open
+        DW      DEVEXIT                 ; Close
+        DW      CMDERR                  ; Rem media?
+
+BREAK   <Device Control data>
+
+STATISTICS_SIZE EQU     40
+
+DRIVER_SEL      DB      0       ; 0 if /E (TYPE 1), 1 if /A (TYPE 2),
+
+DEV_SIZE        DW      256     ; Size in K of the cache
+
+SECTRACK        DW      ?       ; Sectors per track
+
+current_dev_size dw     ?       ; Current size in K of cache
+
+;;      Data peculiar to AT&T 6300 PLUS.
+
+S5_FLAG         DB      0       ;; = S_OLIVETTI if 6300 plus machine
+                                ;; = S_VECTRA if HP Vectra machine
+
+                db      ?       ; Spacer
+
+A20On   dw      0DF90h
+A20Off  dw      0DD00h
+
+special_mem     dw      0
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Unfortunately the code in smartdrv is very machine dependent
+; necessitating the use of a system flag to store the machine
+; configuration. The system flag is initialised during init time
+; and used when the caching services are requested. One bit which
+; is set and tested during caching is the state of the a20 line
+; when the cache code is entered. This is used because there are
+; applications which enable the a20 line and leave it enabled 
+; throughout the duration of execution.  Since smartdrv is a device
+; driver it shouldn't change the state of the environment.
+;
+; The system flag bit assignments are:
+;
+;       -------------------------------------------------
+;       |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0  |
+;       -------------------------------------------------
+;          |-----|-----|     |     |     |     |     |
+;                |           |     |     |     |     -----286 (and AT)
+;                |           |     |     |     -----------386 (later than B0)
+;               not          |     |     -----------------PS/2 machine
+;              used          |     -----------------------Olivetti (not used)
+;                            -----------------------------A20 state (enabled ?)
+;
+; The Olivetti guys have defined a flag of their own. This should be removed
+; and the bit assigned out here for them should be used. 
+;
+sys_flg db      ?
+;
+;       equates used for the system flag
+;
+M_286   equ     00000001B
+M_386   equ     00000010B
+M_PS2   equ     00000100B
+M_OLI   equ     00001000B
+A20_ST  equ     00010000B
+ifdef   OMTI
+OMTI_EXT equ    00100000B
+endif
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;   flag to indicate that reset code is being executed
+reboot_flg  db  0
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;   emm ctrl address, needed for the reset code
+emm_ctrl_addr   dw  EXTMEM_LOW
+                dw  EXTMEM_HIGH
+;
+;
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; A20 address line state determination addresses
+;
+low_mem label   dword
+        dw      20h*4
+        dw      0
+
+high_mem label  dword
+        dw      20h*4 + 10h
+        dw      0ffffh
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; A20 PS2 equates
+;
+PS2_PORTA   equ 0092h
+GATE_A20    equ 010b
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;   386 working areas
+start_gdt       label   byte
+nul_des desc    <>
+cs_des  desc    <0FFFFh,0,0,09Fh,0,0>
+ss_des  desc    <0FFFFh,0,0,093h,0,0>
+ds_des  desc    <0FFFFh,0,0,093h,0,0>
+es_des  desc    <0FFFFh,0,0,093h,0,0>
+end_gdt         label   byte
+
+emm_gdt gdt_descriptor <end_gdt-start_gdt,0,0>
+;
+;   int 15 gdt
+;
+int15_gdt   label   byte
+            desc    <>      ;dummy descriptor
+            desc    <>      ;descriptor for gdt itself
+src         desc    <0ffffh,,,93h,,>
+tgt         desc    <0ffffh,,,93h,,>
+            desc    <>                  ;bios cs descriptor
+            desc    <>                  ;stack segment descriptor
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 0 if device is valid
+; Non-0 if device install failed (device non-functional)
+;
+;   We need this state because there is no way to "un-install"
+;     a character device as there is with block devices
+;
+NULDEV  DB      0
+
+;
+; 0 if caching is off
+; Non-0 if caching is on
+;
+ENABLE_13 DB    1  ; 0 for debug
+
+;
+; 0 if no write through
+; Non-0 if write through
+;
+WRITE_THROUGH DB 0
+
+;
+; 0 if no write buffering
+; Non-0 if write buffering enabled
+;
+WRITE_BUFF DB   0
+
+;
+; 0 if cache is unlocked
+; Non-0 if cache is locked
+;
+LOCK_CACHE DB   0
+
+;
+; 0 if full track I/O to tracks not in cache is not cached.
+; Non-0 if ALL I/O is to be cached
+;
+ALL_CACHE DB 1
+
+;
+; 0 if reboot flush is disabled
+; Non-0 if reboot flush is enabled
+;
+REBOOT_FLUSH DB 0
+
+;
+; An exclusion sem so that the INT 13 handler and the timer interact
+;       without re-entrancy problems
+;
+INT_13_BUSY     DB      0               ; Exclusion sem
+
+        EVEN                            ; Force word data to word align
+;
+; Statistics counters
+;
+;  WARNING!!!! Do not disturb the order of these!!!! See IOCTL_READ code.
+;
+TOTAL_WRITES    DD      0
+WRITE_HITS      DD      0
+TOTAL_READS     DD      0
+READ_HITS       DD      0
+TTRACKS         DW      ?       ; Total number of track buffers that fit
+                                ;  in DEV_SIZE K (number of cache elements)
+TOTAL_USED      DW      0
+TOTAL_LOCKED    DW      0
+TOTAL_DIRTY     DW      0
+
+;
+; Tick counters
+;
+TICK_SETTING    DW      1092            ; Approx 1 minute
+TICK_CNT        DW      1092
+
+;
+; Non-zero if there are dirty buffers in the cache
+;
+DIRTY_CACHE     DW      0               ; 0 if no dirty elements in cache
+
+BREAK   <Common Device code>
+
+;       INT13 DEVICE ENTRY POINTS - STRATEGY, INT13$IN
+;
+;       This code is standard DOS device driver function dispatch
+;       code. STRATEGY is the device driver strategy routine, INT13$IN
+;       is the driver interrupt routine.
+;
+;       INT13$IN uses INT13TBL to dispatch to the appropriate handler
+;       for each device function. It also does standard packet
+;       unpacking.
+;
+;       SEE ALSO
+;         MS-DOS Technical Reference manual section on
+;         Installable Device Drivers
+;
+
+ASSUME  CS:INT13CODE,DS:NOTHING,ES:NOTHING,SS:NOTHING
+
+PTRSAV  DD      0                       ; Storage location for packet addr
+
+;**     STRATEGY - Device strategy routine
+;
+;       Standard DOS 2.X 3.X device driver strategy routine. All it does
+;       is save the packet address in PTRSAV.
+;
+;       ENTRY   ES:BX -> Device packet
+;       EXIT    NONE
+;       USES    NONE
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;
+
+STRATP  PROC    FAR
+
+STRATEGY:
+        MOV     WORD PTR [PTRSAV],BX    ; Save packet addr
+        MOV     WORD PTR [PTRSAV+2],ES
+        RET
+
+STRATP  ENDP
+
+;**     INT13$IN - Device interrupt routine
+;
+;       Standard DOS 2.X 3.X device driver interrupt routine.
+;
+;
+;       ENTRY   PTRSAV has packet address saved by previous STRATEGY call.
+;       EXIT    Dispatch to appropriate function handler
+;                       CX = Packet RW_COUNT
+;                       DX = Packet RW_START
+;                       ES:DI = Packet RW_TRANS
+;                       DS = INT13CODE
+;                       STACK has saved values of all regs but FLAGS
+;                   All function handlers must return through one of
+;                       the standard exit points
+;       USES    FLAGS
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;
+
+INT13$IN:
+        PUSH    SI
+        PUSH    AX
+        PUSH    CX
+        PUSH    DX
+        PUSH    DI
+        PUSH    BP
+        PUSH    DS
+        PUSH    ES
+        PUSH    BX
+
+        LDS     BX,[PTRSAV]            ;GET POINTER TO I/O PACKET
+    ;
+    ; Set up registers for READ or WRITE since this is the most common case
+    ;
+        MOV     CX,DS:[BX.RW_COUNT]     ;CX = COUNT
+        MOV     DX,DS:[BX.RW_START]     ;DX = START SECTOR
+        MOV     AL,DS:[BX.REQFUNC]      ; Command code
+        MOV     AH,BYTE PTR [INT13TBL]  ; Valid range
+        CMP     AL,AH
+        JA      CMDERR                  ; Out of range command code
+        MOV     SI,OFFSET INT13TBL + 1  ; Table of routines
+        CBW                             ; Make command code a word
+        ADD     SI,AX                   ; Add it twice since one word in
+        ADD     SI,AX                   ;  table per command.
+
+        LES     DI,DS:[BX.RW_TRANS]     ; ES:DI transfer address
+
+        PUSH    CS
+        POP     DS
+
+ASSUME  DS:INT13CODE
+
+        JMP     WORD PTR [SI]           ; GO DO COMMAND
+
+;**     EXIT - ALL ROUTINES RETURN THROUGH ONE OF THESE PATHS
+;
+;       Exit code entry points:
+;
+;       SEE ALSO
+;         MS-DOS Technical Reference manual section on
+;         Installable Device Drivers
+;
+;       GENERAL ENTRY for all entry points
+;               All packet values appropriate to the specific device function
+;               filled in except for the status word in the static request
+;               header.
+;
+;       CMDERR - Used when an invalid device command is detected
+;
+;               ENTRY Stack has frame set up by INT13$IN
+;               EXIT  Standard Device driver with error 3
+;               USES  FLAGS
+;
+;       ERR$CNT - Used when READ or WRITE wants to return with error code.
+;                  The packet RW_COUNT field is zeroed
+;
+;               ENTRY AL is error code for low byte of packet status word
+;                     Stack has frame set up by INT13$IN
+;               EXIT  Standard Device driver with error AL
+;               USES  FLAGS
+;
+;       ERR$EXIT - Used when a function other that READ or WRITE wants to
+;                       return an error
+;
+;               ENTRY AL is error code for low byte of packet status word
+;                     Stack has frame set up by INT13$IN
+;               EXIT  Standard Device driver with error AL
+;               USES  FLAGS
+;
+;       DEVEXIT - Used when a function wants to return with no error
+;
+;               ENTRY AL is value for low byte of packet status word
+;                      NOTE: Typically there is no meaningful value
+;                       in the AL register when EXITing through here.
+;                       This is OK as the low 8 bits of the status word
+;                       have no meaning unless an error occured.
+;                     Stack has frame set up by INT13$IN
+;               EXIT  Standard Device driver with no error
+;               USES  FLAGS
+;
+;       ERR1 - Used when a function wants to return with a value
+;                       for the whole status word
+;
+;               ENTRY AX is value for packet status word
+;                     Stack has frame set up by INT13$IN
+;               EXIT  Standard Device driver with or without error
+;               USES  FLAGS
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;
+
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+
+CMDERR:
+        MOV     AL,3                    ;UNKNOWN COMMAND ERROR
+        JMP     SHORT ERR$EXIT
+
+ERR$CNT:
+        LDS     BX,[PTRSAV]
+        MOV     [BX.RW_COUNT],0         ; NO sectors transferred
+ERR$EXIT:                               ; Error in AL
+        MOV     AH,(STERR + STDON) SHR 8  ;MARK ERROR RETURN
+        JMP     SHORT ERR1
+
+EXITP   PROC    FAR
+
+DEVEXIT:
+        MOV    AH,STDON SHR 8
+ERR1:
+        LDS     BX,[PTRSAV]
+        MOV     [BX.REQSTAT],AX         ; Set return status
+
+        POP     BX
+        POP     ES
+        POP     DS
+        POP     BP
+        POP     DI
+        POP     DX
+        POP     CX
+        POP     AX
+        POP     SI
+        RET                             ;RESTORE REGS AND RETURN
+EXITP   ENDP
+
+;
+; The following functions are not supported at this time.
+;
+INT13$Read_St:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+INT13$Write_St:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        JMP     CMDERR
+
+BREAK   <IOCTL Read function (get device control parms)>
+
+SET_ZRJ3:
+        JMP     SET_ZR
+
+INT13$IOCTL_Read:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CLD
+        CMP     CX,STATISTICS_SIZE      ; Must have room to transfer data.
+        JB      SET_ZRJ3                ; Not enough room from user
+        MOV     [TOTAL_USED],0
+        MOV     [TOTAL_LOCKED],0
+        MOV     [TOTAL_DIRTY],0
+    ;
+    ; Count all occupied, dirty and locked elements
+    ;
+        MOV     [INT_13_BUSY],1
+        MOV     SI,[CACHE_HEAD]
+        INC     SI
+NEXTCC:
+        DEC     SI
+        TEST    [SI.TRACK_FLAGS],TRACK_FREE
+        JNZ     SKIPCC
+        INC     [TOTAL_USED]
+        TEST    [SI.TRACK_FLAGS],TRACK_LOCKED
+        JZ      TEST_DIRTY
+        INC     [TOTAL_LOCKED]
+TEST_DIRTY:
+        TEST    [SI.TRACK_FLAGS],TRACK_DIRTY
+        JZ      SKIPCC
+        INC     [TOTAL_DIRTY]
+SKIPCC:
+        MOV     SI,[SI.FWD_LRU_LNK]
+        INC     SI
+        JNZ     NEXTCC
+        MOV     [INT_13_BUSY],0
+        MOV     AL,[WRITE_THROUGH]
+        MOV     AH,[WRITE_BUFF]
+        STOSW
+        MOV     AL,[ENABLE_13]
+        MOV     AH,[NULDEV]
+        STOSW
+        MOV     AX,[TICK_SETTING]
+        STOSW
+        MOV     AL,[LOCK_CACHE]
+        MOV     AH,[REBOOT_FLUSH]
+        STOSW
+        MOV     AL,[ALL_CACHE]
+        XOR     AH,AH                   ; Unused currently
+        STOSW
+        MOV     SI,OFFSET TOTAL_WRITES
+        MOV     CX,12
+        REP     MOVSW
+;
+; Transfer Above Board Information
+;
+        xor     dx,dx
+        mov     es:[di][0],dx
+        mov     es:[di][2],dx
+        mov     es:[di][4],dx
+        cmp     [driver_sel],dl         ; is it expanded memory?
+        jz      no_ems                  ; no, info already set
+        mov     cx,16
+        mov     ax,[current_dev_size]
+        div     cx
+        or      dx,dx
+        jz      no_remain
+        inc     ax
+        xor     dx,dx
+no_remain:
+        stosw
+        mov     ax,[dev_size]
+        div     cx
+        or      dx,dx
+        jz      no_remaind
+        inc     ax
+no_remaind:
+        stosw
+        mov     ax,MIN_CACHE_SIZE_K / 16
+        stosw
+no_ems:
+        LDS     BX,[PTRSAV]
+ASSUME  DS:NOTHING
+        MOV     [BX.RW_COUNT],STATISTICS_SIZE ; transfer amount
+        JMP     DEVEXIT
+
+BREAK   <IOCTL Write functions (set device control parms and do flushes)>
+
+;
+; Command table for IOCTL Write functions. The first byte of the written
+;       data contains the "function" code which is dispatched via this
+;       table. The first byte is the maximum legal function code, then the word
+;       addresses of the handlers for each function.
+;
+IOCTLTBL DB     0Ch
+        DW      IOCTL_FLUSH               ; Function 0h
+        DW      IOCTL_FLUSH_INVALID       ; Function 1h
+        DW      IOCTL_DISABLE             ; Function 2h
+        DW      IOCTL_ENABLE              ; Function 3h
+        DW      IOCTL_WRITE_MOD           ; Function 4h
+        DW      IOCTL_SET_TICK            ; Function 5h
+        DW      IOCTL_LOCK                ; Function 6h
+        DW      IOCTL_UNLOCK              ; Function 7h
+        DW      IOCTL_REBOOT              ; Function 8h
+        DW      IOCTL_STAT_RESET          ; Function 9h
+        DW      IOCTL_ALL_CACHE           ; Function Ah
+        dw      ioctl_reduce_cache_size   ; Function Bh
+        dw      ioctl_increase_cache_size ; Function Ch
+
+SET_ZR:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        LDS     BX,[PTRSAV]
+ASSUME  DS:NOTHING
+        MOV     [BX.RW_COUNT],0         ; NO bytes transferred
+        JMP     DEVEXIT
+
+SET_ERR_CNT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     AL,3                    ;UNKNOWN COMMAND ERROR
+        JMP     ERR$CNT
+
+INT13$IOCTL_Write:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CMP     [NULDEV],0              ; Is the device valid?
+        JNZ     SET_ZR                  ; No, you get an error
+        MOV     AL,ES:[DI]              ; Get command byte
+        MOV     AH,BYTE PTR [IOCTLTBL]  ; Valid range
+        CMP     AL,AH                   ; In range?
+        JA      SET_ERR_CNT             ; No
+        MOV     SI,OFFSET IOCTLTBL + 1  ; Table of routines
+        CBW                             ; Make command code a word
+        ADD     SI,AX                   ; Add it twice since one word in
+        ADD     SI,AX                   ;  table per command.
+        JMP     WORD PTR [SI]           ; GO DO COMMAND
+
+;**     IOCTL_FLUSH -- Flush the cache, but keep the data
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_FLUSH:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1
+        CALL    FLUSH_WHOLE_CACHE
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+;**     IOCTL_FLUSH_INVALIDATE -- Flush the cache, and discard the data
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_FLUSH_INVALID:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1
+        CALL    FLUSH_WHOLE_CACHE
+        CALL    INVALIDATE_CACHE
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+;**     IOCTL_DISABLE -- Disable the caching for both reads and writes
+;
+;   Also flush and invalidate the cache
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_DISABLE:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1
+        CALL    FLUSH_WHOLE_CACHE
+        CALL    INVALIDATE_CACHE
+        MOV     [ENABLE_13],0
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+;**     IOCTL_ENABLE --  Enable the caching for reads (and possibly writes)
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_ENABLE:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [ENABLE_13],1
+        JMP     DEVEXIT
+
+;**     IOCTL_WRITE_MOD -- En/Disable Write through and write caching
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+;   Second byte of data indicates what to set
+;       0 Turn off Write through
+;       1 Turn on Write through
+;       2 Turn off Write buffering (also flush)
+;       3 Turn on Write buffering (also flush)
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_WRITE_MOD:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CMP     CX,2            ; Did user write enough?
+        JB      SET_ZR          ; No, error
+        MOV     AL,ES:[DI.1]    ; Get second byte
+        CMP     AL,3            ; In range?
+        JA      SET_ZR          ; No, error
+        CMP     AL,2            ; WT or WB?
+        JB      SET_WRITE_TH    ; WT
+        DEC     AL
+        DEC     AL                      ; 2 = 0, 3 = 1
+        MOV     [INT_13_BUSY],1
+        MOV     [WRITE_BUFF],AL
+        CALL    FLUSH_WHOLE_CACHE
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+SET_WRITE_TH:
+        MOV     [WRITE_THROUGH],AL
+        JMP     DEVEXIT
+
+;**     IOCTL_SET_TICK -- Set tick count for auto flush
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+;   Second byte and third byte of data is value to set
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_SET_TICK:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CMP     CX,3            ; Did user write enough?
+        JB      SET_ZRJ         ; No, error
+        MOV     AX,ES:[DI.1]    ; Get second byte and third byte as word
+        MOV     [TICK_SETTING],AX
+        JMP     DEVEXIT
+
+SET_ZRJ:
+        JMP      SET_ZR
+
+;**     IOCTL_LOCK -- Lock the current cache
+;
+;   Also flush the cache
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_LOCK:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1
+        CALL    FLUSH_WHOLE_CACHE
+        MOV     [LOCK_CACHE],1
+    ;
+    ; Lock all cache elements that have something in them
+    ;
+        MOV     SI,[CACHE_HEAD]
+        INC     SI
+NEXTCS:
+        DEC     SI
+        TEST    [SI.TRACK_FLAGS],TRACK_FREE
+        JNZ     SKIPCS
+        OR      [SI.TRACK_FLAGS],TRACK_LOCKED
+SKIPCS:
+        MOV     SI,[SI.FWD_LRU_LNK]
+        INC     SI
+        JNZ     NEXTCS
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+;**     IOCTL_UNLOCK --  Unlock the cache
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_UNLOCK:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1
+        MOV     [LOCK_CACHE],0
+    ;
+    ; UnLock all cache elements
+    ;
+        MOV     SI,[CACHE_HEAD]
+        INC     SI
+NEXTCX:
+        DEC     SI
+        AND     [SI.TRACK_FLAGS],NOT TRACK_LOCKED
+        MOV     SI,[SI.FWD_LRU_LNK]
+        INC     SI
+        JNZ     NEXTCX
+        MOV     [INT_13_BUSY],0
+        JMP     DEVEXIT
+
+;**     IOCTL_REBOOT -- En/Disable Reboot flush
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+;   Second byte of data indicates what to set
+;       0 Turn off reboot flush
+;       1 Turn on reboot flush
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_REBOOT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CMP     CX,2            ; Did user write enough?
+        JB      SET_ZRJ         ; No, error
+        MOV     AL,ES:[DI.1]    ; Get second byte
+        CMP     AL,1            ; In range?
+        JA      SET_ZRJ         ; No, error
+        MOV     [REBOOT_FLUSH],AL
+        JMP     DEVEXIT
+
+
+;**     IOCTL_STAT_RESET -- Reset the INT 13 statistics counters
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_STAT_RESET:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        XOR     AX,AX
+        MOV     WORD PTR [TOTAL_WRITES],AX
+        MOV     WORD PTR [TOTAL_WRITES + 2],AX
+        MOV     WORD PTR [WRITE_HITS],AX
+        MOV     WORD PTR [WRITE_HITS + 2],AX
+        MOV     WORD PTR [TOTAL_READS],AX
+        MOV     WORD PTR [TOTAL_READS + 2],AX
+        MOV     WORD PTR [READ_HITS],AX
+        MOV     WORD PTR [READ_HITS + 2],AX
+        JMP     DEVEXIT
+
+;**     IOCTL_ALL_CACHE -- En/Disable All cache
+;
+; ENTRY:
+;   ES:DI is transfer address
+;   CX is transfer count
+;   Second byte of data indicates what to set
+;       0 Turn off all cache
+;       1 Turn on all cache
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+IOCTL_ALL_CACHE:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CMP     CX,2            ; Did user write enough?
+        JB      SET_ZRJ2        ; No, error
+        MOV     AL,ES:[DI.1]    ; Get second byte
+        CMP     AL,1            ; In range?
+        JA      SET_ZRJ2        ; No, error
+        MOV     [ALL_CACHE],AL
+        JMP     DEVEXIT
+
+SET_ZRJ2:
+        JMP     SET_ZR
+
+;**     ioctl_reduce_cache_size  Dynamically reduce the size of the cache
+;
+; This routine dynamically reduces the size of an Above Board memory (/A)
+; cache.  The routine is passed the number of pages that the cache should
+; be reduced by.  The minimum size for a cache is 64K or 4 pages.  In
+; removing the tracks from the cache, the memory is returned to the EMM
+; and then the cache control structures for that memory are taken off the
+; LRU list, and set to free.
+;
+; NOTE: In this version of INT13, only reads are cached, so that when
+;       a cached track is "removed" from memory, it's contents are not
+;       updated to disk.
+;
+; ENTRY:
+;   ES:DI is transfer address
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+error_reduce_exitj:
+        jmp     error_reduce_exit
+
+ioctl_reduce_cache_size:
+        assume  ds:Int13Code
+        assume  es:nothing
+        assume  ss:nothing
+
+        cmp     byte ptr [driver_sel],1 ; Make sure using Above Board
+        jnz     error_reduce_exitj
+        mov     ax,es:[di.1]            ; Get second byte
+        or      ax,ax                   ; Reduce by a non-0 amount?
+        jnz     do_it
+        jmp     devexit
+do_it:  mov     cl,4                    ; Multiply by 16 to get # of K bytes
+        shl     ax,cl                   ; AX has requested reduction in K
+        mov     bx,word ptr [current_dev_size]
+        mov     si,bx                   ; Save current_dev_size in SI for error
+        sub     bx,ax                   ; BX now has remaining cache memory in K
+        cmp     bx,MIN_CACHE_SIZE_K     ; Compare BX with min cache in K bytes
+        jl      error_reduce_exitj
+        mov     word ptr [current_dev_size],bx
+        shr     bx,cl                   ; BX has new cache size in pages
+        mov     byte ptr [int_13_busy],1
+;
+; Request Reallocation of Pages from EMM
+;
+        push    ax
+        mov     dx,word ptr [above_pid]
+        mov     ah,ABOVE_REALLOCATE_PID
+        int     67h
+        or      ah,ah
+        jnz     real_fail
+;
+; Determine how many cache tracks will be lost
+;
+        mov     bx,word ptr [sectrack]  ; Init code checked for too large track
+        mov     cl,9
+        shl     bx,cl                   ; BX has bytes/track
+        mov     ax,word ptr [ttracks]
+        mul     bx                      ; AX:DX has bytes used by tracks
+        xchg    ax,si
+        mov     di,dx
+        mov     cx,1024
+        mul     cx                      ; AX:DX has total bytes allocated
+        sub     ax,si                   ; Find difference in allocated and used
+        sbb     dx,di
+        xchg    ax,si
+        xchg    dx,di
+        pop     ax                      ; AX still has requested reduction in K
+        mul     cx                      ; DX:AX has requested reduction in byte
+
+;
+; Make sure the we have to free up tracks in order to satisfy the request
+; HACK! HACK! HACK!  Smartdrv should only allocate as many pages as it needs.
+; ChipA 14-Mar-1988
+;
+        cmp     dx,di
+        ja      free_tracks
+        jb      no_need_to_free_tracks
+        cmp     ax,si
+        ja      free_tracks
+no_need_to_free_tracks:
+        sub     ax,ax
+        mov     dx,ax
+        jmp     all_freed
+
+free_tracks:
+        sub     ax,si                   ; Account for part not used
+        sbb     dx,di
+        div     bx                      ; AX has number of tracks being "lost"
+        or      dx,dx
+        jz      no_remainder
+        inc     ax                      ; Add one more track if remainder
+;
+; Determine which cache control structures we are to remove
+;
+no_remainder:
+        mov     si,ax
+        mov     cx,SIZE CACHE_CONTROL
+        mul     cx
+        xchg    ax,bx                   ; BX has backward offset into CCS's
+        mov     ax,word ptr [ttracks]
+        sub     word ptr [ttracks],si
+        mul     cx                      ; AX has end of Cache Control
+        sub     ax,bx                   ; AX has start offset of CCS's to remove
+        mov     cx,si                   ; CX has number of CCS's to remove
+        mov     si,word ptr [cache_control_ptr]
+        add     si,ax                   ; SI points to first CCS to modify
+;
+; Loop through each cache control structure, removing from LRU list
+;
+remove_cache_entries:
+        mov     word ptr [si].track_flags,TRACK_FREE
+        call    unlink_cache
+        add     si,SIZE CACHE_CONTROL
+        loop    remove_cache_entries
+
+all_freed:
+        mov     byte ptr [int_13_busy],0
+        jmp     devexit
+
+real_fail:
+        pop     ax
+        mov     [current_dev_size],si   ; Restore former dev size
+        mov     byte ptr [int_13_busy],0
+error_reduce_exit:
+        mov     al,0Ch                  ; General failure
+        jmp     err$cnt
+
+
+;**     ioctl_increase_cache_size  Dynamically increase the size of the cache
+;
+; This routine dynamically increases the size of an Above Board memory (/A)
+; cache.  The routine is passed the number of pages that the cache should
+; be increased by.  The maximum size allowed is the size specified from the
+; INT13.SYS command line.  The cache control structures for the memory added
+; to the cache are placed on the LRU list at the LRU position, so that they
+; will be immediately available for incoming tracks.
+;
+; ENTRY:
+;   ES:DI is transfer address
+; EXIT:
+;   Through one of the device exit paths
+; USES:
+;   ALL
+;
+error_increase_exitj:
+        jmp     error_increase_exit
+
+ioctl_increase_cache_size:
+        assume  ds:Int13Code
+        assume  es:nothing
+        assume  ss:nothing
+
+        cmp     [driver_sel],1          ; Make sure using Above Board
+        jnz     error_increase_exitj
+        mov     ax,es:[di.1]            ; Get second byte
+        mov     cl,4                    ; Multiply by 16 to get # of K bytes
+        shl     ax,cl                   ; AX has requested addition in K
+        mov     bx,word ptr [current_dev_size]
+        mov     si,bx                   ; Save current dev size for error
+        add     bx,ax                   ; BX now has new cache memory size in K
+        cmp     bx,[dev_size]           ; Compare BX with largest size in K bytes
+        jbe     increase_size_ok
+        mov     bx, [dev_size]          ; Go to MAX size
+        mov     ax, bx
+        sub     ax, si                  ; Correct increase
+increase_size_ok:
+        mov     word ptr [current_dev_size],bx
+        shr     bx,cl                   ; BX has new cache size in pages
+        mov     [int_13_busy],1
+;
+; Request Reallocation of Pages from EMM
+;
+        push    ax
+        mov     dx,[above_pid]
+        mov     ah,ABOVE_REALLOCATE_PID
+        int     67h
+        or      ah,ah
+        jnz     realloc_fail
+;
+; Determine how many cache tracks will be gained
+;
+        mov     bx,word ptr [sectrack]  ; Init code checked for too large track
+        mov     cl,9
+        shl     bx,cl                   ; BX has bytes/track
+        mov     ax,word ptr [ttracks]
+        mul     bx                      ; AX:DX has bytes used by tracks
+        xchg    ax,si
+        mov     di,dx
+        mov     cx,1024
+        mul     cx                      ; AX:DX has total bytes allocated
+        sub     ax,si                   ; Find difference in allocated and used
+        sbb     dx,di
+        xchg    ax,si
+        xchg    dx,di
+        pop     ax                      ; AX still has requested reduction in K
+        mul     cx                      ; DX:AX has requested reduction in byte
+        add     ax,si                   ; Account for part not used
+        adc     dx,di
+        div     bx                      ; AX has number of tracks being "gained"
+        or      ax, ax                  ; DIV trashes flags
+        jz      nothing_to_gain
+;
+; Determine which cache control structures we are to add
+;
+        mov     si,ax
+        mov     cx,SIZE CACHE_CONTROL
+        mov     ax,[ttracks]
+        add     [ttracks],si            ; Update TTRACKS
+        mul     cx                      ; AX has end of Cache Control
+        mov     cx,si                   ; CX has number of CCS's to add
+        mov     si,[cache_control_ptr]
+        add     si,ax                   ; SI points to first CCS to modify
+;
+; Loop through each cache control structure, adding to LRU list
+;
+add_cache_entries:
+        mov     di,si                   ; Place element at LRU position
+        xchg    di,[cache_tail]
+        mov     [di].fwd_lru_lnk,si
+        mov     [si].back_lru_lnk,di
+        mov     [si].fwd_lru_lnk,-1
+        mov     [si].track_flags,TRACK_FREE
+
+        add     si,SIZE CACHE_CONTROL
+        loop    add_cache_entries
+nothing_to_gain:
+        mov     [int_13_busy],0
+        jmp     devexit
+
+realloc_fail:
+        pop     ax
+        mov     [current_dev_size],si   ; Restore to original size
+        mov     [int_13_busy],0
+error_increase_exit:
+        mov     al,0Ch                  ; General failure
+        jmp     err$cnt
+
+
+;
+; If the device errors out during install, we set the break address here.
+;
+ERROR_END LABEL BYTE
+
+BREAK   <INT 1C (timer) handler>
+
+        EVEN                    ; Force word align
+;
+; Storage for the INT 1C vector BEFORE cache installed
+;
+OLD_1C  DD      ?
+
+;**     INT_1C_HANDLER - Handler for INT 1C timer ticks
+;
+; ENTRY
+;       None
+;
+; EXIT
+;       To next 1C handler, EOI may be sent
+;
+; USES
+;       None
+;
+; SEE ALSO
+;       IBM PC TECH REF MANUAL section on INT 1C
+;       DOS PRINT utility (most of this is stolen from there)
+;
+INT_1C_HANDLER  PROC    FAR
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    AX
+        DEC     [TICK_CNT]
+        JNZ     CHAIN_1C
+        CMP     [INT_13_BUSY],0
+        JZ      TRY_FLSH
+RE_TRIGGER:
+        INC     [TICK_CNT]              ; Set it back to 1 so next tick triggers
+CHAIN_1C:
+        POP     AX
+        JMP     [OLD_1C]
+
+TRY_FLSH:
+        mov     al,00001011b            ; Select ISR in 8259
+        out     20H,al
+        jmp     short yyyy
+yyyy:
+        jmp     short zzzz
+zzzz:
+        in      al,20H                  ; Get ISR register
+        and     al,0FEH                 ; Mask timer int
+        jnz     RE_TRIGGER              ; Another int is in progress
+        INC     [INT_13_BUSY]           ; Exclude
+        CMP     [DIRTY_CACHE],0         ; Anything to do?
+        JZ      SKIP_FLSH               ; No
+        STI
+        mov     al,20H
+        out     20H,al
+        CALL    FLUSH_WHOLE_CACHE_SAV
+SKIP_FLSH:
+        MOV     AX,[TICK_SETTING]
+        CLI
+        MOV     [TICK_CNT],AX
+        MOV     [INT_13_BUSY],0
+        JMP     CHAIN_1C
+
+INT_1C_HANDLER  ENDP
+
+BREAK   <INT 13 handler>
+
+
+; INT 13 stack frame
+;
+STACK_FRAME STRUC
+USER_OFF    DW  ?           ; added for user transfer address
+USER_ES DW      ?
+USER_DS DW      ?
+USER_DI DW      ?
+USER_SI DW      ?
+USER_BP DW      ?
+        DW      ?
+USER_BX DW      ?
+USER_DX DW      ?
+USER_CX DW      ?
+USER_AX DW      ?
+USER_IP DW      ?
+USER_CS DW      ?
+USER_FL DW      ?
+STACK_FRAME ENDS
+
+        EVEN                    ; Force word align
+;
+; Storage for the INT 13 vector BEFORE cache installed
+;
+OLD_13  DD      ?
+
+;
+; Array of sec/track for all hardfiles on system. First element cooresponds
+;   to first hard file.
+;       Value = 0 indicates no hardfile
+;
+SECTRKARRAY     DB  MAX_HARD_FILES DUP (0)
+;
+; ARRAY OF MAXIMUM USEABLE HEADS FOR ALL THE HARDFILES IN THE SYSTEM. FIRST
+; ELEMENT CORRESPONDS TO FIRST HARDFILE.
+;       VALUE = FF  INDICATES NO HARDFILE   (SUNILP)
+;
+HDARRAY         DB  MAX_HARD_FILES DUP (0FFH)
+
+ifdef   OMTI
+OMTI_SET_CYL    EQU     0EEh
+OMTI_GET_CYL    EQU     0FEh
+OMTI_GET_REV    EQU     0F9h
+endif   ;OMTI
+;
+; INT 13 function dispatch
+;       Addresses of routines for AH INT 13 functions
+;
+INT13DISPATCH   LABEL   WORD
+        DW      POP_NO_PROC             ; 0, reset
+        DW      POP_NO_PROC             ; 1, Read status
+        DW      CACHE_READ              ; 2, read
+        DW      CACHE_WRITE             ; 3, write
+        DW      POP_NO_PROC             ; 4, verify
+        DW            INVALID_PASS      ; 5, format
+        DW            INVALID_PASS      ; 6, format
+        DW            INVALID_PASS      ; 7, format
+        DW      POP_NO_PROC             ; 8, drive parms
+        DW            INVALID_PASS      ; 9, Init drive characteristic
+        DW            INVALID_PASS      ; A, Read long
+        DW            INVALID_PASS      ; B, Write long
+        DW      POP_NO_PROC             ; C, Seek
+        DW      POP_NO_PROC             ; D, Alt reset
+        DW            INVALID_PASS      ; E, Read buffer
+        DW            INVALID_PASS      ; F, Write buffer
+        DW      POP_NO_PROC             ; 10, Test drive rdy
+        DW      POP_NO_PROC             ; 11, Recalibrate
+        DW      POP_NO_PROC             ; 12, Controller diag
+        DW            INVALID_PASS      ; 13, Drive diag
+        DW      POP_NO_PROC             ; 14, Controller diag internal
+        DW      POP_NO_PROC             ; 15, READ DASD
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;       MODIFICATIONS TO DATA STRUCT TO SUPPORT MULTI-TRACK I/O
+;
+;       sunilp
+;
+; extra declarations needed
+;
+max_hd          db      ?       ;maximum useable head number for curr. drive
+sect_in_trk     db      ?       ;maximum sector number in trk for curr drive
+bytes_in_trk    dw      ?       ;numb of bytes in trk for current drive
+int13err        db      ?
+;
+TRUE            =       0ffH
+FALSE           =       NOT TRUE
+REG1_P  =       001B
+REG2_P  =       010B
+REG3_P  =       100B
+;
+REG1t   struc
+START_H db      ?       ;start head
+START_T dw      ?       ;start track
+COUNT   dw      ?       ;number of words
+START_S dw      ?       ;start sector
+REG1t   ends
+;
+REG2t   struc
+        db      ?       ;start head
+        dw      ?       ;start track
+TRACKS  db      ?       ;number of tracks
+REG2t   ends
+;
+REG3t   struc
+        db      ?       ;start head
+        dw      ?       ;start track
+        dw      ?       ;number of words
+REG3t   ends
+;
+REGIONt struc
+FLAG    db      0
+REG1    db      size REG1t dup(?)
+REG2    db      size REG2t dup(?)
+REG3    db      size REG3t dup(?)
+REGIONt ends
+;
+;
+REGION  db      size REGIONt dup(?)
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;       INT_13_HANDLER - Handler for INT 13 requests
+;
+; ENTRY
+;       All regs as for INT 13
+;
+; EXIT
+;       To old INT 13 handler with regs unchanged if cache not involved
+;       Else return in AH and flags as per INT 13.
+;
+; USES
+;       AH and carry bit of FLAGS
+;
+; SEE ALSO
+;       IBM PC TECH REF MANUAL section on INT 13
+;
+INT_13_HANDLER  PROC    FAR
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1 ; Exclude
+        TEST    DL,80H          ; Hard file?
+        JNZ     IS_HARD         ; Yes
+NO_PROC:
+        PUSHF
+        CLI
+        CALL    [OLD_13]        ; Let old handler do it
+        MOV     [INT_13_BUSY],0 ; Clear sem
+        RET     2               ; "IRET" chucking flags
+
+;
+; Pop off the stack frame and pass to old handler
+;
+POP_NO_PROC:
+        POP     BX
+        POP     ES
+        POP     DS
+    ; Simulate POPA
+        POP     DI
+        POP     SI
+        POP     BP
+        POP     BX              ; Dummy for pop sp
+        POP     BX
+        POP     DX
+        POP     CX
+        POP     AX
+    ;
+        JMP     NO_PROC
+
+IS_HARD:
+        STI                     ; INTs ok now
+    ;
+    ; Set up standard stack frame
+    ;
+    ; Simulate PUSHA
+        PUSH    AX
+        PUSH    CX
+        PUSH    DX
+        PUSH    BX
+        PUSH    BX              ; dummy for push sp
+        PUSH    BP
+        PUSH    SI
+        PUSH    DI
+    ;
+        PUSH    DS
+        PUSH    ES
+        push    bx
+    ; Set frame pointer
+        MOV     BP,SP
+        MOV     BL,AH
+        XOR     BH,BH                   ; Command in BX
+        PUSH    CS
+        POP     DS
+ASSUME  DS:INT13CODE
+        CMP     [ENABLE_13],0           ; Are we enabled?
+        JZ      POP_NO_PROC             ; No, ignore
+
+ifdef   OMTI
+;
+; The following code is used to handle the extended cylinder access method
+; used by the OMTI controller.  This controller has a modified INT13 routine
+; that uses a unique function number to tell the controller that the next
+; access to INT13 is for an extended cylinder.
+;
+        test    sys_flg,OMTI_EXT        ; Are we in extended state?
+        jnz     in_extended_state
+        cmp     bx,OMTI_SET_CYL         ; Is this the OMTI extended function?
+        jnz     check_command_range
+        or      sys_flg,OMTI_EXT
+        jmp     pop_no_proc
+in_extended_state:
+;
+; If we are in the extended state, we want to make sure that this call
+; does not go through into the cache.  Therefore, we will check to see
+; if this is a read or write function, and will return to the old INT13
+; routine if so.
+;
+        and     sys_flg,NOT OMTI_EXT    ; Clear the extended flag
+        cmp     bx,2h                   ; READ
+        jz      pop_no_proc
+        cmp     bx,3h                   ; WRITE
+        jz      pop_no_proc
+check_command_range:
+;
+; Allow the other OMTI functions to pass through
+;
+        cmp     bx,OMTI_GET_CYL
+        jz      pop_no_proc
+        cmp     bx,OMTI_GET_REV
+        jz      pop_no_proc
+endif ; OMTI
+
+        CMP     BX,15H                  ; Command in range?
+        JA            INVALID_PASS      ; No, throw out cache
+        SHL     BX,1                    ; Times two bytes per table entry
+        JMP     [BX.INT13DISPATCH]      ; Dispatch to handler
+
+;**    FLUSH_INVALID_PASS -- Discard cache and pass through
+;
+; ENTRY:
+;   INT 13 regs except for BP,BX and DS
+; EXIT:
+;   To old INT13 handler
+;
+FLUSH_INVALID_PASS:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CALL    FLUSH_WHOLE_CACHE
+        CALL    INVALIDATE_CACHE
+        JMP     POP_NO_PROC
+
+;**    INVALID_PASS -- DISCARD CACHE, NO NEED TO FLUSH, PASS THROUGH
+;
+;**     SUNIL PAI
+;
+; ENTRY:
+;   INT 13 regs except for BP,BX and DS
+; EXIT:
+;   To old INT 13 handler
+;
+INVALID_PASS:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CALL    INVALIDATE_CACHE
+        JMP     POP_NO_PROC
+
+;**    FLUSH_PASS -- Flush cache (but retain data) and pass through
+;
+; ENTRY:
+;   INT 13 regs except for BP,BX and DS
+; EXIT:
+;   To old INT13 handler
+;
+FLUSH_PASS:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        CALL    FLUSH_WHOLE_CACHE
+        JMP     POP_NO_PROC
+
+BREAK   <CACHE_READ -- Read via cache>
+
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+;
+cache_read:
+;
+;       inputs: int13 regs except for bp - user stack frame
+;                                     bx - function (read,write)
+;                                     ds - int13code segment
+;
+;       exits:  to user success routine
+;               to user error routine
+;               to old int13 handler call
+;
+;       uses:   all but bp
+;
+;       written by: sunil pai
+;
+        call    check_parameters        ; check user params
+        jc      pop_no_proc             ; if error go to old int 13 handler
+                                        ;
+        call    process_regions         ; for multi-track business find the
+                                        ; initial partial track, middle block
+                                        ; and final partial track
+                                        ; sets up REGION struct
+;
+;       mov     [int13err],FALSE        ; clear int 13 error flag
+;
+        test    [REGION.FLAG],REG1_P    ; is region1 present
+        je      cr$2                    ; if not present try region2
+;
+        mov     dh,[REGION.REG1.START_H]        ;start head
+        mov     cx,[REGION.REG1.START_T]        ;get start track
+        mov     bx,[REGION.REG1.START_S]        ;start sector
+        mov     ax,[REGION.REG1.COUNT]          ;number of words
+        call    process_read_partial            ;
+        jc      error                   ;go to process error
+;
+cr$2:   test    [REGION.FLAG],REG2_P    ; is region2 present
+        je      cr$3                    ; if not present try region3
+;
+        mov     dh,[REGION.REG2.START_H]        ; get start head
+        mov     cx,[REGION.REG2.START_T]        ; get start track
+        mov     al,[REGION.REG2.TRACKS]         ; get number of tracks
+        call    process_block_read              ; multi track capability
+        jc      error                           ; fouled?
+;
+cr$3:   test    [REGION.FLAG],REG3_P    ; is region3 present
+        je      suc                     ; if not we are done
+;
+        mov     dh,[REGION.REG3.START_H]        ; start head
+        mov     cx,[REGION.REG3.START_T]        ; start track
+        mov     bx,1                            ; start sector is 1
+        mov     ax,[REGION.REG3.COUNT]          ; number of words
+        call    process_read_partial            ;
+        jc      error                           ; just as we were about to fin!
+;
+;       exit points - suc and error.
+;
+suc:    and     [bp.USER_FL],NOT f_Carry        ;
+        mov     byte ptr [bp.USER_AX.1],0       ;
+;
+operation_done:
+        mov     cs:[int_13_busy],0              ;clear semaphore
+        pop     bx                      ;user offset
+;
+;       simulate popa
+;
+        pop     es
+        pop     ds
+        pop     di
+        pop     si
+        pop     bp
+        pop     bx
+        pop     bx
+        pop     dx
+        pop     cx
+        pop     ax
+;
+        iret
+;
+error:
+;
+;       the next two instructions were removed because of the way Compaq
+;       handles bad sectors. they mark sectors bad not tracks. so in a
+;       track there may be good and bad sectors. However our int13 caching
+;       system does i/o from disk in tracks and will not get any track with
+;       bad sectors. to take care of this, we pass the read to the old int13
+;       handler even when there is an int 13 error
+;
+;       test    [int13err],TRUE
+;       jne     er$1                    ;if not int13 error go to call
+                                        ;int13
+        jmp     pop_no_proc
+;er$1:  or      [bp.USER_FL],f_Carry    ;
+;       mov     byte ptr [bp.USER_AX.1],AL      ;int13 error code
+;       jmp     operation_done
+;
+pop_no_procw:
+        call    invalidate_cache
+        jmp     pop_no_proc
+;
+cache_write:
+;
+;       inputs: int13 regs except for bp - user stack frame
+;                                     bx - function (read,write)
+;                                     ds - int13code segment
+;
+;       uses:   all but bp
+;
+;       written by: sunil pai
+;
+        call    check_parameters        ;check user params
+        jc      pop_no_procw            ;error
+                                        ;
+        call    process_regions         ;for multi-track business find the
+                                        ;initial partial track, middle block
+                                        ;and final partial track
+                                        ;sets up REGION struct
+;
+;       writes always update disk, i.e., write through always operational
+;
+        mov     ax,[bp.user_ax]         ; restore int13 registers
+        mov     cx,[bp.user_cx]         ;
+        mov     dx,[bp.user_dx]         ;
+        mov     bx,[bp.user_bx]         ;
+        mov     es,[bp.user_es]         ;
+        pushf                           ; since interrupt routine being called
+        cli
+        call    [old_13]                ; call old int 13 handler
+        jnc     cw$1                    ; no error in writing to disk, continue
+;
+        or      [bp.user_fl],f_Carry    ; error then set carry
+        mov     byte ptr [bp.user_ax.1],ah       ; and error code
+        jmp     short errorw            ; and take error exit
+;
+;       int 13 was successful, now we have to update cache as well
+;
+cw$1:   and     [bp.user_fl],not f_Carry        ; int 13 success
+        mov     byte ptr [bp.user_ax.1],0        ;
+;
+        and     dl,not 80h
+;
+        test    [REGION.FLAG],REG1_P    ; is region1 present
+        je      cw$2                    ; if not present try region2
+;
+        mov     dh,[REGION.REG1.START_H]        ; get start head
+        mov     cx,[REGION.REG1.START_T]        ; get start track
+        mov     bx,[REGION.REG1.START_S]        ; start sector
+        mov     ax,[REGION.REG1.COUNT]          ; number of words
+        call    process_write_partial           ; partial write
+        jc      errorw                  ; go to process error
+;
+cw$2:   test    [REGION.FLAG],REG2_P    ; is region2 present
+        je      cw$3                    ; if not present try region3
+;
+        mov     dh,[REGION.REG2.START_H]        ; get start head
+        mov     cx,[REGION.REG2.START_T]        ; get start track
+        mov     al,[REGION.REG2.TRACKS]         ; get number of tracks
+        call    process_block_write             ;
+        jc      errorw                          ; fouled?
+;
+cw$3:   test    [REGION.FLAG],REG3_P    ; is region3 present
+        je      operation_donew                 ; if not we are done
+;
+        mov     dh,[REGION.REG3.START_H]        ; start head
+        mov     cx,[REGION.REG3.START_T]        ; start track
+        mov     bx,1                            ; start sector is 1
+        mov     ax,[REGION.REG3.COUNT]          ; number of words
+        call    process_write_partial           ;
+        jnc     operation_donew                 ; no error - finish
+;
+errorw: call    invalidate_cache                ; we are not sure of the
+operation_donew:
+        jmp     operation_done
+;
+;
+INT_13_HANDLER  endp
+;
+process_read_partial    proc    near
+;
+;       is used to read a partial track
+;
+;       inputs: dx: head and drive (8th bit stripped)
+;               cx: track
+;               bx: start sector
+;               ax: number of words
+;
+;       outputs:cy set if error
+;                  clear if success
+;
+;       strategy:
+;               if (track in cache) then {
+;                       if (track in track_buffer) then
+;                               perform user read from track buffer;
+;                       else
+;                               perform user read from cache;
+;               }
+;               else {
+;                       read track into track buffer;
+;                       read track buffer into cache;
+;                       perform user read from track buffer;
+;               }
+;
+;       cache transfers handled by freeing cache element if possible
+;       and making it lru
+;
+;       uses: only dx assumed unchanged
+;
+        call    track_in_cache          ; is track in cache
+        jc      read_disk               ; if not we have to read from disk
+;
+        cmp     cx,[track_buffer_cyln]  ; is it in the track buffer
+        jnz     not_in_mem              ; no
+        cmp     dx,[track_buffer_hddr]  ;
+        jz      read_bufferj            ; yes
+;
+;       read buffer from cache
+;
+not_in_mem:
+        push    dx
+        xchg    ax,bx           ;get number of words in bx and start sect in ax
+        dec     ax              ;0 based number
+        mov     cl,9            ;
+        shl     ax,cl           ;byte offset
+        xor     dx,dx           ;
+;
+        mov     cx,bx           ;number of words
+        mov     es,[bp.user_es] ;
+        mov     di,[bp.user_off];
+        shl     bx,1            ; number of bytes
+        add     [bp.user_off],bx        ; update user offset
+;
+        add     ax,word ptr [si.base_offset]
+        adc     dx,word ptr [si.base_offset.2]
+        xor     bh,bh
+        push    si
+        push    ds
+        push    bp
+        call    blkmov
+        pop     bp
+        pop     ds
+        pop     si
+        pop     dx
+        jc      err_cache
+        call    cache_is_mru
+        clc
+        ret
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;       track not in cache. see if free cache available to initiate transfer
+;
+read_disk:
+        cmp     di,-1           ;free cache
+        jnz     rd_part         ;if present we can initiate read
+        stc                     ; else error exit
+        ret
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+read_bufferj:
+        jmp           short read_buffer
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;       cache element available. we can start by transferring track from disk
+;       to track buffer.
+;
+rd_part:
+        mov     si,di           ;get element in si
+        mov     [track_buffer_cyln],-1  ;invalidate present track buffer
+        mov     [track_buffer_hddr],-1
+        mov     [si.track_flags],track_free     ;if read fails
+        push    dx
+        push    cx
+        push    bx
+        push    ax
+        or      cl,1
+        or      dl,80h
+        mov     al,[sect_in_trk]
+        mov     ah,2                    ; read
+        push    cs
+        pop     es
+        mov     bx,[track_buffer_ptr]
+        pushf
+        cli
+        call    [old_13]
+        jnc     rd$1
+        cmp     ah,11h  ;the int13 error which is not an error
+        je      rd$1
+        mov     [int13err],TRUE
+        add     sp,8
+        mov     al,ah
+        stc
+        ret
+;
+;       transfer track buffer to cache
+;
+rd$1:
+        mov     di,[track_buffer_ptr]   ;es:di is transfer address
+        mov     cx,[bytes_in_trk]
+        shr     cx,1                    ; cx is number words in track
+        mov     bh,1            ;write
+        mov     ax,word ptr [si.base_offset]    ;address of cache
+        mov     dx,word ptr [si.base_offset.2]  ;
+        push    ds
+        push    si
+        push    bp
+        call    blkmov
+        pop     bp
+        pop     si
+        pop     ds
+        pop     ax
+        pop     bx
+        pop     cx
+        pop     dx
+        jnc     rd$2
+;
+;       error in transferring info to cache. invalidate cache element and
+;       make it lru
+;
+err_cache:
+        mov     [si.track_flags],track_free
+        call    cache_is_lru            ; make cache element lru
+        stc
+        ret
+;
+;       info transfer to cache successful. fill in track, head and drive
+;       info into cache control element and track buffer control element
+;
+if      debug
+rd_2:
+endif
+rd$2:
+        mov     word ptr [si.track_cyln],cx
+        mov     word ptr [si.track_drive],dx
+        and     [si.track_flags], not track_free
+        mov     word ptr [track_buffer_cyln],cx
+        mov     word ptr [track_buffer_hddr],dx
+;
+;       perform user i/o from track buffer
+;
+read_buffer:
+        call    cache_is_mru
+;
+        mov     si,bx           ; start sector
+        dec     si              ; 0 based number
+        mov     cl,9            ;
+        shl     si,cl           ; byte offset in si
+        add     si,[track_buffer_ptr]
+        mov     cx,ax
+        mov     es,[bp.user_es]
+        mov     di,[bp.user_off]
+        cld
+rep     movsw
+        mov     [bp.user_off],di
+        clc
+        ret
+;
+process_read_partial    endp
+;
+process_block_read      proc    near
+;
+;       inputs: ax = number of tracks
+;               dx = drive and head (8th bit stripped)
+;               cx = start track
+;               bp = user stack frame
+;
+;       outputs: cy set if error
+;                cy clear if okay
+;
+;       algorithm:
+;
+;               repeat
+;                   if (cur_trk in cache) then
+;                           transfer track from cache to user buffer;
+;                           no_of_trks = no_of_trks - 1
+;                   else
+;                           accumulate tracks which are not in cache
+;                           read these in one disk operation
+;                           transfer these from user buffer to cache
+;                           no_of_trks = no_of_trks - accumulated_trks
+;               until no_of_trks == 0
+;
+pbr$1:
+;
+;       since we are going to look ahead and see how many tracks can
+;       be dealt with together, we have to save start head and track
+;
+        push    cx              ; save start head
+        push    dx              ; save start track
+        xor     ah,ah           ;number of accumulated tracks
+pbr$2:  call    track_in_cache  ;
+        jnc     pbr$4           ; if current track in cache start processing
+        inc     dh              ; go to next track
+        call    adj_hd_trk      ;
+        inc     ah              ;accumulate the tracks
+        dec     al              ;are we done
+        jne     pbr$2           ;go to see next track
+        pop     dx              ;restore start head and track
+        pop     cx              ;
+        call    pr_acc_trks     ;process the accumulated tracks
+        ret                     ;we are done
+pbr$4:
+        pop     dx              ;restore start head and track
+        pop     cx
+        or      ah,ah           ;are there any accumulated
+        je      pbr$5
+        call    pr_acc_trks     ;process the accumulated tracks
+        jc      pbr$7           ;if carry set finish with error
+        add     dh,ah           ;adjust track and head
+        call    adj_hd_trk
+        jmp     pbr$1
+;
+pbr$5:  call    pr_cur_trk      ;process current track which is in cache
+        jc      pbr$7           ;if carry set finish with error
+        inc     dh
+        call    adj_hd_trk
+pbr$6:
+        dec     al              ;are we done?
+        jne     pbr$1           ;
+        clc
+pbr$7:  ret
+;
+process_block_read      endp
+;
+pr_acc_trks     proc    near
+;
+;       inputs: cx = start track
+;               dh = start head
+;               ah = number of accumulated tracks
+;
+;       outputs: if success :- cy clear, [bp.user_off] modified
+;                if failure :- cy set
+;
+;       regs to be preserved: al,cx,si
+;
+;       algorithm:
+;
+;               read buffer from disk;
+;               for (cur_trk=start_trk,transfer_off=user_off; no_of_trks-- > 0;
+;               transfer_off=transfer_off+size_of_trk) do
+;                       if ((cache=get_cache())!=-1) then
+;                               transfer_trk_to_cache;
+;                       else
+;                               exit with error;
+;
+;
+        push    si
+        push    dx
+        push    cx
+        push    ax              ; stack:- {ax,cx,dx,si}
+;
+;       initialise int13 registers for reading the accumulated tracks into
+;       user memory.
+;
+        mov     al,ah           ;number of tracks
+        xor     ah,ah           ;in ax
+;
+        mul     [sect_in_trk]   ;get number of sectors in ax
+;
+        mov     ah,2
+        or      cx,1            ;start sector
+;
+        or      dl,80h          ;set hard disk bit
+        mov     bx,[bp.user_off];
+        mov     es,[bp.user_es] ;
+;
+        pushf
+        cli
+        call    [old_13]        ;perform multi track read
+;
+;       check for int 13 error
+;
+        jnc     pat$1           ;if okay proceed
+;
+        add     sp,8            ;clear stack
+        mov     al,ah
+        mov     [int13err],TRUE ;
+        stc
+        ret                     ;error exit
+;
+;       we have succesfully read al tracks into user memory. now these have
+;       to transfer these to cache.
+;
+pat$1:  and     dl,not 80h      ;clear off 8th bit
+        pop     ax              ;restore ax
+        pop     cx              ;
+        push    cx              ;
+        push    ax
+;
+        mov     di,[bp.user_off];initialise transfer offset
+;
+;       ah has number of tracks still left to be transferred
+;       di has transfer offset
+;       cx has current track number
+;       dx has current drive and head
+;
+pat$2:
+        call    get_cache       ;get free cache element
+;
+;       si = cache element
+;
+        cmp     si,-1           ;was there an element
+        je      pat$5           ;cache saturated exit
+;
+;       check if track is in track buffer
+;
+        cmp     cx,[track_buffer_cyln]
+        jne     pat$21
+        cmp     dx,[track_buffer_hddr]
+        jne     pat$21
+;
+;       track is in track buffer. to avoid two transfers invalidate
+;       track buffer
+;
+        mov     [track_buffer_cyln],-1
+        mov     [track_buffer_hddr],-1
+;
+;       transfer track from user buffer to cache
+;
+pat$21: mov     [si.track_flags],track_free    ;if write fails
+        push    cx
+        push    ax
+        push    ds
+        push    si
+        push    bp
+        push    di
+        push    dx
+;
+        mov     es,[bp.user_es]
+        mov     cx,[bytes_in_trk]
+        shr     cx,1                    ;words
+        mov     ax,word ptr [si.base_offset]
+        mov     dx,word ptr [si.base_offset.2]
+        mov     bh,1            ;write
+        call    blkmov
+;
+        pop     dx
+        pop     di
+        pop     bp
+        pop     si
+        pop     ds
+        pop     ax
+        pop     cx
+;
+        jnc     pat$3
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;       error in transferring information to cache. make it lru
+;
+;
+        call    cache_is_lru
+pat$5:
+        add     sp,8
+        stc
+        ret                     ;cache error exit
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;       successfully transferred information to cache. fill in track and
+;       drive and head information into cache control element
+;
+pat$3:  mov     word ptr [si.track_cyln],cx
+        mov     word ptr [si.track_drive],dx
+        and     [si.track_flags],not track_free
+        call    cache_is_mru
+
+;
+        add     di,[bytes_in_trk]   ;advance pointer in user transfer buffer to
+                                    ;next track
+;
+        inc     dh                  ;advance track
+        call    adj_hd_trk
+;
+pat$4:  dec     ah                  ;have we processed all the accumulated trks
+        jne     pat$2
+        mov     [bp.user_off],di    ;update user transfer address to beyond
+                                    ;this accumulated block
+        pop     ax
+        pop     cx
+        pop     dx
+        pop     si
+        clc
+        ret                             ;success exit
+;
+pr_acc_trks     endp
+;
+pr_cur_trk      proc    near
+;
+;       inputs:
+;       si = cache element
+;       cx = current track
+;       dx = drive and head
+;
+;       outputs:
+;       cy = set if error
+;          = clear if success
+;
+;       algorithm:
+;               transfer track from cache to user memory
+;
+        push    ax
+        push    cx
+        push    dx
+        push    si
+        push    ds
+        push    bp
+;
+        mov     cx,[bytes_in_trk]
+        shr     cx,1
+        mov     ax,word ptr [si.base_offset]
+        mov     dx,word ptr [si.base_offset.2]
+        mov     es,[bp.user_es]
+        mov     di,[bp.user_off]
+        xor     bh,bh           ;read
+        call    blkmov
+;
+        pop     bp
+        pop     ds
+        pop     si
+        pop     dx
+        pop     cx
+        pop     ax
+;
+        jnc     pct$1
+;
+        mov     [si.track_flags],track_free
+        call    cache_is_lru
+        stc
+        ret             ;error exit
+;
+pct$1:  call    cache_is_mru
+        mov     di,[bytes_in_trk]
+        add     [bp.user_off],di
+        clc
+        ret
+;
+pr_cur_trk      endp
+;
+process_write_partial   proc    near
+;
+;       is used to write a partial track
+;
+;       inputs: dx: int13 dx with high bit of dl set off
+;               cx: track
+;               bx: start sector
+;               ax: number of words
+;
+;       outputs:cy set if error
+;                  clear if success
+;
+;       strategy:
+;               if (track in cache) then {
+;                       if (track in track_buffer) then
+;                               invalidate track buffer;
+;                       perform user write into cache;
+;               }
+;               else {
+;                       read track into track buffer;
+;                       write track buffer into cache;
+;               }
+;
+;
+        call    track_in_cache          ;is track in cache
+        jc      read_diskw              ;if not we have to read from disk
+;
+        cmp     cx,[track_buffer_cyln]  ;is it in the track buffer
+        jnz     not_in_memw             ;no
+        cmp     dx,[track_buffer_hddr]  ;
+        jnz     not_in_memw             ;no
+                                        ;yes
+;
+        mov     [track_buffer_cyln],-1  ;invalidate trk buf
+        mov     [track_buffer_hddr],-1  ;to avoid two transfers
+;
+;       update cache element from user buffer
+;
+not_in_memw:
+        push    dx
+        xchg    ax,bx           ;get number of words in bx and start sect in ax
+        dec     ax              ;0 based number
+        mov     cl,9            ;
+        shl     ax,cl           ;byte offset
+        xor     dx,dx           ;
+;
+        mov     cx,bx           ;number of words
+        mov     es,[bp.user_es] ;
+        mov     di,[bp.user_off];
+        shl     bx,1
+        add     [bp.user_off],bx
+;
+        add     ax,word ptr [si.base_offset]
+        adc     dx,word ptr [si.base_offset.2]
+        mov     bh,1            ;write
+        push    si
+        push    ds
+        push    bp
+        call    blkmov
+        pop     bp
+        pop     ds
+        pop     si
+        pop     dx
+        jc      err_cw
+        call    cache_is_mru
+        clc
+        ret
+;
+;       cache error
+;
+err_cw: mov     [si.track_flags],track_free
+        call    cache_is_lru
+        stc
+        ret
+;
+;       track not in cache. see if free cache element available
+;
+read_diskw:
+        cmp     di,-1           ;free cache
+        jnz     rd_partw        ;if present we can initiate read
+        stc
+        ret
+;
+;       free cache element available. read track from disk into track buffer
+;
+rd_partw:
+        mov     si,di           ;get element in si
+        mov     [track_buffer_cyln],-1
+        mov     [track_buffer_hddr],-1
+        mov     [si.track_flags],track_free
+        push    dx
+        push    cx
+        push    bx
+        push    ax
+        or      cl,1
+        or      dl,80h
+        mov     al,[sect_in_trk]
+        mov     ah,2
+        push    cs
+        pop     es
+        mov     bx,[track_buffer_ptr]
+        pushf
+        cli
+        call    [old_13]
+        jnc     wr$1
+        cmp     ah,11h  ;the int13 error which is not an error
+        je      wr$1
+        mov     [int13err],TRUE
+        add     sp,8
+        mov     al,ah
+        stc
+        ret
+;
+;       since we have already updated disk, the track read doesn't need
+;       to be updated from user buffer. transfer track from track buffer
+;       into cache
+;
+wr$1:   mov     di,[track_buffer_ptr]   ;es:di is transfer address
+        mov     al,[sect_in_trk]
+        xor     ah,ah
+        mov     cl,8
+        shl     ax,cl
+        mov     cx,ax
+        mov     bh,1            ;write
+        mov     ax,word ptr [si.base_offset]
+        mov     dx,word ptr [si.base_offset.2]
+        push    ds
+        push    si
+        push    bp
+        call    blkmov
+        pop     bp
+        pop     si
+        pop     ds
+        pop     ax
+        pop     bx
+        pop     cx
+        pop     dx
+        jnc     wr$2
+        ret
+;
+;       information successfully transferred to cache. fill in cache
+;       control element with the info on head, drive and track
+;
+wr$2:
+        mov     word ptr [si.track_cyln],cx
+        mov     word ptr [si.track_drive],dx
+        and     [si.track_flags], not track_free
+        mov     word ptr [track_buffer_cyln],cx
+        mov     word ptr [track_buffer_hddr],dx
+;
+        call    cache_is_mru
+;
+        shl     ax,1
+        add     [bp.user_off],ax
+        clc
+        ret
+;
+process_write_partial   endp
+;
+;
+process_block_write     proc    near
+;
+;       al = number of tracks
+;       cx = start track
+;       dx = drive and start head
+;       bp = user stack frame
+;
+;       cy set if error
+;       cy clear if success
+;
+;       algorithm: for (cur_trk=st_trk; trks-- > 0; )
+;                       if (cur_trk in cache) then
+;                           write cur_trk from user buffer into cache;
+;                       else {
+;                           get a free cache element;
+;                           write cur_trk from user buffer into this cache elem
+;                       }
+;
+        mov     di,[bp.user_off]
+;
+pbw$1:  push    di              ;save it because next call destroys di
+        call    track_in_cache  ;is the track in cache
+        jnc     pbw$2
+;
+        cmp     di,-1           ;no free cache
+        je      pbw$4           ;error exit
+;
+        mov     si,di           ;track was not in cache. now there will be one
+        mov     [si.track_flags],track_free
+        mov     word ptr [si.track_cyln],cx
+        mov     word ptr [si.track_drive],dx
+;
+pbw$2:  pop     di
+;
+;       check if it is in track buffer also in which case invalidate trk buffer
+;
+        cmp     cx,[track_buffer_cyln]
+        jne     pbw$21
+        cmp     dx,[track_buffer_hddr]
+        jne     pbw$21
+;
+;       invalidate track buffer to avoid two transfers
+;
+        mov     [track_buffer_cyln],-1
+        mov     [track_buffer_hddr],-1
+;
+;       update cache from user buffer
+pbw$21:
+        push    cx              ;
+        push    ax
+        push    ds
+        push    si
+        push    bp
+        push    di
+        push    dx
+;
+        mov     es,[bp.user_es]
+        mov     cx,[bytes_in_trk]
+        shr     cx,1
+        mov     ax,word ptr [si.base_offset]
+        mov     dx,word ptr [si.base_offset.2]
+        mov     bh,1
+        call    blkmov
+;
+        pop     dx
+        pop     di
+        pop     bp
+        pop     si
+        pop     ds
+        pop     ax
+        pop     cx
+;
+        jnc     pbw$22
+        jmp     err_cw
+;
+pbw$22: and     [si.track_flags],not track_free
+;
+        inc     dh              ;go to next track
+        call    adj_hd_trk
+pbw$3:  add     di,[bytes_in_trk]
+        call    cache_is_mru
+;
+        dec     al              ; are we done
+        jne     pbw$1
+;
+;       success exit
+        mov     [bp.user_off],di
+        clc
+        ret
+;
+;       error exit
+;
+pbw$4:  pop     di
+        stc
+        ret
+;
+process_block_write     endp
+;
+check_parameters        proc    near
+;
+;       inputs: same as int13 registers except for
+;               BP - user_stack_frame
+;               BX - function (either read or write)
+;               DS - int13code segment
+;
+;       outputs: carry set if params invalid
+;                carry clear if params okay
+;
+;                if parameters okay :
+;                dl - drive with high bit off
+;                bx - sector number
+;                cl - cleared of the sector number
+;
+;
+;       check for number of drives
+;
+        and     dl, not 80H             ; turn off high bit of drive
+        cmp     dl,MAX_HARD_FILES       ; more than allowed drives?
+        jae     bad_parmx               ; error.
+;
+;       check for number of sectors
+;
+        or      al,al                   ; zero sectors ?
+        je      bad_parmx               ; error.
+;
+        cmp     al,80h                  ; more than 80h sectors ?
+        ja      bad_parmx               ; error.
+;
+;       check for wrap in user transfer address
+;
+        mov     di,[bp.user_bx]         ; es:di is transfer address
+        xor     ah,ah                   ; ax has number of sectors
+        mov     si,ax                   ; get it into si
+        push    cx                      ;
+        mov     cl,9
+        shl     si,cl                   ; convert number of sectors into
+                                        ; number of bytes
+        dec     si                      ; convert into zero based number
+        pop     cx                      ;
+        add     di,si                   ; add to transfer address offset
+        jc      bad_parmx               ; if exceeds 64k offset then wrap
+;
+;       get drive number into di to use as offset into sect / trk table
+;
+        mov     di,dx                   ; drive number
+        and     di,0000000011111111B    ; just get the relevant bits
+;
+;       form sector number in bx and compare against allowed number of sectors
+;       in track on the drive indicated
+;
+        mov     bx,cx                   ;
+        and     bx,0000000000111111B    ; bl will then have sector number
+        or      bx,bx                   ; zero sector number
+        je      bad_parmx               ; is bad
+        cmp     bl, [di.sectrkarray]    ; is it more than number of sectors
+                                        ; allowed
+        ja      bad_parmx               ;
+;
+;       check head parameter
+;
+        cmp     dh,[di.hdarray]         ; is it more than max useable val for drive
+        ja      bad_parmx               ;
+;
+;       do we need some code to check if read exceeds tracks in system ?
+;       should we also put a limit on the number of sectors that could
+;       be looked up in cache ?
+;
+;
+;       clear off sector number from cl to leave just trk number in cx
+;
+        and     cl,11000000B            ; clear off sector number
+;
+;       store sectors in track for current drive and bytes in track for
+;       current drive in memory
+;
+        push    bx
+        push    cx
+        mov     bl,[di.hdarray]
+        mov     [max_hd],bl           ; maximum head number for cur. drive
+        mov     bl,[di.sectrkarray]     ; number of sectors in trk
+        mov     [sect_in_trk],bl        ; store this
+        mov     cl,9
+        shl     bx,cl                   ; bytes in track
+        mov     [bytes_in_trk],bx       ; store this
+        pop     cx
+        pop     bx
+        clc
+        ret                             ;return with no error
+;
+bad_parmx:
+        stc
+        ret
+;
+check_parameters        endp
+;
+process_regions proc    near
+;
+;       inputs: bx - start sector
+;               al - number of sectors
+;               cx - start track
+;
+;       outputs: none
+;
+;       action: initialise regions struct
+;
+        mov     byte ptr [REGION.FLAG],0 ; clear regions flag
+        cmp     bx,1            ; if start sector is one
+        je      pr$2            ; might as well start with region2
+;
+;       process region1
+;
+        or      [REGION.FLAG],REG1_P    ; mark region1 present
+        mov     ah,[sect_in_trk]        ; get sectors in track
+        sub     ah,bl           ; remaining number of sectors in track
+        inc     ah              ; adjust 0 based numb to one based numb
+        cmp     ah,al
+        jbe     pr$1            ; if below or equal ah has number of sectors
+                                ; in region1
+        mov     ah,al           ; else all the sectors are in region1
+pr$1:   sub     al,ah           ; adjust number of sectors
+        mov     [REGION.REG1.START_H],dh
+        mov     [REGION.REG1.START_T],cx
+        mov     [REGION.REG1.START_S],bx
+        push    cx              ; save these registers
+        push    ax              ;
+        mov     al,ah           ;
+        xor     ah,ah           ; ax has number of sectors now
+        mov     cl,8            ;
+        shl     ax,cl           ; multiply by 256 to get number of words
+        mov     [REGION.REG1.COUNT],ax  ; store this count
+        pop     ax              ;
+        pop     cx
+        inc     dh
+        call    adj_hd_trk
+;
+;       process region2
+;
+pr$2:   or      al,al           ; are we done
+        je      pr$end          ;
+        xor     ah,ah           ; ax has number of sectors
+        div     [sect_in_trk]   ; find number of tracks
+        or      al,al           ; al will have number of full tracks
+                                ; ah will have number of sectors left
+        je      pr$3            ; if no full tracks no region2
+;
+        or      [REGION.FLAG],REG2_P    ; mark region2 present
+        mov     [REGION.REG2.START_H],dh
+        mov     [REGION.REG2.START_T],cx; store start track
+        mov     [REGION.REG2.TRACKS],al ; and number of tracks
+        add     dh,al           ; adjust track number
+        call    adj_hd_trk
+;
+;       process region3
+;
+pr$3:   or      ah,ah           ; are we done (no sectors left)
+        je      pr$end          ; if yes go to fin
+        or      [REGION.FLAG],REG3_P    ; else mark region3 present
+        mov     [REGION.REG3.START_H],dh
+        mov     [REGION.REG3.START_T],cx        ;store track number
+        mov     cl,8
+        mov     al,ah
+        xor     ah,ah           ; convert number of sectors into number of
+        shl     ax,cl           ; words
+        mov     [REGION.REG3.COUNT],ax  ; store this
+pr$end:
+;
+        ret
+;
+process_regions endp
+;
+;       Support Routines:
+;
+;
+track_in_cache  proc    near
+;
+;       input:  dl = drive number with bit 8 set off
+;               cx = cylinder number
+;
+        mov     di,-1           ; di will return lru item nearest to matching
+                                ; element, -1 if none
+        mov     si,[cache_head] ; start with mru cache entry
+        inc     si              ; to counter next instruction
+nexte:
+        dec     si              ; to counter last instruction in the loop
+        test    [si.track_flags],track_locked ; is the track locked?
+        jnz     no_set          ;
+        mov     di,si           ; if not locked update di to this element
+no_set:
+        test    [si.track_flags],track_free ; is element free
+        jnz     skipe           ; if free we need not check this one
+        cmp     dx,word ptr [si.track_drive]    ; if not free check drive+head
+        jnz     skipe           ;
+        cmp     cx,[si.track_cyln]              ; and cylinder number
+        jz      tic$1           ; if found exit routine
+skipe:
+        mov     si,[si.fwd_lru_lnk]     ; else go to check next cache element
+        inc     si              ; if last element was end then si = -1
+        jnz     nexte           ; and incrementing it will set zero flag
+        stc
+        ret
+tic$1:  clc
+        ret
+;
+track_in_cache  endp
+;
+get_cache       proc    near
+;
+;       inputs: none
+;       outputs: si = lru cache element not locked
+;                   = -1 if all elems locked
+;
+        mov     si,[cache_tail] ;start with lru element
+        inc     si              ;to counter next instruction
+gc$1:
+        dec     si              ; to counter last instruction in loop
+        test    [si.track_flags],track_locked ; is the element locked
+        jz      gc$2            ; if not locked this is the lucky(?) guy
+;
+        mov     si,[si.back_lru_lnk]    ; else go back in chain to check the
+                                        ; next recently used cache element
+        inc     si              ; as before -1 is the end of chain
+        jnz     gc$1            ; incrementing it will set zero flag
+;
+        dec     si              ; no element found, si = -1
+;
+gc$2:   ret
+;
+get_cache       endp
+;
+adj_hd_trk  proc    near
+;
+;       inputs: ch,cl track number
+;               dh changed head number to be checked and adjusted
+;
+;       outputs: cx and dh updated
+;
+        pushf
+aht$1:  cmp     dh,[max_hd]         ;is the head number > heads on drive
+        jbe     aht$2
+        sub     dh,[max_hd]         ;if so decrease head number by number of
+                                    ;heads on drive
+        dec     dh                  ;by one more
+        add     ch,1                ;and step to next track
+        jnc     aht$1
+        add     cl,40h
+        jmp     aht$1
+aht$2:  popf
+        ret
+;
+adj_hd_trk      endp
+
+CACHE_HIT PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+CACHE_HIT ENDP
+
+
+;**     INVALIDATE_CACHE -- Discard all cache info
+;
+; ENTRY
+;       Cache is flushed (If it is not, all dirty info will simply be chucked)
+; EXIT
+;       All elements of cache are marked free
+; USES
+;       BX,FLAGS
+;
+INVALIDATE_CACHE PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     BX,[CACHE_HEAD]
+        INC     BX              ; Counter next instruction
+NEXTC:
+        DEC     BX
+        MOV     [BX.TRACK_FLAGS],TRACK_FREE
+        MOV     BX,[BX.FWD_LRU_LNK]
+        INC     BX
+        JNZ     NEXTC
+    ;
+    ; Track buffer invalid too
+    ;
+        MOV     [TRACK_BUFFER_CYLN],-1
+        MOV     [TRACK_BUFFER_HDDR],-1
+        MOV     [DIRTY_CACHE],0
+        ret
+
+INVALIDATE_CACHE ENDP
+
+;**     CACHE_IS_MRU -- Put cache element in LRU chain at MRU position
+;
+; ENTRY
+;       SI points cache element to place at MRU position
+; EXIT
+;       SI is at MRU position (head)
+; USES
+;       DI,FLAGS
+;
+CACHE_IS_MRU PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        push    di
+        CMP     SI,[CACHE_HEAD]
+        JZ      RET444
+        CALL    UNLINK_CACHE
+        MOV     DI,SI
+        XCHG    DI,[CACHE_HEAD]
+        MOV     [DI.BACK_LRU_LNK],SI
+        MOV     [SI.FWD_LRU_LNK],DI
+        MOV     [SI.BACK_LRU_LNK],-1
+RET444: pop di
+        RET
+
+CACHE_IS_MRU ENDP
+
+;**     CACHE_IS_LRU -- Put cache element in LRU chain at LRU position
+;
+; ENTRY
+;       SI points to cache element to place at LRU position
+; EXIT
+;       SI is at LRU position (tail)
+; USES
+;       DI,FLAGS
+;
+CACHE_IS_LRU PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        push    di
+        CMP     SI,[CACHE_TAIL]
+        JZ      RET555
+        CALL    UNLINK_CACHE
+        MOV     DI,SI
+        XCHG    DI,[CACHE_TAIL]
+        MOV     [DI.FWD_LRU_LNK],SI
+        MOV     [SI.BACK_LRU_LNK],DI
+        MOV     [SI.FWD_LRU_LNK],-1
+RET555: pop     di
+        RET
+
+CACHE_IS_LRU ENDP
+
+;**     UNLINK_CACHE -- Unlink cache element from LRU chain
+;
+; ENTRY
+;       SI points to element to unlink
+; EXIT
+;       SI is unlinked
+; USES
+;       DI,FLAGS
+;
+UNLINK_CACHE PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        PUSH    BX
+        MOV     DI,[SI.BACK_LRU_LNK]    ; Get prev guy
+        INC     DI                      ; Guy First?
+        JZ      NEW_HEAD                ; Yes
+        DEC     DI
+        MOV     BX,[SI.FWD_LRU_LNK]     ; Get next guy
+        MOV     [DI.FWD_LRU_LNK],BX     ; Prev fwd is my fwd
+        INC     BX                      ; Is that guy last?
+        JZ      NEW_TAIL                ; Yes
+        DEC     BX
+        MOV     [BX.BACK_LRU_LNK],DI    ; Next back is my back
+NULL_CACHE:
+        POP     BX
+        RET
+
+NEW_HEAD:
+        MOV     DI,[SI.FWD_LRU_LNK]     ; Is head also tail?
+        INC     DI
+        JZ      NULL_CACHE              ; Yes
+        DEC     DI
+        MOV     [CACHE_HEAD],DI         ; New head
+        MOV     [DI.BACK_LRU_LNK],-1    ; New head has no back link
+        POP     BX
+        RET
+
+NEW_TAIL:
+        MOV     [CACHE_TAIL],DI         ; New tail
+        POP     BX
+        RET
+UNLINK_CACHE ENDP
+
+RETRY_CNT       DB      ?
+
+;**     WRITE_FROM_CACHE -- Write out cache element to disk
+;
+; ENTRY
+;       SI -> cache element to write
+; EXIT
+;       Carry Clear
+;               Written OK
+;               Track buffer is set to this track
+;       Carry Set
+;               Error, AL is error code
+;               Track buffer is set to empty
+; USES
+;       AX,BX,CX,DX,ES,DI,FLAGS
+;
+WRITE_FROM_CACHE PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+    ;
+    ; First transfer track down to track buffer because we can't write
+    ;   direct to extended or expanded mem with INT 13
+    ;
+        PUSH    CS
+        POP     ES
+        MOV     DI,[TRACK_BUFFER_PTR]   ; ES:DI is transfer addr for BLKMOV
+        MOV     BX,WORD PTR [SI.TRACK_DRIVE]
+        XOR     BH,BH
+        MOV     AL,[BX.SECTRKARRAY]
+        XOR     AH,AH
+        PUSH    AX
+        MOV     CL,8
+        SHL     AX,CL                   ; AX is words in track
+        MOV     CX,AX
+        XOR     BH,BH                   ; Read
+        MOV     AX,WORD PTR [SI.BASE_OFFSET]
+        MOV     DX,WORD PTR [SI.BASE_OFFSET.2]  ; DX:AX is address in mem
+        PUSH    DS
+        PUSH    SI
+        PUSH    BP
+        CALL    BLKMOV                  ; Track buffer contents to track buffer
+        POP     BP
+        POP     SI
+        POP     DS
+        JC      ERR_FLP
+        POP     AX                      ; AL is sec/trk
+    ;
+    ; Now write it out to drive from the track buffer
+    ;
+        MOV     CX,[SI.TRACK_CYLN]
+        MOV     DX,WORD PTR [SI.TRACK_DRIVE]
+        MOV     [TRACK_BUFFER_CYLN],CX  ; Set track buffer currency
+        MOV     [TRACK_BUFFER_HDDR],DX
+        OR      CL,1
+        OR      DL,80H
+        MOV     AH,3
+        PUSH    CS
+        POP     ES
+        MOV     BX,[TRACK_BUFFER_PTR]
+        PUSH    AX
+        MOV     [RETRY_CNT],5
+RETRY_WRITE:
+        PUSHF
+        CALL    [OLD_13]                ; Write it out
+        JC      ERR_RETRY
+NO_ERR1:
+        POP     AX
+ERR_FL:
+        ret
+
+ERR_RETRY:
+        CMP     AH,11H                  ; The error that is not an error?
+        JZ      NO_ERR1                 ; Yes, cmp cleared carry
+        PUSH    AX                      ; Save error in AH
+        MOV     AH,0                    ; Reset
+        INT     13H
+        POP     AX                      ; Get error back
+        DEC     [RETRY_CNT]
+        JZ      SET_ERR                 ; Return error
+        POP     AX                      ; Recover correct AX for INT 13
+        PUSH    AX
+        JMP     RETRY_WRITE
+
+SET_ERR:
+        MOV     AL,AH                   ; INT 13 error to AL
+ERR_FLP:
+        ADD     SP,2
+        STC
+        MOV     [TRACK_BUFFER_CYLN],-1  ; Zap the track buffer
+        MOV     [TRACK_BUFFER_HDDR],-1
+        JMP     ERR_FL
+
+WRITE_FROM_CACHE ENDP
+
+;**     FLUSH_CACHE -- Flush specific cache element if it's dirty
+;
+; ENTRY
+;       SI points to element to flush
+; EXIT
+;   Carry Clear
+;       SI is flushed if it was dirty
+;       SI.TRACK_FLAGS dirty bit clear
+;       Track buffer set to this track
+;   Carry Set
+;       SI could not be flushed
+;       SI.TRACK_FLAGS = free
+;       AL is error code
+;       Track buffer set to empty
+; USES
+;       AX,BX,CX,DX,ES,DI,FLAGS
+;
+FLUSH_CACHE PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        TEST    [SI.TRACK_FLAGS],TRACK_FREE     ; Clears carry
+        JNZ     IGNORE_TRK
+        TEST    [SI.TRACK_FLAGS],TRACK_DIRTY    ; Clears carry
+        JZ      IGNORE_TRK
+        CALL    WRITE_FROM_CACHE
+        DEC     [DIRTY_CACHE]                   ; Doesn't effect carry
+        JC      FLUSH_ERRX
+        AND     [SI.TRACK_FLAGS],NOT TRACK_DIRTY ; Clears carry
+IGNORE_TRK:
+        ret
+
+FLUSH_ERRX:
+        MOV     [SI.TRACK_FLAGS],TRACK_FREE     ; Track gone, unlocked
+        RET
+
+FLUSH_CACHE ENDP
+
+;**     FLUSH_WHOLE_CACHE_SAV -- Flush all dirty cache elements saving regs
+;
+; ENTRY
+;       None
+; EXIT
+;       Cache flushed
+; USES
+;       FLAGS
+;
+FLUSH_WHOLE_CACHE_SAV PROC NEAR
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+    ; Simulate PUSHA
+        PUSH    AX
+        PUSH    CX
+        PUSH    DX
+        PUSH    BX
+        PUSH    BX              ; dummy for push sp
+        PUSH    BP
+        PUSH    SI
+        PUSH    DI
+    ;
+        PUSH    DS
+        PUSH    ES
+        PUSH    CS
+        POP     DS
+ASSUME  DS:INT13CODE
+        CALL    FLUSH_WHOLE_CACHE
+        POP     ES
+        POP     DS
+    ; Simulate POPA
+        POP     DI
+        POP     SI
+        POP     BP
+        POP     BX              ; Dummy for pop sp
+        POP     BX
+        POP     DX
+        POP     CX
+        POP     AX
+    ;
+        ret
+FLUSH_WHOLE_CACHE_SAV ENDP
+
+;**     FLUSH_WHOLE_CACHE -- Flush all dirty cache elements
+;
+; ENTRY
+;       None
+; EXIT
+;       Cache flushed
+; USES
+;       AX,BX,CX,DX,ES,SI,DI,FLAGS
+;
+FLUSH_WHOLE_CACHE PROC NEAR
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     SI,[CACHE_HEAD]
+        INC     SI              ; Counter next instruction
+FLSH_LP:
+        DEC     SI
+        CALL    FLUSH_CACHE
+        MOV     SI,[SI.FWD_LRU_LNK]
+        INC     SI
+        JNZ     FLSH_LP
+FLUSH_DONE:
+        MOV     [DIRTY_CACHE],0 ; No dirty guys in cache
+        ret
+
+FLUSH_WHOLE_CACHE ENDP
+
+BREAK   <Drive code for /E driver>
+
+;
+; The following label defines the start of the I/O code which is driver type
+; specific.
+;
+; THE TYPE 2 driver must REPLACE this code with code appropriate
+;       to the driver type.
+;
+                EVEN            ; Force start of drive code to word boundary
+
+DRIVE_CODE      LABEL   WORD
+
+EXTMEM_LOW      EQU     0000H   ; 24 bit addr of start of extended memory
+EXTMEM_HIGH     EQU     0010H
+
+;**     BASE_ADDR data element
+;
+; The next value defines the 24 bit address of the start of the memory for
+;  the cache. It is equal to the EMM_BASE value in the
+;  EMM_REC structure for the cache.
+;
+;  NOTE THAT IT IS INITIALIZED TO THE START OF EXTENDED MEMORY. This is
+;  because BLKMOV is used to read the EMM_CTRL sector during initialization
+;  of a TYPE 1 driver.
+;
+; NOTE: This data element is shared by TYPE 1, 2 drivers, but
+;       its meaning and correct initial value are driver type specific.
+;
+
+;; NOTE: The value at BASE_ADDR is patched during initialization when
+;;       loading a RAMDrive into upper extended memory on a PLUS
+;;
+BASE_ADDR       LABEL   DWORD   ; 24 bit address of start of this RAMDRV
+                DW      EXTMEM_LOW
+                DW      EXTMEM_HIGH
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;**     BLKMOV - Perform transfer for TYPE 1 driver
+;
+;       This routine is the transfer routine for moving bytes
+;       to and from the AT extended memory in real mode using
+;       the LOADALL instruction. The LOADALL instruction is used
+;       to set up a segment descriptor which has a 24 bit address.
+;       During the time the LOADALL 24 bit segment descriptor is
+;       in effect we must have interrupts disabled. If a real mode
+;       8086 interrupt handler was given control it might perform
+;       a segment register operation which would destroy the special
+;       segment descriptor set up by LOADALL. This is prevented by
+;       doing a CLI during the "LOADALL time".
+;
+;       WARNING NUMBER ONE:
+;           THIS CODE WILL NOT WORK ON ANY 80286 MACHINE WHERE THE NMI
+;           INTERRUPT IS ANYTHING BUT A FATAL, SYSTEM HALTING ERROR.
+;
+;       Since it is bad to leave interrupts disabled for a long
+;       time, the I/O is performed 256 words at a time enabling
+;       interrupts between each 256 word piece. This keeps the time
+;       interrupts are disabled down to a reasonable figure in the 100mSec
+;       range.
+;
+;       To use the LOADALL instruction 102 bytes at location 80:0 must
+;       be used. INT13 copies the contents of 80:0 into its own buffer,
+;       copies in the LOADALL info, performs the LOADALL, and then copies
+;       back the previous contents of 80:0. These operations are all
+;       performed during the time interrupts are disabled for each 256 word
+;       block. This must be done with interrupts disabled because this area
+;       on DOS 2.X and 3.X contains variable BIOS data.
+;
+;       In order to gain full 24 bit addressing it is also required
+;       that address line 20 be enabled. This effects 8086 compatibility
+;       on 80286 systems. This code leaves address line 20 enabled
+;       for the ENTIRE duration of the I/O because it is too time
+;       expensive to disable/enable it for each 256 word block.
+;
+;       WARNING NUMBER TWO:
+;           IF A MULTITASKING PRE-EMPTIVE SYSTEM SCHEDULES AND RUNS
+;           AN APPLICATION WHICH RELIES ON THE 1 MEG ADDRESS WRAP
+;           PROPERTY OF THE 8086 AND 8088 DURING THE TIME INT13
+;           IS IN THE MIDDLE OF DOING AN I/O WITH ADDRESS LINE 20 ENABLED,
+;           THE APPLICATION WILL NOT RUN PROPERLY AND MAY DESTRUCT THE
+;           INT13 MEMORY.
+;
+;       METHOD:
+;           Perform various LOADALL setup operations
+;           Enable address line 20
+;           While there is I/O to perform
+;               Do "per 256 word block" LOADALL setup operations
+;               Set up copy of 80:0 to INT13 buffer
+;               CLI
+;               copy 80:0 to INT13 buffer
+;               copy LOADALL info to 80:0
+;               LOADALL
+;               do 256 word transfer
+;               copy INT13 80:0 buffer back to 80:0
+;               STI
+;           Disable address line 20
+;
+;       SEE ALSO
+;           INTEL special documentation of LOADALL instruction
+;
+;       ENTRY:
+;           ES:DI is packet transfer address.
+;           CX is number of words to transfer.
+;           DX:AX is 32 bit start byte offset (0 = start of cache)
+;           BH is 1 for WRITE, 0 for READ
+;
+;           BASE_ADDR set to point to start of cache memory
+;               This "input" is not the responsibility of the caller. It
+;               is up to the initialization code to set it up when the
+;               device is installed
+;
+;       EXIT:
+;           Carry Clear
+;                   OK, operation performed successfully
+;           Carry Set
+;                   Error during operation, AL is error number (INT 13 error)
+;
+;       USES:
+;           ALL
+;
+;       This routine is specific to TYPE 1 driver
+;
+;       sunilp - incorporated blkmov_386 (thanks to gregh)
+;                incorporated loadall_286 trick (thanks to scottra)
+;                added new a20 functionality
+;                ideally the code should be all relocatable abd the 386
+;                blkmov should be relocated on the 286 blkmov for the
+;                386 case. Also the A20 routines for the Olivetti or PS/2
+;                should also ideally be relocated on top of the normal A20
+
+BLKMOV:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        test    [sys_flg],M_386
+        je     blkmov_286
+        jmp     blkmov_386
+    ;
+    ; Compute 32 bit address of start of I/O
+    ;
+blkmov_286:
+        ADD     AX,WORD PTR [BASE_ADDR]
+        ADC     DX,WORD PTR [BASE_ADDR + 2]
+    ;
+    ; Dispatch on function
+    ;
+        OR      BH,BH
+        JZ      READ_IT
+    ;
+    ; Write
+    ;
+        MOV     WORD PTR [ESDES.SEG_BASE],AX
+        MOV     BYTE PTR [ESDES.SEG_BASE + 2],DL
+;        MOV     [LSI],DI
+        mov     [lbx],di        ;sp
+        MOV     [LDI],0
+        MOV     SI,OFFSET DSDES
+        JMP     SHORT SET_TRANS
+
+READ_IT:
+        MOV     WORD PTR [DSDES.SEG_BASE],AX
+        MOV     BYTE PTR [DSDES.SEG_BASE + 2],DL
+        MOV     [LDI],DI
+;        MOV     [LSI],0           ;sp
+        mov     [lbx],0
+        MOV     SI,OFFSET ESDES
+SET_TRANS:
+        MOV     AX,ES
+        CALL    SEG_SET                 ; Set ES or DS segreg
+    ;
+    ; Set stack descriptor
+    ;
+        MOV     AX,SS
+        MOV     [LSSS],AX
+        MOV     SI,OFFSET SSDES
+        CALL    SEG_SET
+        MOV     [LSP],SP
+;        SUB     [LSP],2                 ; CX is on stack at LOADALL
+;
+;       the loadall kludge
+;
+        mov     ax,cs                   ;sp
+        inc     ax                      ;sp
+        mov     [lcss],ax               ;sp
+        mov     si,offset CSDES         ;sp
+        mov     ax,cs                   ;sp
+        call    seg_set                 ;sp
+    ;
+    ; Set Other LOADALL stuff
+    ;
+        SMSW    [LDSW]
+        SIDT    FWORD PTR [IDTDES]
+        SGDT    FWORD PTR [GDTDES]
+    ;
+    ; NOW The damn SXXX instructions store the desriptors in a
+    ;     different order than LOADALL wants
+    ;
+        MOV     SI,OFFSET IDTDES
+        CALL    FIX_DESCRIPTOR
+        MOV     SI,OFFSET GDTDES
+        CALL    FIX_DESCRIPTOR
+    ;
+    ; Enable address line 20
+    ;
+
+;;
+;; Enable address line 20 on the PC AT or activate A20-A23 on the 6300 PLUS.
+;; The former can be done by placing 0dfh in AH and activating the keyboard
+;; processor.  On the PLUS, 90h goes in AL and the port at 03f20h is written.
+;; So the combined value of 0df90h can be used for both machines with
+;; appropriate coding of the called routine A20.
+;;
+
+;;      MOV     AH,0DFH
+        mov     ax,cs:[A20On]           ;; set up for PLUS or AT
+        CALL    A20
+        Jc      NR_ERR
+;        JMP     SHORT IO_START         ;sp
+        jmp     short move_main_loop    ;sp
+
+NR_ERR:
+        MOV     AL,0AAH                 ; Drive not ready error
+        STC
+        RET
+
+;IOLOOP:                                ;sp
+;        PUSH    CX                     ;sp
+
+move_main_loop:                         ;sp
+assume ds:nothing                       ;sp
+        jcxz    io_done                 ;sp
+        mov     cs:[ldx],cx                ;sp
+        MOV     AX,80H
+        MOV     DS,AX
+        PUSH    CS
+        POP     ES
+        XOR     SI,SI
+        MOV     DI,OFFSET cs:[SWAP_80]
+        MOV     CX,102/2
+        mov     cs:[ssSave],ss
+        CLD
+        CLI                             ; Un interruptable
+        REP     MOVSW                   ; Save contents of 80:0
+        PUSH    DS
+        PUSH    ES
+        POP     DS
+        POP     ES
+        XOR     DI,DI
+        MOV     SI,OFFSET cs:LOADALL_TBL
+        MOV     CX,102/2
+        REP     MOVSW                   ; Transfer in LOADALL info
+         DW      050FH                   ; LOADALL INSTRUCTION
+AFTER_LOADALL:
+; set up stack for moving 80:0 information back again
+;
+        xor     bp,bp
+        mov     ss,ax
+        mov     si,offset cs:[swap_80]
+        mov     cx,102/2
+move_loop:
+        lods    word ptr cs:[si]
+        mov     ss:[bp],ax
+        inc     bp
+        inc     bp
+        loop    move_loop
+        mov     ss,cs:[ssSave]
+        mov     cx,dx
+        mov     si,bx
+;critical code
+        sti
+        rep     movsw
+        cli                 ; bugfix sunilp
+        mov     ax,cs
+        dec     ax
+        push    ax
+        mov     ax,offset    io_done
+        push    ax
+        db      0cbh
+;
+        db      16 dup (0fah) ; bugfix sunilp
+        mov     ax,cs
+        dec     ax
+        push    ax
+        mov     ax,offset    resume_int
+        push    ax
+        db      0cbh
+;
+resume_int:
+        mov     cs:[ldi],di
+        mov     cs:[lbx],si
+        jmp     move_main_loop
+
+;        REP     MOVSW                   ; Move data
+;IO_START:
+;        JCXZ    IODN
+;        MOV     WORD PTR [LCX],256      ; ASSUME full block
+;        SUB     CX,256
+;        JNC     IOLOOP                  ; OK
+;        ADD     [LCX],CX                ; OOPs, partial block
+;        XOR     CX,CX                   ; This is the last block
+;        JMP     IOLOOP
+
+;IODN:
+io_done:
+        sti                             ; bugfix sunilp
+        MOV     CX,800H                 ; Retry this many times
+OFFLP:
+
+;;
+;; Reset of line A20 on the PC AT requires writing 0ddh to the keyboard
+;; processor.  On the PLUS, the appropriate value is 00.
+;;
+
+;;      MOV     AH,0DDH
+        mov     ax,cs:[A20Off]  ;; setup for PLUS or AT. ah for IBM, al for PLUS
+        CALL    A20             ; Disable address line 20
+        jnc     dis_done
+        LOOP    OFFLP
+dis_done:
+        CLC
+        RET
+
+;**     A20 - ENABLE/DISABLE ADDRESS LINE 20 ON IBM PC-AT
+;
+;       This routine enables/disables address line 20 by twiddling bits
+;       in one of the keyboard controller registers.
+;
+;       SEE ALSO
+;           IBM Technical Reference Personal Computer AT Manual #1502243
+;               Page 5-155
+;
+;       ENTRY
+;           AH = 0DDH to disable A20
+;           AH = 0DFH to enable A20
+;       EXIT
+;           CY Failed
+;           NC Succeeded
+;       USES
+;           AL, FLAGS
+;
+; WARNING If this routine is called in a CLI state this routine has
+;       the side effect of enabling interrupts.
+;
+;       This routine is specific to TYPE 1 driver
+;
+
+A20:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+;; CS override needed on S5_FLAG to avoid phase errors on
+;; forward declaration of this variable.
+        cmp     cs:[S5_FLAG],S_OLIVETTI ;; test for 6300 PLUS
+        jne     test_vec                ;; yes, do this code
+        jmp     a20s5
+test_vec:
+        cmp     cs:[S5_FLAG],S_VECTRA
+        jne     test_ps2
+        jmp     VecA20
+test_ps2:
+        test    cs:[sys_flg],M_PS2      ; is it a ps2 machine
+        jne     a20ps2                   ; if yes it has separate a20 routine
+old_a20:
+        CLI
+        call    check_a20               ; check to see if it can be enb /disb
+        jc      a20suc                 ; no it may not be toggled
+        CALL    E_8042
+        JNZ     a20err
+        MOV     AL,0D1H
+        OUT     64H,AL
+        CALL    E_8042
+        JNZ     a20err
+        MOV     AL,AH
+        OUT     60H,AL
+        CALL    E_8042
+        JNZ     a20err
+    ;
+    ;   We must wait for the a20 line to settle down, which (on an AT)
+    ;    may not happen until up to 20 usec after the 8042 has accepted
+    ;    the command.  We make use of the fact that the 8042 will not
+    ;    accept another command until it is finished with the last one.
+    ;    The 0FFh command does a NULL 'Pulse Output Port'.  Total execution
+    ;    time is on the order of 30 usec, easily satisfying the IBM 8042
+    ;    settling requirement.  (Thanks, CW!)
+    ;
+        mov     al,0FFh                 ;* Pulse Output Port (pulse no lines)
+        out     64H,al                  ;* send cmd to 8042
+        CALL    E_8042                  ;* wait for 8042 to accept cmd
+        jnz     A20Err
+
+A20Suc: sti
+        clc
+        RET
+A20Err: sti
+        stc
+        ret
+;
+; Helper routine for A20. It waits for the keyboard controller to be "ready".
+;
+E_8042:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    CX
+        XOR     CX,CX
+E_LOOP:
+        IN      AL,64H
+        AND     AL,2
+        LOOPNZ  E_LOOP
+        POP     CX
+        RET
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;       A20 status checking. If request is to enable a20 we must check to
+;       see if it is already enabled. If so we just set the sys_flg to
+;       indicate this. On disabling the routine checks to see if disabling
+;       is allowed
+;
+check_a20:
+assume ds:nothing,es:nothing,ss:nothing
+        cmp     ah,0ddh     ; is it a disable operation
+        jne     check_a20_enable
+;
+;   check if a20 disabling allowed
+;
+        test    cs:[sys_flg],a20_st
+        jne     no_toggle
+toggle: clc
+        ret
+;
+;   a20 enabling, check if allowed
+;
+check_a20_enable:
+        and     cs:[sys_flg], not A20_ST
+        push    cx
+        push    ds
+        push    si
+        push    es
+        push    di
+        lds     si,cs:low_mem
+        les     di,cs:high_mem
+        mov     cx,3
+        cld
+repe    cmpsw
+        pop     di
+        pop     es
+        pop     si
+        pop     ds
+        jcxz    not_enabled
+        pop     cx
+        or      cs:[sys_flg],A20_ST
+no_toggle:
+        stc
+        ret
+not_enabled:
+        pop     cx
+        clc
+        ret
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; A20 routine for PS2s. The PS2 A20 hardware has shifted and toggling
+; a bit in the system port is all that is required.
+A20PS2:
+assume  ds:nothing,es:nothing,ss:nothing
+        cli
+;
+;   first separate disable operation from enable operation
+;
+        cmp     ah,0ddh
+        je      disbl_PS2
+;
+;   enabling the a20
+;
+        and     cs:[sys_flg],not A20_ST
+        in      al,PS2_PORTA    ; input a20 status
+        test    al,GATE_A20     ; is the a20 line set
+        je      set_it          ;
+        or      cs:[sys_flg],A20_ST ; indicate that it was already set
+ps2a20suc:
+        clc
+        sti
+        ret
+
+set_it: push    cx
+        xor     cx,cx
+        or      al,GATE_A20
+        out     PS2_PORTA,al    ; set it
+see_agn:
+        in      al,PS2_PORTA    ; read status again
+        test    al,GATE_A20
+        loopz   see_agn
+        pop     cx
+        jz      ps2err
+        clc
+        sti
+        ret
+;
+;       disabling the ps2
+;
+disbl_PS2:
+        test    cs:[sys_flg],A20_ST
+        jne     ps2a20suc
+;
+        push    cx
+        xor     cx,cx
+        in      al,PS2_PORTA
+        and     al,not GATE_A20
+        out     PS2_PORTA,al
+see_agn1:
+        in      al,PS2_PORTA
+        test    al,GATE_A20
+        loopnz  see_agn1
+        pop     cx
+        jnz     ps2err
+        clc
+        sti
+        ret
+;
+ps2err:
+        stc
+        sti
+        ret
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;*     VECA20 - Address enable/disable routine for Vectra family computers
+;;
+;;      This routine does the same function as A20 for Vectra machines.
+;;      Vectra machines require writing single byte as opposed to
+;;      double byte commands to the 8041.  This is due to a bug
+;;      in older versions in the Vectra 8041 controllers.  IBM
+;;      machines must use double byte commands due to lack of
+;;      implementation of single byte commands in some of their machines.
+;;
+;;      Uses    al, flags
+;;      Has same results as A20
+;;
+VecA20:
+        CLI
+        call    check_a20
+        jc      VecA20Suc
+        call    E_8042
+        jnz     VecA20Err
+        mov     al,ah                   ;sigle byte command is code passed
+        out     64H,al
+        call    E_8042
+        jnz     VecA20Err
+;       See A20 for a description of the following code.  It simply makes
+;       sure that the previous command has been completed. We cannot
+;       pulse the command reg since there is a bug in some Vectra 8041s
+;       instead we write the byte again knowing that when this one is
+;       accepted the previous one has been processed.
+        mov     al,ah
+        out     64H,al
+        call    E_8042
+        jnz     VecA20Err
+VecA20Suc:
+        sti
+        clc
+        ret
+VecA20Err:
+        sti
+        stc
+        ret
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;*     A20S5 - Address enable/disable routine for the 6300 PLUS.
+;;
+;;      This routine enables lines A20-A23 on the PLUS by writing
+;;      to port 03f20h.  Bit 7 turns the lines on, and bit 4 sets
+;;      the power-up bit.  To disable the lines, the processor
+;;      must be reset.  This is done by saving the world and 
+;;      jumping to the ROM 80286 reset code.  Since the power-up bit
+;;      is set, the data segment is set to the BiosSeg at 40h
+;;      and a jump is then made to the address at RealLoc1.  
+;;      At RealLoc1, one can find the CS:IP where the code
+;;      is to continue.
+;;       
+;;      Uses ax, flags.
+;;      Returns with zero flag set.
+;;
+A20S5:  test    [reboot_flg],0ffh       ;; sunilp
+        jne     a20s5boot               ;; sunilp
+        cli
+        or      al,al                   ;; if zero, then resetting processor
+        jnz     A20S5Next
+        call    RSet                    ;; must return with entry value of ax
+A20S5Next:
+        push    dx                      ;; set/reset port
+        mov     dx,3f20h
+        out     dx,al
+        pop     dx
+        clc                             ;; sunilp modification cy flag now important
+        STI
+        RET
+
+;;* a20S5BOOT - This code bypasses the processor reset on a reboot
+;;              of the 6300 PLUS.  Otherwise the machine hangs.
+a20s5BOOT:                              ;; use this code before reboot
+        cli
+        jmp short a20s5next
+
+OldStackSeg     dw      0               ;; used during PLUS processor reset
+                                        ;; to save the stack segment
+
+;;* Rset -      Reset the 80286 in order to turn off the address lines
+;;              on the 6300 PLUS.  Only way to do this on the
+;;              current hardware.  The processor itself can be
+;;              reset by reading or writing prot 03f00h
+;;
+;;  Uses flags.
+;;
+RSet:
+        pusha                           ;; save world
+        push    ds                      ;; save segments
+        push    es
+        mov     ax,BiosSeg              ;; point to the bios segment
+        mov     ds,ax                   ;; ds -> 40h
+assume  ds:BiosSeg
+        push    word ptr [RealLoc1]     ;; save what might have been here
+        push    word ptr [RealLoc1+2]
+        mov     word ptr [RealLoc1],cs:[offset ReturnBack] ;; load our return address
+        mov     word ptr [RealLoc1+2],cs
+assume ds:nothing
+        mov     [OldStackSeg],ss        ;; save the stack segment, too
+        mov     dx,03f00h               ;; reset the processor
+        in      ax,dx
+        nop                             
+        nop
+        nop
+        cli
+        hlt                             ;; should never get here
+ReturnBack:
+        mov     ss,[OldStackSeg]        ;; start the recovery
+assume ds:BiosSeg
+        pop     word ptr [RealLoc1+2]
+        pop     word ptr [RealLoc1]
+        pop     es
+        pop     ds
+        popa
+        ret             
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+blkmov_386:         ;_protect:
+assume  ds:int13code,es:nothing,ss:nothing
+;
+; Compute 32 bit address of start of I/O
+;
+        add     ax,word ptr [base_addr]
+        adc     dx,word ptr [base_addr + 2]
+;
+        push    cx
+;
+; Are we in virtual mode
+;
+        smsw    cx
+        test    cx,01B          ; is the pe bit set
+        je      pr_mode_tran
+
+       jmp     int_15_tran
+;
+; Dispatch on function
+;
+pr_mode_tran:
+        or      bh,bh
+        jz      read_it_1
+;
+; Write
+;
+; Update ES descriptor with address of track in cache
+;
+        mov     si,offset es_des
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+; Update DS descriptor with transfer address
+;
+        mov     ax,es
+        mov     cx,16
+        mul     cx
+        mov     si,offset ds_des
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+
+
+; Switch SI and DI for write transfer
+
+        mov     si,di
+        xor     di,di
+
+        jmp     short set_trans_1
+
+read_it_1:
+;
+; Update DS descriptor with address of track in cache
+;
+        mov     si,offset ds_des
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+; Update ES descriptor with transfer address
+;
+        mov     ax,es
+        mov     cx,16
+        mul     cx
+        mov     si,offset es_des
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+; Keep SI and DI the same for read transfer
+;
+        xor     si,si
+
+set_trans_1:
+;
+; Restore Transfer Count
+;
+        pop     cx
+
+;
+        mov     ax,cs:[A20On]
+        call    A20
+        jc      nr_err_1
+;
+;       we shall do the transfer 1024 words at a time
+;
+        db      66h
+        push    ax
+        mov     bx,cx
+assume ds:nothing
+pr_io_agn_1:
+        mov     cx,1024
+        cmp     bx,cx
+        ja      pr_strt_1
+        mov     cx,bx
+pr_strt_1:
+        sub     bx,cx
+        cli             ; Un interruptable
+        cld
+        lgdt    fword ptr emm_gdt
+
+
+;
+; Switch to protected mode
+;
+        db      66h,0Fh, 20h, 0             ;mov     eax,cr0
+        or      ax,1
+        db      66h,0Fh,22h, 0              ;mov     cr0,eax
+;
+; Clear prefetch queue
+;
+        db      0eah            ; far jump
+        dw      offset flush_prefetch
+        dw      cs_des - start_gdt      
+;
+flush_prefetch:
+        assume  cs:nothing
+;
+; Initialize segment registers
+;
+        mov     ax,ds_des - start_gdt
+        mov     ds,ax
+        assume  ds:nothing
+        mov     ax,es_des - start_gdt
+        mov     es,ax
+        assume  es:nothing
+        shr     cx,1                    ; convert word count to dword count
+        db      0f3h,066h,0a5h          ; rep movsd
+;       rep     movsw                   ; Move data
+;
+;
+; Return to Real Mode
+;
+;
+        db      66h,0Fh, 20h, 0             ; mov     eax,cr0
+        and     ax,0FFFEh
+        db      66h,0Fh, 22h, 0             ; mov     cr0,eax
+;
+; Flush Prefetch Queue
+;
+        db      0EAh                    ; Far jump
+        dw      offset flushcs
+cod_seg dw      ?                       ; Fixed up at initialization time
+        assume  cs:Int13Code
+flushcs:
+;
+        sti
+;  see if transfer done else go to do next block
+;
+        or      bx,bx
+        jne     pr_io_agn_1
+;
+        db      66h
+        pop     ax
+        mov     ax,cs
+        mov     es,ax
+        assume  es:nothing
+        mov     ds,ax
+        assume  ds:Int13Code
+
+        mov     cx,800h                 ; Retry this many times
+offlp_1:
+        mov     ax,cs:[A20Off]
+        call    A20                     ; Disable address line 20
+        jnc     offlp1_out
+        loop    offlp_1
+offlp1_out:
+        clc
+        ret
+
+nr_err_1:
+
+        mov     al,0AAh                 ; Drive not ready error
+        stc
+        ret
+;
+int_15_tran:
+assume  ds:int13code,es:nothing,ss:nothing
+        or      bh,bh
+        jz      read_it_2
+;
+; Write
+;
+; Update tgt descriptor with address of track in cache
+;
+        mov     si,offset tgt
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+; Update src descriptor with transfer address
+;
+        mov     ax,es
+        mov     cx,16
+        mul     cx
+        add     ax,di
+        adc     dx,0
+        mov     si,offset src
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+        jmp     short set_trans_2
+
+read_it_2:
+;
+; Update src descriptor with address of track in cache
+;
+        mov     si,offset src
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+; Update tgt descriptor with transfer address
+;
+        mov     ax,es
+        mov     cx,16
+        mul     cx
+        add     ax,di
+        adc     dx,0
+        mov     si,offset tgt
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+;
+set_trans_2:
+;
+; Restore Transfer Count
+;
+        pop     bx
+
+;
+;       we shall do the transfer 1024 words at a time
+;
+pr_io_agn_2:
+        mov     cx,1024
+        cmp     bx,cx
+        ja      pr_strt_2
+        mov     cx,bx
+pr_strt_2:
+        sub     bx,cx
+        push    cs
+        pop     es
+        mov     si,offset int15_gdt
+        mov     ax,emm_blkm shl 8
+        int     emm_int
+        jc      nr_err_1
+;
+;
+;  see if transfer done else fo to do next block
+;
+        or      bx,bx
+        je      io_exit
+;
+        add     [src.bas_0_15],2048
+        adc     [src.bas_16_23],0
+        adc     [src.bas_24_31],0
+;
+        add     [tgt.bas_0_15],2048
+        adc     [tgt.bas_16_23],0
+        adc     [tgt.bas_24_31],0
+;
+        jmp     pr_io_agn_2
+io_exit:
+        clc
+        ret
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;**     SEG_SET - Set up a LOADALL segment descriptor as in REAL mode
+;
+;       This routine sets the BASE value in the segment descriptor
+;       pointed to by DS:SI with the segment value in AX as the 80286
+;       does in REAL mode. This routine is used to set a descriptor
+;       which DOES NOT have an extended 24 bit address.
+;
+;       SEE ALSO
+;           INTEL special documentation of LOADALL instruction
+;
+;       ENTRY:
+;             DS:SI -> Seg register descriptor
+;             AX is seg register value
+;       EXIT:
+;             NONE
+;       USES:
+;             AX
+;
+;       This routine is specific to TYPE 1 driver
+;
+
+SEG_SET:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    DX
+        PUSH    CX
+        MOV     CX,16
+        MUL     CX      ; Believe or not, this is faster than a 32 bit SHIFT
+        MOV     WORD PTR [SI.SEG_BASE],AX
+        MOV     BYTE PTR [SI.SEG_BASE + 2],DL
+        POP     CX
+        POP     DX
+        RET
+
+;**     FIX_DESCRIPTOR - Shuffle GTD IDT descriptors
+;
+;       The segment descriptors for the IDT and GDT are stored
+;       by the SIDT instruction in a slightly different format
+;       than the LOADALL instruction wants them. This routine
+;       performs the transformation by PUSHing the contents
+;       of the descriptor, and then POPing them in a different
+;       order.
+;
+;       SEE ALSO
+;           INTEL special documentation of LOADALL instruction
+;           INTEL 80286 processor handbook description of SIDT instruction
+;
+;       ENTRY:
+;           DS:SI points to IDT or GDT descriptor in SIDT form
+;       EXIT:
+;           DS:SI points to IDT or GDT descriptor in LOADALL form
+;       USES:
+;           6 words of stack
+;
+;       NOTE: The transformation is reversable, so this routine
+;               will also work to transform a descriptor in LOADALL
+;               format to one in SIDT format.
+;
+;       Specific to TYPE 1 driver
+;
+
+FIX_DESCRIPTOR:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    WORD PTR [SI + 4]
+        PUSH    WORD PTR [SI + 2]
+        PUSH    WORD PTR [SI]
+        POP     WORD PTR [SI + 4]
+        POP     WORD PTR [SI]
+        POP     WORD PTR [SI + 2]
+        RET
+
+;**     DATA SPECIFIC TO THE LOADALL INSTRUCTION USAGE
+;
+;       SWAP_80 and LOADALL_TBL are data elements specific to the use
+;       of the LOADALL instruction by TYPE 1 drivers.
+;
+
+;
+; Swap buffer for contents of 80:0
+;
+        EVEN            ; Force word alignment of SWAP_80 and LOADALL_TBL
+
+SWAP_80 DB      102 DUP(?)
+ssSave  dw      ?
+
+;
+; LOADALL data buffer placed at 80:0
+;
+LOADALL_TBL     LABEL   BYTE
+        DB      6 DUP(0)
+LDSW    DW      ?
+        DB      14 DUP (0)
+TR      DW      0
+FLAGS   DW      0               ; High 4 bits 0, Int off, Direction clear
+                                ;   Trace clear. Rest don't care.
+LIP     DW      OFFSET AFTER_LOADALL
+LDT     DW      0
+LDSS    DW      8000h
+LSSS    DW      ?
+LCSS    DW      ?
+LESS    DW      ?
+LDI     DW      ?
+LSI     DW      ?
+LBP     DW      ?
+LSP     DW      ?
+LBX     DW      ?
+LDX     DW      ?
+LCX     DW      ?
+LAX     DW      80H
+ESDES   SEGREG_DESCRIPTOR <>
+CSDES   SEGREG_DESCRIPTOR <>
+SSDES   SEGREG_DESCRIPTOR <>
+DSDES   SEGREG_DESCRIPTOR <>
+GDTDES  DTR_DESCRIPTOR <>
+LDTDES  DTR_DESCRIPTOR <0D000H,0,0FFH,0088H>
+IDTDES  DTR_DESCRIPTOR <>
+TSSDES  DTR_DESCRIPTOR <0C000H,0,0FFH,0800H>
+
+;**     TRUE LOCATION OF ABOVE_PID
+;
+;       Define the TRUE (runtime TYPE 2 driver) location of ABOVE_PID.
+;       This is the only piece of TYPE 2 specific data that we need
+;       in the resident image. We must define it HERE rather than down
+;       at ABOVE_BLKMOV so that we have its TRUE location after the
+;       TYPE 2 code is swapped in at initialization. If we defined
+;       it down at ABOVE_BLKMOV any instruction like:
+;
+;               MOV     DX,[ABOVE_PID]
+;
+;       Would have to be "fixed up" when we moved the ABOVE_BLKMOV
+;       code into its final location.
+;
+
+ABOVE_PID       EQU     WORD PTR $ - 2          ; TRUE location of ABOVE_PID
+
+;
+; The following label defines the end of the region where BLKMOV code
+;   may be swapped in. BLKMOV code to be swapped in MUST fit
+;   between DRIVE_CODE and DRIVE_END
+;
+DRIVE_END       LABEL   WORD
+
+
+BREAK   <INT 19/9 Handlers>
+
+;
+; As discussed above in the documentation of the EMM_CTRL sector it
+; is necessary to hear about system re-boots so that the EMM_ISDRIVER
+; bits in the EMM_REC structure can be manipulated correctly.
+;
+; On the IBM PC family of machines there are two events which cause a
+; "soft" system re-boot which we might expect the EMM_CTRL sector to
+; survive through. One is software INT 19H, the other is the Ctrl-Alt-Del
+; character sequence which can be detected by "listening" on INT 9 for
+; it. The code below consists of a handler for INT 19H, a handler
+; for INT 9, and a drive TYPE dependant piece of code.
+;
+; The drive TYPE dependant piece of code works as follows:
+;
+;       TYPE 1 uses EMM_CTRL sector so it turnd off the
+;               EMM_ISDRIVER bit in the record indicated by MY_EMM_REC.
+;               EACH TYPE 1 driver in the system includes the INT 19/9
+;               code.
+;
+;       TYPE 2 DOES NOT use the EMM_CTRL sector but it still has
+;               a handler. What this handler does is issue an
+;               ABOVE_DEALLOC call to deallocate the Above Board
+;               memory allocated to INT13. In current versions
+;               of the EMM device driver this step is unnecessary
+;               as the EMM device driver is thrown away together
+;               with all of the allocation information when the system
+;               is re-booted. We do it anyway because some future version
+;               of the EMM device driver may be smarter and retain
+;               allocation information through a warm-boot. Currently,
+;               doing this doesn't hurt anything. Since this code cannot
+;               do a global ABOVE_DEALLOC for all TYPE 2 drivers in the
+;               system, it does an ABOVE_DEALLOC only for its memory
+;               and EACH TYPE 2 driver in the system includes the INT 19/9
+;               code.
+;
+
+;
+; Storage locations for the "next" INT 19 and INT 9 vectors, the ones
+;  that were in the interrupt table when the device driver was loaded.
+;  They are initialized to -1 to indicate they contain no useful information.
+;
+OLD_19  LABEL   DWORD
+        DW      -1
+        DW      -1
+
+OLD_9   LABEL   DWORD
+        DW      -1
+        DW      -1
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; modification to meet new memory allocation standard
+OLD_15  LABEL   DWORD
+        DW      -1
+        DW      -1
+int15_size  dw  0
+;
+;
+INT_15:
+ASSUME DS:NOTHING,SS:NOTHING,ES:NOTHING
+;
+;       This piece of code determines the size of extended memory
+;       which was allocated before this driver and then subtracts
+;       the amount it has allocated for itself
+;
+;       inputs: ah = 88h is of interest
+;       outputs: ax = size of extended memory allocated by all before and
+;                including us
+;       regs used: flags
+;
+        pushf
+        cmp     ah,88h
+        je      mem_det
+        popf
+        jmp     [old_15]
+mem_det:
+        mov     ax,[int15_size]
+        popf
+        clc
+        sti
+        iret
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;**     INT 9 Keyboard handler
+;
+;       All this piece of code does is look for the Ctrl-Alt-Del event.
+;       If key is not Ctrl-Alt-Del, it jumps to OLD_9 without doing
+;       anything. If the Ctrl-Alt-Del key is detected it calls
+;       RESET_SYSTEM to perform driver TYPE specific re-boot code.
+;       It then resets INT 13H to disable the cache and then jumps to
+;       OLD_9 to pass on the event.
+;
+;       NOTE THAT UNLIKE INT 19 THIS HANDLER DOES NOT NEED TO RESET
+;       THE INT 9 AND INT 19 VECTORS. This is because the Ctrl-Alt-Del
+;       IBM ROM re-boot code resets these vectors.
+;
+;       We would LIKE to ALSO flush the cache, but we can't. For one the
+;       keyboard is at a higher IRQ than the disk. We could EOI the keyboard,
+;       but this doesn't fix the second problem. INT 13s to write
+;       out any dirty tracks take a LONG time, so long that we lose
+;       the key. In other words we see Ctrl-Alt-Del, but none of the
+;       INT 9 handlers after us will.
+;
+;
+;       SEE ALSO
+;           INT 9 IBM ROM code in ROM BIOS listing of
+;           IBM PC Technical Reference manual for any PC family member
+;
+;       ENTRY
+;           NONE
+;       EXIT
+;           NONE, via OLD_9
+;       USES
+;           FLAGS
+;
+;       THIS CODE IS USED BY TYPE 1,2 drivers.
+;
+
+INT_9:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    AX
+        PUSH    DS
+        IN      AL,60H
+        CMP     AL,83                   ; DEL key?
+        JNZ     CHAIN                   ; No
+        XOR     AX,AX
+        MOV     DS,AX
+        MOV     AL,BYTE PTR DS:[417H]   ; Get KB flag
+        NOT     AL
+        TEST    AL,0CH                  ; Ctrl Alt?
+        JNZ     CHAIN                   ; No
+        MOV     [INT_13_BUSY],1         ; Exclude
+;
+; We would LIKE to do this, always but we can't. For one the keyboard
+;   is at a higher IRQ than the disk. We can EOI the keyboard,
+;   but this doesn't fix the second problem. INT 13s to write
+;   out any dirty tracks take a LONG time, so long that we loose
+;   the key. In other words we see Ctrl-Alt-Del, but none of the
+;   INT 9 handlers after us will.
+;
+        CMP     [REBOOT_FLUSH],0        ; Reboot flush enabled?
+        JZ      NO_REBOOT_FLUSH         ; No
+        CMP     [DIRTY_CACHE],0         ; Anything to do?
+        JZ      NO_REBOOT_FLUSH         ; No
+        MOV     AL,20H
+        OUT     20H,AL                  ; EOI the keyboard int
+        CALL    FLUSH_WHOLE_CACHE_SAV   ; Flush cache
+NO_REBOOT_FLUSH:
+;
+        CALL    RESET_SYSTEM            ; Ctrl Alt DEL
+    ;
+    ; Reset INT 13 vector to turn cache off
+    ;
+        MOV     AX,WORD PTR [OLD_13]
+        CLI
+        MOV     WORD PTR DS:[13H * 4],AX
+        MOV     AX,WORD PTR [OLD_13 + 2]
+        MOV     WORD PTR DS:[(13H * 4) + 2],AX
+    ;
+    ; Reset INT 1C vector to turn cache off
+    ;
+;       MOV     AX,WORD PTR [OLD_1C]
+;       MOV     WORD PTR DS:[1CH * 4],AX
+;       MOV     AX,WORD PTR [OLD_1C + 2]
+;       MOV     WORD PTR DS:[(1CH * 4) + 2],AX
+        MOV     [INT_13_BUSY],0
+CHAIN:
+        POP     DS
+        POP     AX
+        JMP     [OLD_9]
+
+;**     INT 19 Software re-boot handler
+;
+;       All this piece of code does is sit on INT 19 waiting for
+;       a re-boot to be signaled by being called. It calls
+;       FLUSH_WHOLE_CACHE_SAV to flush out any dirty cache info then
+;       RESET_SYSTEM to perform driver TYPE specific re-boot code,
+;       resets the INT 19, INT 13 and INT 9 vectors,
+;       and then jumps to OLD_19 to pass on the event.
+;
+;       NOTE THAT UNLIKE INT 9 THIS HANDLER NEEDS TO RESET
+;       THE INT 9 AND INT 19 VECTORS. This is because the INT 19
+;       IBM ROM re-boot code DOES NOT reset these vectors, and we
+;       don't want to leave them pointing to routines that are not
+;       protected from getting stomped on by the re-boot.
+;
+;       SEE ALSO
+;           INT 19 IBM ROM code in ROM BIOS listing of
+;           IBM PC Technical Reference manual for any PC family member
+;
+;       ENTRY
+;           NONE
+;       EXIT
+;           NONE, via OLD_19
+;       USES
+;           FLAGS
+;
+;       THIS CODE IS USED BY TYPE 1,2 drivers.
+;
+
+INT_19:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        MOV     [INT_13_BUSY],1         ; Exclude
+        cmp     [reboot_flush],0        ;
+        je      no_flush
+        CALL    FLUSH_WHOLE_CACHE_SAV   ; Flush out the cache
+no_flush:
+        CALL    RESET_SYSTEM
+        PUSH    AX
+        PUSH    DS
+        XOR     AX,AX
+        MOV     DS,AX
+        MOV     AX,WORD PTR [OLD_13]
+        CLI
+    ;
+    ; Reset INT 13 vector to trun cache off
+    ;
+        MOV     WORD PTR DS:[13H * 4],AX
+        MOV     AX,WORD PTR [OLD_13 + 2]
+        MOV     WORD PTR DS:[(13H * 4) + 2],AX
+    ;
+    ; Reset INT 1C vector to turn cache off
+    ;
+;       MOV     AX,WORD PTR [OLD_1C]
+;       MOV     WORD PTR DS:[1CH * 4],AX
+;       MOV     AX,WORD PTR [OLD_1C + 2]
+;       MOV     WORD PTR DS:[(1CH * 4) + 2],AX
+    ;
+    ; Since INT 19 DOES NOT reset any vectors (like INT 9 Ctrl Alt DEL does),
+    ;   we must replace those vectors we have mucked with.
+    ;
+    ; NOTE THAT WE RESET VECTORS DIRECTLY!!!!!!!!!!!!!!!!!!
+    ;   We are not sure that DOS is reliable enough to call.
+    ;
+        MOV     AX,WORD PTR [OLD_19]
+        MOV     WORD PTR DS:[19H * 4],AX
+        MOV     AX,WORD PTR [OLD_19 + 2]
+        MOV     WORD PTR DS:[(19H * 4) + 2],AX
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;   removed from smartdrv
+;       MOV     AX,WORD PTR [OLD_9]
+;       MOV     WORD PTR DS:[9H * 4],AX
+;       MOV     AX,WORD PTR [OLD_9 + 2]
+;       MOV     WORD PTR DS:[(9H * 4) + 2],AX
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        mov     ax,word ptr [old_15]
+        cmp     ax,word ptr [old_15+2]
+        jne     res_15
+        cmp     ax,-1
+        je      skip_res
+res_15:
+        mov     word ptr ds:[15h*4],ax
+        mov     ax,word ptr    [old_15+2]
+        mov     word ptr ds:[(15h*4) +2],ax
+;
+skip_res:
+        POP     DS
+        POP     AX
+        MOV     [INT_13_BUSY],0
+        JMP     [OLD_19]
+
+;**     RESET_SYSTEM perform TYPE 1 (/E) driver specific reboot code
+;
+;       This code performs the EMM_ISDRIVER reset function as described
+;       in EMM.ASM for all EMM_REC structure for this device (offset
+;       stored in MY_EMM_REC). We use the same LOADALL
+;       method described at BLKMOV to address the EMM_CTRL sector
+;       at the start of extended memory and perform our changes in
+;       place.
+;
+;       NOTE: RESET_SYSTEM ALSO defines the start of ANOTHER piece of
+;               driver TYPE specific code that TYPE 2 drivers
+;               will have to swap in a different piece of code for.
+;
+;       ENTRY
+;           NONE
+;       EXIT
+;           NONE
+;       USES
+;           NONE
+;
+; This code is specific to TYPE 1 drivers
+;
+
+RESET_SYSTEM:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        JMP     SHORT TRUE_START
+
+MY_EMM_REC      DW      0               ; Offset into 1K EMM_CTRL of my record
+
+TRUE_START:
+        PUSHA
+        mov     cs:[reboot_flg],0ffh    ; set the reboot flag
+        cmp     cs:[my_emm_rec],0       ; was an emm record allocated?
+        je      reset_skip
+        PUSH    DS
+        PUSH    ES
+;
+; reset base_addr to be address of emm ctrl sector
+;
+        mov     ax,cs:[emm_ctrl_addr]
+        mov     dx,cs:[emm_ctrl_addr+2]
+        mov     word ptr cs:[base_addr],ax
+        mov     word ptr cs:[base_addr+2],dx
+ ;
+ ;  read 1k emm control sector into track buffer, I want to keep memory
+ ;  access methods separate from driver code. We end up wasting a lot of
+ ;  time here but is reboot code anyway so thats okay
+ ;
+        mov     bx,cs
+        mov     es,bx                   ;
+        mov     di,cs:[track_buffer_ptr]
+        mov     cx,512
+        xor     ax,ax
+        xor     dx,dx
+        mov     bh,0        ; read
+        push    es
+        push    di
+        call    blkmov
+        pop     di
+        pop     es
+        jc      finish_reset
+;
+;   fix the flags for my emm record so that it is no longer in use
+;
+        mov     bx,cs:[my_emm_rec]
+        add     bx,di
+        and     es:[bx.emm_flags],not emm_isdriver
+;
+;   write out the modified emm record out to memory
+;
+        xor     ax,ax
+        xor     dx,dx
+        mov     bh,1        ; write
+        call    blkmov
+finish_reset:
+        POP     ES
+        POP     DS
+reset_skip:
+        POPA
+        RET
+
+;
+; The following label defines the end of the
+; Driver TYPE specific RESET_SYSTEM code which will have to be replaced
+; for different driver TYPEs as the code between RESET_SYSTEM and
+; RESET_INCLUDE. Swapped in code MUST FIT between RESET_SYSTEM and
+; RESET_INCLUDE.
+;
+RESET_INCLUDE  LABEL   BYTE
+
+;
+; This data is only used at INIT, but it must be protected from overwrite
+;  by the DO_INIT code.
+;
+TERM_ADDR       LABEL   DWORD   ; Address to return as break address in INIT packet
+                DW      ?       ; Computed at INIT time
+                DW      ?       ; INT13 CS filled in at INIT
+
+;
+; THIS CODE MUST BE IN RESIDENT PORTION BECAUSE IT WRITES IN THE AREA
+;  OCCUPIED BY THE DISPOSABLE INIT CODE.
+;
+
+;**     DO_INIT - Initialize cache structures to "empty"
+;
+DO_INIT:
+ASSUME  DS:INT13CODE
+        MOV     AX,[SECTRACK]
+        MOV     CL,9
+        SHL     AX,CL                   ; AX is bytes per track buffer
+        MOV     BX,[CACHE_CONTROL_PTR]
+        MOV     CX,[TTRACKS]
+        MOV     [CACHE_HEAD],BX
+        MOV     [BX.BACK_LRU_LNK],-1
+        MOV     WORD PTR [BX.BASE_OFFSET],0
+        MOV     WORD PTR [BX.BASE_OFFSET+2],0
+        MOV     [BX.TRACK_FLAGS],TRACK_FREE
+        MOV     DI,BX
+        ADD     BX,SIZE CACHE_CONTROL   ; Next structure
+        DEC     CX                      ; One less to do
+        JCXZ    SETDONE                 ; one buffer in cache
+SETLOOP:
+        MOV     [DI.FWD_LRU_LNK],BX
+        MOV     [BX.BACK_LRU_LNK],DI
+        MOV     [BX.TRACK_FLAGS],TRACK_FREE
+        MOV     DX,WORD PTR [DI.BASE_OFFSET]
+        ADD     DX,AX
+        MOV     WORD PTR [BX.BASE_OFFSET],DX
+        MOV     DX,WORD PTR [DI.BASE_OFFSET+2]
+        ADC     DX,0
+        MOV     WORD PTR [BX.BASE_OFFSET+2],DX
+        MOV     DI,BX
+        ADD     BX,SIZE CACHE_CONTROL   ; Next structure
+        LOOP    SETLOOP
+SETDONE:
+        MOV     [DI.FWD_LRU_LNK],-1
+        MOV     [CACHE_TAIL],DI         ; That is the tail
+;
+;       NOTE FALL THROUGH!!!!!!!
+;
+
+;**     SETBPB - Set INIT packet I/O return values
+;
+;       This entry is used to set the INIT packet Break address
+;
+;       ENTRY
+;           TERM_ADDR set to device end
+;       EXIT
+;           through DEVEXIT
+;       USES
+;           DS, BX, CX
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+
+SETBPB:
+ASSUME  DS:NOTHING
+    ;
+    ; 7.  Set the return INIT I/O packet values
+    ;
+        LDS     BX,[PTRSAV]
+        MOV     CX,WORD PTR [TERM_ADDR]
+        MOV     WORD PTR [BX.INIT_BREAK],CX                ;SET BREAK ADDRESS
+        MOV     CX,WORD PTR [TERM_ADDR + 2]
+        MOV     WORD PTR [BX.INIT_BREAK + 2],CX
+        JMP     DEVEXIT
+
+
+        EVEN                    ; Make sure we get word alignment of the track
+                                ;    buffer.
+
+;
+; The following items define the "track buffer". When we want to I/O a track
+;    this is where we do it. We cannot I/O the track directly into extended
+;    memory because we have no way to specify a 24 bit address to INT 13. We
+;    Cannot I/O direct to expanded memory because DMA into the expanded memory
+;    window is not supported. This buffer also "holds" one track, so we keep
+;    track of the last track that was in here because it is faster to access
+;    it here than through extended/expanded memory. A value of -1 in the
+;    "currency" fields indicates that there is currently nothing interesting
+;    in the track buffer. NOTE: It is ASSUMED that the track buffer always
+;    represents a track that is IN the cache, therefore one must be sure to
+;    invalidate the track buffer when the cache element it represents is
+;    discarded. The offset of the track buffer is dynamic. Never talk about
+;    OFFSET TRACK_BUFFER. Always get the track buffer address out of
+;    TRACK_BUFFER_PTR. The initialization code "moves" the track buffer so
+;    that it does not cause a DMA Boundary error which would slow things
+;    down quite a bit.
+;
+
+;
+; Cylinder and hd/drv of track in track buffer
+;
+TRACK_BUFFER_CYLN       DW      -1
+TRACK_BUFFER_HDDR       DW      -1
+
+;
+; Pointer to track buffer. May be adjusted for DMA boundary error prevention.
+;
+TRACK_BUFFER_PTR DW     OFFSET TRACK_BUFFER
+
+;
+; Cache structure pointers
+;
+
+;
+; Pointer to cache structures. This ends up being right after TRACK_BUFFER.
+;
+CACHE_CONTROL_PTR DW    ?
+
+;
+; Cache head and tail pointers
+;
+CACHE_HEAD      DW      ?
+CACHE_TAIL      DW      ?
+
+;
+; This is the "in the 1Meg address space" track buffer. Its TRUE start
+; may be adjusted for DMA boundary violation error prevention, and its
+; Size may be adjusted depending on how many sectors per track there
+; are. WARNING! This buffer must be AT LEAST 1024 bytes for /E driver
+; init code (buffer for 1K EMM control sector).
+;
+TRACK_BUFFER    DB      (512 * 2 + 16) DUP(0)
+                                    ; we really don't need those 16 bytes, i
+                                    ; am just paranoid
+;
+; The TERM_ADDR for the device will be set somewhere "around" here
+;    by the init code
+;
+
+BREAK   <COMMON INIT CODE>
+
+;**     DISPOSABLE INIT DATA
+;
+; INIT data which need not be part of resident image
+;
+
+U_SWITCH        db      0       ;; upper extended memory requested on 6300 PLUS
+
+EXT_K           DW      ?       ; Size in K of Extended memory.
+
+NUM_ARG         DB      1       ; Counter for numeric
+                                ;    arguments  bbbb.
+
+GOTSWITCH       DB      0       ; Bit map of switches seen
+
+ SWITCH_E        EQU     00000001B
+ SWITCH_A        EQU     00000010B   ; Only switch allowed
+ SWITCH_T        EQU     00000100B
+ SWITCH_D        EQU     00001000B
+ SWITCH_WT       EQU     00010000B
+ SWITCH_WC       EQU     00100000B
+ SWITCH_R        EQU     01000000B
+ SWITCH_C        EQU     10000000B
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+sys_det proc    near
+;
+; author:  sunilp, august 1, 1987.  thanks to rickha for most of this
+;          routine.
+;
+; purpose: to determine whether extended memory cache can be installed
+;          on this system. also to determine and store in the system 
+;          flag the machine identification.
+;
+; inputs:  none
+;
+; outputs: CY set if this machine doesn't allow extended memory cache.
+;          CY clear if this machine allows extended memory cache and
+;                   the system flag is set according to the machine type.
+;
+; registers used:  ax,es,flags
+;----------------------------------
+;       Clear the state of the system flag
+;
+assume ds:int13code,es:nothing,ss:nothing
+        xor     ax,ax                   ; 0000 into AX
+        mov     [sys_flg],al            ; clear system flag
+;----------------------------------
+;       Determine if 8086/8088 system. If so we should abort immediately.
+;
+        push    ax                      ; ax has 0
+        popf                            ; try to put that in the flags
+        pushf
+        pop     ax                      ; look at what really went into flags
+        and     ax,0F000h               ; mask off high flag bits
+        cmp     ax,0F000h               ; Q: was high nibble all ones ?
+        je      cpu_err                 ; Y: it's an 8086 (or 8088)
+;----------------------------------
+;       Determine if 80286/80386 machine. 
+;
+        mov     ax,0F000h               ;   N: try to set the high bits
+        push    ax
+        popf                            ;      ... in the flags
+        pushf
+        pop     ax                      ; look at actual flags
+        and     ax,0F000h               ; Q: any high bits set ?
+        je      cpu_286                 ;   N: it's an 80286
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;       It is a 386 cpu. We should next try to determine if the ROM is
+;       B0 or earlier. We don't want these guys.
+;
+cpu_386:
+        pushf                           ; clear
+        pop     ax                      ;   NT
+        and     ax,not 0F000h           ;     and
+        push    ax                      ;       IOPL
+        popf                            ;         bits
+;----------------------------------
+;       the next three instructions were removed because we are loaded
+;       in real mode. So there is no need to check for virtual mode.
+;
+;       smsw    ax                      ;check for Virtual Mode
+;       test    ax,0001                 ; Q: Currently in Virtual Mode ?
+;       jnz     cpu_exit                ;   Y: quit with error message
+;----------------------------------
+                                        ;   N: check 386 stepping for B0
+        call    is_b0                   ; Q: B0 ?
+        jc      cpu_err                 ;   Y: abort
+;----------------------------------
+;       We have a valid 386 guy. Set the flag to indicate this.
+;
+        or      [sys_flg],M_386         ; set 386 bit
+        jmp     short PS2Test
+
+;----------------------------------
+;       This is a 286 guy. Check for AT model byte. We don't want non-ATs.
+;       Set 286 bit if AT type. Then check for PS/2
+;
+cpu_286:
+        mov     ax,0ffffh
+        mov     es,ax
+        cmp     byte ptr es:[0eh],0fch  ; AT model byte
+        jne     cpu_err                 ; if not abort
+;
+        or      [sys_flg],M_286         ; set 286 flag bit
+;
+;
+;       Determine if this is a PS/2 system
+;
+PS2Test:
+        call    IsPS2Machine
+        or      ax,ax
+        jz      NCRTest
+        or      [sys_flg],M_PS2
+
+NCRTest:
+        call    IsNCRMachine
+        or      ax,ax
+        jz      cpu_suc
+
+        ; We're on an NCR machine, send D7 and D5 to the 8042 in order
+        ; to toggle A20 instead of the DF and DD we usually send.
+        ; ChipA 06-16-88
+        mov     cs:[A20On],0D790h
+        mov     cs:[A20Off],0D500h
+
+;----------------------------------
+;       success exit:--
+cpu_suc:
+        clc
+        ret
+
+;----------------------------------
+;       error exit:--
+cpu_err:
+        stc
+        ret
+;
+sys_det endp
+
+
+;*--------------------------------------------------------------------------*
+;*                                                                          *
+;*  IsPS2Machine                                            HARDWARE DEP.   *
+;*                                                                          *
+;*      Check for PS/2 machine                                              *
+;*                                                                          *
+;*  ARGS:   None                                                            *
+;*  RETS:   AX = 1 if we're on a valid PS/2 machine, 0 otherwise            *
+;*  REGS:   AX  and Flags clobbered                                         *
+;*                                                                          *
+;*--------------------------------------------------------------------------*
+
+IsPS2Machine proc   near
+
+            mov     ah,0C0h         ; Get System Description Vector
+            stc
+            int     15h
+            jc      short IPMNoPS2  ; Error?  Not a PS/2.
+
+            ; Are we on a PS/2 Model 35?
+            cmp     es:[bx+2],09FCh
+            je      short IPMFoundIt        ; Yup, use the PS/2 method
+
+            ; Do we have a "Micro Channel" computer?
+            mov     al,byte ptr es:[bx+5]   ; Get "Feature Information Byte 1"
+            test    al,00000010b    ; Test the "Micro Channel Implemented" bit
+            jz      short IPMNoPS2
+
+IPMFoundIt: mov     ax,1
+            ret
+
+IPMNoPS2:   xor     ax,ax
+            ret
+
+IsPS2Machine endp
+
+
+;*--------------------------------------------------------------------------*
+;*                                                                          *
+;*  IsNCRMachine                                            HARDWARE DEP.   *
+;*                                                                          *
+;*      Check for NCR machine                                               *
+;*                                                                          *
+;*  ARGS:   None                                                            *
+;*  RETS:   AX = 1 if we're on a valid NCR machine, 0 otherwise             *
+;*  REGS:   AX  and Flags clobbered                                         *
+;*                                                                          *
+;*--------------------------------------------------------------------------*
+
+; Look for 'NC' at F000:FFEA
+
+IsNCRMachine proc   near
+
+            mov     ax,0F000h
+            mov     es,ax
+            mov     ax,word ptr es:[0FFEAh]
+            cmp     ax,'CN'
+            je      INMFoundIt
+            xor     ax,ax
+            ret
+
+INMFoundIt: mov     ax,1
+            ret
+
+IsNCRMachine endp
+
+
+;******************************************************************************
+;   IS_B0 - check for 386-B0
+;
+;   This routine takes advantage of the fact that the bit INSERT and 
+;   EXTRACT instructions that existed in B0 and earlier versions of the
+;   386 were removed in the B1 stepping.  When executed on the B1, INSERT 
+;   and EXTRACT cause an INT 6 (invalid opcode) exception.  This routine
+;   can therefore discriminate between B1/later 386s and B0/earlier 386s.
+;   It is intended to be used in sequence with other checks to determine
+;   processor stepping by exercising specific bugs found in specific
+;   steppings of the 386.
+;
+;   ENTRY:  REAL MODE on 386 processor (CPU ID already performed)
+;   EXIT:   CF = 0 if B1 or later
+;           CF = 1 if B0 or prior
+;
+;   ENTRY:  
+;   EXIT:   
+;   USED:   AX, flags
+;   STACK:  
+;------------------------------------------------------------------------------
+is_b0   proc    near
+        push    bx
+        push    cx
+        push    dx
+        push    ds
+
+        xor     bx,bx
+        mov     ds,bx                   ; DS = 0000 (real mode IDT)
+assume ds:R_Mode_IDT
+        push    [bx+(6*4)]
+        pop     cs:[int6_save]          ; save old INT 6 offset
+        push    [bx+(6*4)+2]
+        pop     cs:[int6_save+2]        ; save old INT 6 segment
+                                        
+        mov     word ptr [bx+(6*4)],offset int6
+        mov     [bx+(6*4)+2],cs         ; set vector to new INT 6 handler
+;
+;   Attempt execution of Extract Bit String instruction.  Execution on
+;   B0 or earlier with length (CL) = 0 will return 0 into the destination 
+;   (CX in this case).  Execution on B1 or later will fail and dummy INT 6
+;   handler will return execution to the instruction following the XBTS.
+;   CX will remain unchanged in this case.
+;
+        xor     ax,ax
+        mov     dx,ax
+        mov     cx,0FF00h               ; Extract length (CL)=0, CX=non-zero
+        db      0Fh,0A6h,0CAh           ; XBTS CX,DX,AX,CL
+        
+        xor     bx,bx
+        mov     ds,bx                   ; DS = 0000 (real mode IDT)
+        push    cs:[int6_save]          ; restore original INT 6 offset
+        pop     [bx+(6*4)]              ;
+        push    cs:[int6_save+2]        ; restore original INT 6 segment
+        pop     [bx+(6*4)+2]
+
+        or      cx,cx                   ; Q: CX = 0 (meaning <=B0) ?
+        jz      ib_exit                 ;   Y: exit (carry clear)
+        stc                             ;   N: set carry to indicate >=B1
+ib_exit:
+        cmc                             ; flip carry tense
+        pop     ds
+        pop     dx
+        pop     cx
+        pop     bx
+        ret                             ; *** RETURN ***
+is_b0   endp
+;
+;   Temporary INT 6 handler - assumes the cause of the exception was the 
+;   attempted execution of an XTBS instruction.
+;
+int6    proc    near
+        push    bp
+        mov     bp,sp
+        add     word ptr [bp+2],3       ; bump IP past faulting instruction
+        pop     bp
+        iret                            ; *** RETURN ***
+int6_save       dw      0000,0000
+int6    endp
+;***************************************************************************
+
+;**     PRINT - Print a "$" terminated message on stdout
+;
+;       This routine prints "$" terminated messages on stdout.
+;       It may be called with only the DX part of the DS:DX message
+;       pointer set, the routine puts the correct value in DS to point
+;       at the INT13 messages.
+;
+;       ENTRY:
+;            DX pointer to "$" terminated message (INT13CODE relative)
+;       EXIT:
+;            NONE
+;       USES:
+;            AX
+;
+;       COMMON TO TYPE 1, 2, 3, 4 drivers
+;
+
+PRINT:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    DS
+        PUSH    CS
+        POP     DS
+        MOV     AH,Std_Con_String_Output
+        INT     21H
+        POP     DS
+        RET
+
+;**     ITOA - Print Decimal Integer on stdout
+;
+;       Print an unsigned 16 bit value as a decimal integer on stdout
+;       with leading zero supression. Prints from 1 to 5 digits. Value
+;       0 prints as "0".
+;
+;       Routine uses divide instruction and a recursive call. Maximum
+;       recursion is four (five digit number) plus one word on stack
+;       for each level.
+;
+;       ENTRY   AX has binary value to be printed
+;       EXIT    NONE
+;       USES    AX,CX,DX,FLAGS
+;
+;       COMMON TO TYPE 1, 2, 3, 4 drivers
+;
+
+ITOA:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+
+        MOV     CX,10
+        XOR     DX,DX
+        DIV     CX                      ; DX is low digit, AX is higher digits
+        OR      AX,AX
+        JZ      PRINT_THIS_DIGIT        ; No more higher digits
+        PUSH    DX                      ; Save this digit
+        CALL    ITOA                    ; Print higher digits first
+        POP     DX                      ; Recover this digit
+PRINT_THIS_DIGIT:
+        ADD     DL,"0"                  ; Convert to ASCII
+        MOV     AH,Std_CON_Output
+        INT     21H
+        RET
+
+
+;**     INT13$INIT - Device Driver Initialization routine
+;
+;       INT13 Initialization routine. This is the COMMON initialization
+;       code used by ALL driver TYPEs. Its jobs are to:
+;
+;           1.  Initialize various global values
+;           2.  Check for correct DOS version and do changes to the device
+;                       based on the DOS version if needed.
+;           3.  Set OLD_13, OLD_1C and Parse the command line and set values accordingly
+;           4.  Set up the cache parameters and
+;               Call a TYPE specific INIT routine based on the Parse
+;                       to set up a specific driver TYPE.
+;           5.  Print out report of INT13 parameters
+;           6.  Set the return INIT I/O packet values
+;
+;       The first two lines perform step 1. Step two starts after and
+;       goes through VER_OK. Step 3 starts at VER_OK and goes through
+;       ARGS_DONE. Step 4 starts at ARGS_DONE and goes through I001.
+;       Step 5 starts at I001 and goes through DRIVE_SET. Step 6 starts
+;       at DRIVE_SET and goes through SETBPB. Step 7 starts at SETBPB
+;       and ends at the JMP DEVEXIT 10 lines later.
+;
+;       At any time during the above steps an error may be detected. When
+;       this happens one of the error messages is printed and INT13
+;       de-installs itself.  It does this at DEVABORT_NOMES by changing
+;       the Device attributes to a BLOCK DEVICE and setting its size to NULL.
+;       All INT13 needs to do is make sure any INT vectors it changed
+;       (INT 9 and INT 19 and INT 13) get restored to what they were
+;       when INT13 first started.  If an EMM_CTRL sector is being
+;       used (TYPE 1) and one of the EMM_REC structures has been
+;       marked EMM_ISDRIVER by this driver, it must turn that bit back off
+;       since the driver did not install. A TYPE 2 driver must make sure it
+;       ABOVE_DEALLOCs any memory it allocated from the EMM device. The duty
+;       of reclaiming EMM_CTRL or Above Board memory and re-setting vectors
+;       is done by the DISK_ABORT routine which may be called by either
+;       this COMMON INIT code, or the TYPE specific INIT code.
+;
+;       Step 1 initializes the segment part of TERM_ADDR to the correct
+;       value for type 1, 2 drivers.
+;
+;       Step 2 checks to make sure that we are running on a DOS in the
+;       2.X or 3.X series which this driver is restricted to. If running
+;       on a 2.X series the device header attribute word and device command
+;       table are patched to exclude those device calls that don't exist
+;       on DOS 2.X.
+;
+;       Step 3 uses the "DEVICE = xxxxxxxxx" line pointer provided by
+;       DOS to look for the various device parameters. NOTE: This pointer
+;       IS NOT DOCUMENTED in the DOS 2.X tech ref material, but it does
+;       exist in the same way as 3.X. This code is simple even though
+;       it looks rather long. First it skips over the device name field
+;       to get to the arguments. In then parses the arguments as they are
+;       encountered. All parameter errors are detected here. NOTE THAT
+;       THIS ROUTINE IS NOT RESPONSIBLE FOR SETTING DEFAULT VALUES OF
+;       PARAMETER VARIABLES. This is accomplished by static initialization
+;       of the parameter variables.
+;
+;       Step 4 calls a device TYPE specific initialization routine based
+;       on the parse in step 3 (presence or absense of /E and /A switches).
+;       NOTE that one of the prime jobs of these device TYPE specific
+;       routines is to set all of the variables that are needed by Step
+;       5 and 6 that haven't been set by the COMMON init code:
+;
+;                       DEV_SIZE   set to TRUE size of device
+;                       BASE_ADDR  set to TRUE start of device so BLKMOV
+;                                       can be called
+;                       BASE_RESET set so DISK_ABORT can be called
+;                       TERM_ADDR  set to correct end of device
+;
+;       Step 5 makes the status report display of DEVICE SIZE and other info.
+;
+;       Step 6 sets the INIT I/O packet return values for Break address.
+;
+;
+;       SEE ALSO
+;         MS-DOS Technical Reference manual section on
+;         Installable Device Drivers
+;
+;       ENTRY from INT13$IN
+;       EXIT Through DEVEXIT
+;       USES ALL
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+
+INT13$INIT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+    ;
+    ; 1.  Initialize various global values
+    ;
+        MOV     WORD PTR [TERM_ADDR + 2],CS
+    ;
+    ; 2.  Check for correct DOS version and do changes to the device
+    ;        based on the DOS version if needed.
+    ;
+        CLD
+        MOV     AH,GET_VERSION
+        INT     21H
+        XCHG    AH,AL
+        CMP     AX,(2 SHL 8) + 00
+        JB      BADVER                  ; Below 2.00, BAD
+        CMP     AX,(3 SHL 8) + 00
+        JB      VER2X                   ; 2.X requires some patches
+        CMP     AX,(4 SHL 8) + 00
+        JBE     VER_OK                  ; 3.X or 4.0 OK
+BADVER:
+        MOV     DX,OFFSET BADVERMES
+        JMP     DEVABORT
+
+VER2X:
+        AND     [DEVATS],NOT DEVOPCL        ; No such bit in 2.X
+        MOV     BYTE PTR [INT13TBL],11      ; Fewer functions too
+VER_OK:
+
+;;
+;; 2.5 Check here for 6300 PLUS machine.  First look for Olivetti copyright,
+;;     and if found, check id byte at f000:fffd.
+;;
+
+        push    es                              ;; Olivetti Machine?
+        mov     ax,0fc00h                       ;; Look for 'OL' at fc00:50
+        mov     es,ax
+        cmp     es:[0050h],'LO'
+        jnz     notS5                           ;; not found
+        mov     ax,0f000h
+        mov     es,ax
+        cmp     word ptr es:[0fffdh],0fc00h     ;; look for 6300 plus
+        jnz     notS5
+        mov     [S5_FLAG],S_OLIVETTI            ;; yep, set flag
+notS5:
+
+;; Check here for an HP Vectra machine.  Look for HP id byte.
+;;
+        mov     ax,0f000H
+        mov     es,ax
+        cmp     es:[0f8H],'PH'
+        jnz     notHP
+        mov     [S5_FLAG],S_VECTRA
+notHP:
+        pop     es
+
+;
+; 3.  Set OLD_13, OLD_1C and Parse the command line and set values accordingly
+;
+        MOV     AX,(Get_Interrupt_Vector SHL 8) OR 13H
+        INT     21H
+        MOV     WORD PTR [OLD_13],BX
+        MOV     WORD PTR [OLD_13 + 2],ES
+        MOV     AX,(Get_Interrupt_Vector SHL 8) OR 1CH
+        INT     21H
+        MOV     WORD PTR [OLD_1C],BX
+        MOV     WORD PTR [OLD_1C + 2],ES
+        LDS     SI,[PTRSAV]
+ASSUME  DS:NOTHING
+        MOV     DX,OFFSET HEADERMES
+        CALL    PRINT
+        LDS     SI,[SI.INIT_BPB]    ; DS:SI points to config.sys
+SKIPLP1:                            ; Skip leading delims to start of name
+        LODSB
+        CMP     AL," "
+        JZ      SKIPLP1
+        CMP     AL,9
+        JZ      SKIPLP1
+        CMP     AL,","
+        JZ      SKIPLP1
+        JMP     SHORT SKIPNM
+
+ARGS_DONEJ:
+        JMP     ARGS_DONE
+
+SWITCHJ:
+        JMP     SWITCH
+
+SKIPLP2:                        ; Skip over device name
+        LODSB
+SKIPNM:
+        CMP     AL,13
+        JZ      ARGS_DONEJ
+        CMP     AL,10
+        JZ      ARGS_DONEJ
+        CMP     AL," "
+        JZ      FIRST_ARG
+        CMP     AL,9
+        JZ      FIRST_ARG
+        CMP     AL,","
+        JZ      FIRST_ARG
+        CMP     AL,0            ; Need this for 2.0 2.1
+        JNZ     SKIPLP2
+SCAN_LOOP:                      ; PROCESS arguments
+        LODSB
+FIRST_ARG:
+        OR      AL,AL           ; Need this for 2.0 2.1
+        JZ      ARGS_DONEJ
+        CMP     AL,13
+        JZ      ARGS_DONEJ
+        CMP     AL,10
+        JZ      ARGS_DONEJ
+        CMP     AL," "
+        JZ      SCAN_LOOP
+        CMP     AL,9
+        JZ      SCAN_LOOP
+        CMP     AL,","
+        JZ      SCAN_LOOP
+        CMP     AL,"/"
+        JZ      SWITCHJ
+        CMP     AL,"0"
+        JB      BAD_PARMJ
+        CMP     AL,"9"
+        JA      BAD_PARMJ
+        DEC     SI
+        CALL    GETNUM
+        CMP     [NUM_ARG],1
+        JA      BAD_PARMJ                ; Only 1 numeric argument
+SET_SIZE:
+        CMP     BX,128
+        JB      BAD_PARMJ
+        CMP     BX,8192
+        JA      BAD_PARMJ
+        MOV     [DEV_SIZE],BX
+;A
+        mov     [current_dev_size],bx
+;A
+        JMP     SHORT NUM_DONE
+
+BAD_PARMJ:
+        JMP     SHORT BAD_PARM
+
+NUM_DONE:
+        INC     [NUM_ARG]               ; Next numeric argument
+SCAN_LOOPJ:
+        JMP     SCAN_LOOP
+
+BAD_PARM:
+        MOV     DX,OFFSET ERRMSG1
+DEVABORT:
+        CALL    PRINT
+DEVABORT_NOMES:
+;       INC     [NULDEV]                ;Indicate NUL device
+;       MOV     WORD PTR [TERM_ADDR],OFFSET ERROR_END ;Minimul null device
+;       JMP     SETBPB                  ;and return
+        LDS     BX,[PTRSAV]
+        MOV     WORD PTR [BX].INIT_NUM,0
+        MOV     WORD PTR [BX].INIT_BREAK[0],0
+        MOV     WORD PTR [BX].INIT_BREAK[2],CS
+        MOV     [DEVATS],0
+        JMP     DEVEXIT
+
+SWITCH:
+        LODSB
+        OR      AL,20H
+
+if WINDOWS_SWITCHES eq 0
+        CMP     AL,"e"
+        JNZ     ABOVE_TEST
+EXT_SET:
+        TEST    [GOTSWITCH],SWITCH_E + SWITCH_A
+        JNZ     BAD_PARM
+        OR      [GOTSWITCH],SWITCH_E
+        MOV     [DRIVER_SEL],0
+        JMP     SCAN_LOOP
+
+ABOVE_TEST:
+
+endif   ; WINDOWS_SWITCHES eq 0
+
+;; Added for /u switch
+        cmp     al,'u'                  ;; Look for U switch for PLUS
+        jnz     A_TEST
+        cmp     [S5_FLAG],S_OLIVETTI    ;; No good unless PLUS
+        jne     bad_parm
+        TEST    [GOTSWITCH],SWITCH_A    ;; Already have switch A ?
+        JNZ     BAD_PARM
+        cmp     [U_SWITCH],0
+        jne     bad_parm
+        dec     [U_SWITCH]
+        jmp     scan_loop
+A_TEST:
+;;
+        CMP     AL,"a"
+
+if WINDOWS_SWITCHES
+        jnz     bad_parm
+else
+        JNZ     DIS_TEST
+endif   ;WINDOWS_SWITCHES
+
+ABOVE_SET:
+        TEST    [GOTSWITCH],SWITCH_A    ; Was SWITCH_E + SWITCH_A
+        JNZ     BAD_PARM
+;; added for /u switch
+        cmp     [U_SWITCH],0
+        jne     bad_parm
+;;
+        OR      [GOTSWITCH],SWITCH_A
+        MOV     [DRIVER_SEL],1
+        JMP     SCAN_LOOP
+
+if WINDOWS_SWITCHES eq 0
+
+DIS_TEST:
+        CMP     AL,"d"
+        JNZ     W_TEST
+DIS_SET:
+        TEST    [GOTSWITCH],SWITCH_D
+        JNZ     BAD_PARM
+        OR      [GOTSWITCH],SWITCH_D
+        MOV     [ENABLE_13],0
+        JMP     SCAN_LOOP
+
+W_TEST:
+        CMP     AL,"w"
+        JNZ     T_TEST
+        LODSW
+        OR      AL,20H
+        CMP     AX,":c"
+        JNZ     WT_TEST
+        LODSW
+        OR      AX,2020H
+        CMP     AX,"fo"
+        JNZ     BAD_PARM
+        LODSB
+        OR      AL,20H
+        CMP     AL,"f"
+        JNZ     BAD_PARMJX
+WC_SET:
+        TEST    [GOTSWITCH],SWITCH_WC
+        JNZ     BAD_PARMJX
+        OR      [GOTSWITCH],SWITCH_WC
+        MOV     [WRITE_BUFF],0
+        JMP     SCAN_LOOP
+
+WT_TEST:
+        CMP     AX,":t"
+        JNZ     BAD_PARMJX
+        LODSW
+        OR      AX,2020H
+        CMP     AX,"no"
+        JNZ     BAD_PARMJX
+WT_SET:
+        TEST    [GOTSWITCH],SWITCH_WT
+        JNZ     BAD_PARMJX
+        OR      [GOTSWITCH],SWITCH_WT
+        MOV     [WRITE_THROUGH],1
+        JMP     SCAN_LOOP
+
+BAD_PARMJX:
+        JMP     BAD_PARM
+
+T_TEST:
+        CMP     AL,"t"
+        JNZ     R_TEST
+        LODSW
+        CMP     AL,":"
+        JNZ     BAD_PARMJX
+        CMP     AH,"0"
+        JB      BAD_PARMJX
+        CMP     AH,"9"
+        JA      BAD_PARMJX
+        DEC     SI
+        CALL    GETNUM
+T_SET:
+        TEST    [GOTSWITCH],SWITCH_T
+        JNZ     BAD_PARMJX
+        OR      [GOTSWITCH],SWITCH_T
+        MOV     [TICK_SETTING],BX
+        JMP     SCAN_LOOP
+
+R_TEST:
+        CMP     AL,"r"
+        JNZ     C_TEST
+        LODSW
+        OR      AH,20H
+        CMP     AX,"o:"
+        JNZ     BAD_PARMJX
+        LODSB
+        OR      AL,20H
+        CMP     AL,"n"
+        JNZ     BAD_PARMJX
+        TEST    [GOTSWITCH],SWITCH_R
+        JNZ     BAD_PARMJX
+        OR      [GOTSWITCH],SWITCH_R
+        MOV     [REBOOT_FLUSH],1
+        JMP     SCAN_LOOP
+
+C_TEST:
+        CMP     AL,"c"
+        JNZ     BAD_PARMJX
+        LODSW
+        OR      AH,20H
+        CMP     AX,"o:"
+        JNZ     BAD_PARMJX
+        LODSB
+        OR      AL,20H
+        CMP     AL,"n"
+        JNZ     BAD_PARMJX
+        TEST    [GOTSWITCH],SWITCH_C
+        JNZ     BAD_PARMJX
+        OR      [GOTSWITCH],SWITCH_C
+        MOV     [ALL_CACHE],1
+        JMP     SCAN_LOOP
+endif   ;WINDOWS_SWITCHES eq 0
+
+ARGS_DONE:
+;
+; 4.  Call a TYPE specific INIT routine based on the Parse
+;        to set up a specific driver TYPE.
+;
+        PUSH    CS
+        POP     DS
+ASSUME  DS:INT13CODE
+        MOV     AL,[DRIVER_SEL]         ; Find out which init to call
+        OR      AL,AL
+        JNZ     NEXTV
+        CALL    AT_EXT_INIT
+        JMP     SHORT INI_RET
+
+NEXTV:
+        CALL    ABOVE_INIT
+INI_RET:
+        JNC     I001
+        JMP     DEVABORT_NOMES
+
+I001:
+DRIVE_SET:
+    ;
+    ; update the current device size
+    ;
+        mov     ax,[dev_size]
+        mov     [current_dev_size],ax
+    ;
+    ; 6.  Print out report of INT13 parameters
+    ;
+        MOV     DX,OFFSET STATMES1
+        CALL    PRINT
+        MOV     AX,[DEV_SIZE]
+        CALL    ITOA
+        MOV     DX,OFFSET STATMES1E
+        CMP     [DRIVER_SEL],0
+        JZ      PTYPX
+        MOV     DX,OFFSET STATMES1A
+PTYPX:
+        CALL    PRINT
+        MOV     DX,OFFSET STATMES2
+        CALL    PRINT
+        MOV     AX,[TTRACKS]
+        CALL    ITOA
+        MOV     DX,OFFSET STATMES3
+        CALL    PRINT
+        MOV     AX,[SECTRACK]
+        CALL    ITOA
+        MOV     DX,OFFSET STATMES4
+        CALL    PRINT
+
+ifdef   OMTI
+        mov     dx,offset omti_msg
+        call    print
+endif
+IF DEBUG
+        MOV     DX,OFFSET STATMES5
+        CALL    PRINT
+        MOV     AX,CS
+        CALL    ITOA
+        MOV     DX,OFFSET STATMES6
+        CALL    PRINT
+ENDIF
+    ;
+    ; Turn on the cache by chaining INT 13, and INT 1C
+    ;
+        MOV     DX,OFFSET INT_13_HANDLER
+        MOV     AX,(Set_Interrupt_Vector SHL 8) OR 13H
+        INT     21H
+;       MOV     DX,OFFSET INT_1C_HANDLER
+;       MOV     AX,(Set_Interrupt_Vector SHL 8) OR 1CH
+;       INT     21H
+        JMP     DO_INIT
+
+;**     DRIVEPARMS Initialize drive related cache parameters
+;
+;       ENTRY
+;           Stuff set so that BLKMOV can be used to access cache memory
+;           DEV_SIZE set to TRUE cache size in K
+;       EXIT
+;           Carry Set
+;               Error, message already printed
+;           Carry clear
+;               TRACK_BUFFER_PTR adjusted for DMA error prevention
+;               CACHE_CONTROL_PTR set
+;               TERM_ADDR set
+;               TTRACKS set
+;               SECTRACK set
+;               SECTRKARRAY set
+;               HDARRAY set (SUNILP)
+;       USES
+;           ALL but DS
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+;
+NO_HARDFILES:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        MOV     DX,OFFSET NOHARD
+PEER:
+        CALL    PRINT
+        STC
+        RET
+
+TRACK_TOO_BIG:
+        MOV     DX,OFFSET BIGTRACK
+        JMP     PEER
+
+DRIVEPARMS:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+    ;
+    ; First figure out sec/track of any hardfiles
+    ;
+        MOV     DL,80H
+        MOV     AH,8
+        INT     13H
+        JC      NO_HARDFILES
+        OR      DL,DL
+        JZ      NO_HARDFILES
+        AND     CL,00111111B
+        MOV     [SECTRKARRAY],CL
+        mov     [hdarray],dh
+        XOR     CH,CH
+        MOV     [SECTRACK],CX
+        MOV     CL,DL
+        DEC     CX
+        JCXZ    FINISHED
+        CMP     CX,MAX_HARD_FILES - 1
+        JBE     DNUM_OK
+        MOV     CX,MAX_HARD_FILES - 1
+DNUM_OK:
+        MOV     DL,81H
+PARMLOOP:
+        PUSH    CX
+        PUSH    DX
+        MOV     AH,8
+        INT     13H
+        JC      IGNORE_DRIVE
+        AND     CL,00111111B
+        POP     BX
+        PUSH    BX
+        AND     BX,0000000001111111B
+        MOV     [BX.SECTRKARRAY],CL
+        mov     [bx.hdarray],dh
+        XOR     CH,CH
+        CMP     CX,[SECTRACK]
+        JBE     IGNORE_DRIVE
+        MOV     [SECTRACK],CX
+IGNORE_DRIVE:
+        POP     DX
+        INC     DL
+        POP     CX
+        LOOP    PARMLOOP
+FINISHED:
+    ;
+    ; Figure out number of full tracks that fit in cache
+    ;
+        MOV     AX,[SECTRACK]
+        MOV     CX,512
+        MUL     CX              ; DX:AX = Bytes per track
+        OR      DX,DX
+        JNZ     TRACK_TOO_BIG
+        MOV     BX,AX           ; BX is bytes per track
+        MOV     AX,[DEV_SIZE]
+        MOV     CX,1024
+        MUL     CX              ; DX:AX = size of cache in bytes
+        DIV     BX              ; AX is full tracks in cache
+        MOV     [TTRACKS],AX
+    ;
+    ; Figure out if we have a DMA boundary problem
+    ;
+        mov     DX,DS                   ; Check for 64k boundary error
+        shl     DX,1
+        shl     DX,1
+        shl     DX,1
+        shl     DX,1                    ; Segment converted to absolute address
+        add     DX,[TRACK_BUFFER_PTR]   ; Combine with offset
+        add     DX,511                  ; simulate a one sector transfer
+                                        ; And set next divide for round up
+;
+; If carry is set, then we are within 512 bytes of the end of the DMA segment.
+; Adjust TRACK_BUFFER_PTR UP by 512 bytes.
+;
+        jnc     NotWithin512
+        add     [TRACK_BUFFER_PTR],512  ; adjust
+        jmp     short SetCachest
+
+NotWithin512:
+;
+; DX is the physical low 16 bits of the proposed track buffer plus 511.
+; See how many sectors fit up to boundary.
+;
+        shr     DH,1            ; DH = number of sectors in DMA segment
+                                ;       till start of buffer rounded up
+        mov     AH,128          ; AH = max number of sectors in DMA segment
+        sub     AH,DH
+;
+; AH is now the number of sectors that we can successfully transfer using this
+; address without a DMA boundary problem. If this number is above or equal to
+; the track buffer size, then buffer is OK. Otherwise, we adjust buffer UP
+; till it is after the boundary by adding ((AH+1)*512) to the buffer address.
+;
+        mov     al,ah
+        xor     ah,ah
+        cmp     AX,[SECTRACK]           ; can we fit it in?
+        jae     SetCachest              ; yes, buffer is OK
+        inc     ax                      ; Add 1
+        mov     cl,9                    ; Mult by 512
+        shl     ax,cl
+        add     [TRACK_BUFFER_PTR],ax   ; Adjust
+SetCachest:
+    ;
+    ; Set pointer to cache control structures
+    ;
+        mov     bx,[SECTRACK]
+        mov     cl,9                    ; Mult by 512
+        shl     bx,cl                   ; AX is bytes in Track buffer
+        add     bx,[TRACK_BUFFER_PTR]   ; First byte after track buffer
+        mov     [CACHE_CONTROL_PTR],bx
+        mov     cx,SIZE CACHE_CONTROL
+        mov     ax,[TTRACKS]
+        MUL     cx
+        add     bx,ax
+    ;
+    ; Set TERM_ADDR
+    ;
+        mov     word ptr [TERM_ADDR],bx
+        CLC
+        RET
+
+;**     GETNUM - Read an unsigned integer
+;
+;       This routine looks at DS:SI for a decimal unsigned integer.
+;       It is up to the caller to make sure DS:SI points to the start
+;       of a number. If it is called without DS:SI pointing to a valid
+;       decimal digit the routine will return 0. Any non decimal digit
+;       defines the end of the number and SI is advanced over the
+;       digits which composed the number. Leading "0"s are OK.
+;
+;       THIS ROUTINE DOES NOT CHECK FOR NUMBERS LARGER THAN WILL FIT
+;       IN 16 BITS. If it is passed a pointer to a number larger than
+;       16 bits it will return the low 16 bits of the number.
+;
+;       This routine uses the MUL instruction to multiply the running
+;       number by 10 (initial value is 0) and add the numeric value
+;       of the current digit. Any overflow on the MUL or ADD is ignored.
+;
+;       ENTRY:
+;            DS:SI -> ASCII text of number
+;       EXIT:
+;            BX is binary for number
+;            SI advanced to point to char after number
+;       USES:
+;            AX,BX,DX,SI
+;
+;       COMMON TO TYPE 1, 2, 3, 4 drivers
+;
+
+GETNUM:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+
+        XOR     BX,BX
+GETNUM1:
+        LODSB
+        SUB     AL,"0"
+        JB      NUMRET
+        CMP     AL,9
+        JA      NUMRET
+        CBW
+        XCHG    AX,BX
+        MOV     DX,10
+        MUL     DX
+        ADD     BX,AX
+        JMP     GETNUM1
+
+NUMRET:
+        DEC     SI
+        RET
+
+BREAK   <INITIAL EMM control sector>
+
+;**     flag to signify valid emm control record
+;
+valid_emm   db  0
+
+;**     INITIAL EMM_CTRL sector
+;
+;       This is a datum which represents a correct initial EMM_CTRL
+;       sector as discussed in the EMM_CTRL documentation. It is used
+;       to check for the presense of a valid EMM_CTRL by comparing
+;       the signature strings, and for correctly initializing the
+;       EMM_CTRL sector if needed.
+;
+;       The DWORD at BASE_RESET, which is the EMM_BASE of the NULL
+;       0th EMM_REC structure, is used as a storage location of
+;       the address of the EMM_CTRL sector (PLUS 1024!!!!!!).
+;       This value can be used if it is necessary to re-address the
+;       EMM_CTRL sector during initialization. See the DISK_ABORT routine.
+;       NOTE THAT BASE_RESET CAN NOT BE USED AT RUNTIME AS THIS DATUM
+;       IS NOT PART OF THE RESIDENT IMAGE.
+;
+;       This data is appropriate to TYPE 1 drivers
+;
+
+EMM_CONTROL   LABEL   BYTE
+                DB      "MICROSOFT EMM CTRL VERSION 1.00 CONTROL BLOCK     "
+                DW      0
+                DW      0
+        ; NULL 0th record
+                DW      EMM_ALLOC + EMM_ISDRIVER
+                DW      EMM_EMM
+;; Note:  When using upper extended memory on the PLUS, the value 
+;;        at BASE_RESET + 2 is patched to FA during initialization.
+;;
+BASE_RESET      LABEL   DWORD           ; RESMEM driver must patch this value
+                DW      EXTMEM_LOW + 1024
+                DW      EXTMEM_HIGH
+                DW      0
+
+                DB      950 DUP(0)
+                DB      "ARRARRARRA"
+
+
+BREAK   <INT13 COMMON INIT ROUTINES>
+
+;**     DISK_ABORT - De-install INT13 after init
+;
+;       This routine MUST BE CALLED to de-install a INT13 cache
+;       if the de-installation takes place:
+;
+;               AFTER INT 19/INT 9 vectors are replaced
+;               AFTER ABOVE_PID is valid for TYPE 2
+;               AFTER an EMM_REC structure in the EMM_CTRL sector
+;                       has been marked EMM_ISDRIVER for TYPE 1.
+;
+;       In all cases the INT 9 and INT 19 vectors are replaced if the
+;       value of both words of OLD_19 is NOT -1. This is why the initial value
+;       of this datum is -1. In the event that the INT 9 and INT 19
+;       vectors are replaced, this datum takes on some value other than -1.
+;
+;       If this is a TYPE 1 driver the EMM_ISDRIVER bit is
+;       turned off in the EMM_REC pointed to by MY_EMM_REC.
+;       NOTE THAT A TYPE 1 DRIVER MAY USE THIS ROUTINE
+;       IF IT HAS NOT "TURNED ON" AN EMM_ISDRIVER BIT IN ONE OF THE EMM_REC
+;       STRUCTURES. This is OK because the initial 0 value of MY_EMM_REC
+;       is checked, and nothing is done if it is still 0.
+;
+;       If this is a TYPE 2 driver, an ABOVE_DEALLOC call is made on
+;       ABOVE_PID.
+;
+;       ENTRY:
+;           BASE_RESET valid if TYPE 1
+;           ABOVE_PID valid if TYPE 2
+;       EXIT:
+;           NONE
+;       USES:
+;           ALL but DS
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+
+DISK_ABORT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+
+        CMP     [DRIVER_SEL],1
+        JNZ     NOT_ABOVE
+AGAIN:
+    ;
+    ; TYPE 2, De-alloc the Above Board memory
+    ;
+        MOV     DX,[ABOVE_PID]
+        MOV     AH,ABOVE_DEALLOC
+        INT     67H
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      AGAIN
+        JMP     SHORT RET002
+
+NOT_ABOVE:
+        CMP     [MY_EMM_REC],0                  ; Need to turn off bit?
+        JZ      RET002                          ; No
+    ;
+    ; TYPE 1, turn off EMM_ISDRIVER at MY_EMM_REC
+    ;
+        MOV     AX,WORD PTR [BASE_RESET]
+        MOV     DX,WORD PTR [BASE_RESET + 2]
+        SUB     AX,1024                         ; Backup to EMM_CTRL
+        SBB     DX,0
+        MOV     WORD PTR [BASE_ADDR],AX
+        MOV     WORD PTR [BASE_ADDR + 2],DX
+        XOR     BH,BH                           ; READ
+        CALL    CTRL_IO                         ; Get EMM_CTRL
+        JC      RET002
+        MOV     DI,OFFSET TRACK_BUFFER
+        ADD     DI,[MY_EMM_REC]
+        AND     [DI.EMM_FLAGS],NOT EMM_ISDRIVER     ; Undo install
+        MOV     BH,1            ; WRITE
+        CALL    CTRL_IO         ; EMM_CTRL back out
+RET002:
+    ;
+    ; Reset INT 9, and/or INT 19 if OLD_19 is not -1
+    ;
+        PUSH    DS
+        LDS     DX,[OLD_19]
+ASSUME  DS:NOTHING
+        MOV     AX,DS
+        CMP     AX,-1
+        JNZ     RESET_VECS
+        CMP     AX,DX
+        JZ      NO_VECS
+RESET_VECS:
+        MOV     AX,(Set_Interrupt_Vector SHL 8) OR 19H
+        INT     21H
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; removed from smartdrv
+;       LDS     DX,[OLD_9]
+;       MOV     AX,(Set_Interrupt_Vector SHL 8) OR 9H
+;       INT     21H
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        lds     dx,[old_15]
+        cmp     ax,-1
+        jne     reset_15
+        cmp     ax,dx
+        je      no_vecs
+reset_15:
+        mov     ax,(set_interrupt_vector shl 8) or 15h
+        int     21h
+NO_VECS:
+        POP     DS
+        RET
+
+;**     CTRL_IO - Read/Write the first 1024 bytes at BASE_ADDR
+;
+;       This routine is used at INIT time to read the first 1024
+;       bytes at BASE_ADDR. If TYPE 1 and BASE_ADDR points
+;       to the EMM_CTRL address (initial value), the EMM_CTRL sector
+;       is read/written. If TYPE 1 and BASE_ADDR has been set
+;       to the start of the cache, the first 1024 bytes of the cache
+;       are read/written. If TYPE 2, the first 1024 bytes of
+;       the cache are read/written. All this routine does is
+;       set inputs to BLKMOV to transfer 1024 bytes at offset 0 to/from
+;       TRACK_BUFFER.
+;
+;       ENTRY:
+;            BH = 0 for READ, 1 for WRITE
+;       EXIT:
+;            TRACK_BUFFER filled in with 1024 bytes at BASE_ADDR
+;       USES:
+;            ALL but DS
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+
+CTRL_IO:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        XOR     DX,DX
+        MOV     AX,DX           ; Offset 0
+        MOV     CX,512          ; 1024 bytes
+        PUSH    CS
+        POP     ES
+        MOV     DI,OFFSET TRACK_BUFFER
+        PUSH    DS
+        CALL    BLKMOV          ; Read in EMM_CTRL
+        POP     DS
+        RET
+
+;**     MM_SETDRIVE - Look for/Init EMM_CTRL and DOS volume
+;
+;       This routine is used by TYPE 1 drivers to check for/initialize
+;       the EMM_CTRL sector.
+;
+;       This routine reads the EMM_CTRL sector in to TRACK_BUFFER
+;       CALLS FIND_VDRIVE to check out and alloc or find an EMM_REC
+;       Sets BASE_ADDR to point to the start of the INT13 cache memory
+;       Writes the updated EMM_CTRL back out from TRACK_BUFFER
+;
+;       ENTRY:
+;            BASE_ADDR initialized to point at START of extended memory
+;                    so that the EMM_CTRL sector can be accessed by
+;                    doing I/O at offset 0.
+;            EXT_K is set to size of extended memory
+;            DEV_SIZE is set to user requested device size
+;       EXIT:
+;            CARRY SET - error, message already printed
+;            CARRY CLEAR
+;                    BASE_ADDR set for this drive
+;                    DEV_SIZE set to TRUE size
+;
+;       USES
+;           ALL but DS
+;
+;       Used by TYPE 1 drivers
+;
+
+MM_SETDRIVE:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        XOR     BH,BH           ; READ
+        CALL    CTRL_IO         ; Get EMM_CTRL
+        MOV     DX,OFFSET INIT_IO_ERR
+        JC      ERR_RET2
+        CALL    FIND_VDRIVE     ; Snoop
+        JC      RET001
+        PUSH    ES              ; Save EMM_BASE from EMM_REC
+        PUSH    DI
+; modification sunilp
+        cmp     [u_switch],0    ; we shall use ol' microsoft standard for this
+        je      mm_s$1          ; if we are using int15 scheme no need to write
+                                ; out emm control record
+; end modification sp
+        MOV     BH,1            ; WRITE
+        CALL    CTRL_IO         ; Write EMM_CTRL back out
+        MOV     DX,OFFSET INIT_IO_ERR
+        JC      ERR_RET2P
+mm_s$1:
+        POP     WORD PTR [BASE_ADDR]    ; Set final correct BASE_ADDR
+        POP     WORD PTR [BASE_ADDR + 2]
+        CLC
+RET001:
+        RET
+
+ERR_RET2P:
+        ADD     SP,4
+ERR_RET2:
+        CALL    PRINT
+        STC
+        RET
+
+;**     FIND_VDRIVE - Check out EMM_CTRL and alloc
+;
+;       This code checks for a valid EMM_CTRL and sets up
+;       an initial one if there isn't. It then performs the
+;       algorithm described in the EMM_CTRL documentation
+;       to either allocate a NEW EMM_REC of type EMM_APPLICATION,
+;       or find an existing EMM_REC which is EMM_APPLICATION and has
+;       its EMM_ISDRIVER bit clear. In the later case it
+;       checks to see if DEV_SIZE is consistent with EMM_KSIZE
+;       and tries to make adjustments to EMM_KSIZE or DEV_SIZE
+;       if they are not consistent.
+;
+;       First the EMM_CTRL signature strings are checked.
+;       If they are not valid we go to SETCTRL to set up a new
+;       empty EMM_CTRL in SECTOR_BUFFER.
+;       If the signatures are valid, EMM_TOTALK is checked
+;       against EXT_K. If they are the same, the EMM_CTRL sector is
+;       valid and we skip to SCAN_DEV. Otherwise we initialize the
+;       EMM_CTRL sector at SETCTRL. All we need to do to set up the initial
+;       EMM_CTRL sector is transfer the record at EMM_CONTROL into
+;       TRACK_BUFFER and set EMM_TOTALK and EMM_AVAILK to EXT_K - 1.
+;
+;       In either case, finding a valid EMM_CTRL or setting up a correct
+;       initial one, we end up at SCAN_DEV. This code performs the
+;       scan of the EMM_REC structures looking for a "free" one
+;       or an allocated one which is EMM_APPLICATION and has its EMM_ISDRIVER
+;       bit clear as described in the EMM_CTRL sector documentation.
+;
+;       If we find a "free" EMM_REC structure we go to GOT_FREE_REC
+;       and try to allocate some memory. This attempt will fail if
+;       EMM_AVAILK is less than 16K. We then call SET_RESET to do
+;       the INT 9/INT 19 setup. We adjust DEV_SIZE to equal the
+;       available memory if DEV_SIZE is > EMM_AVAILK. Then all we do
+;       is set EMM_AVAILK and all of the fields in the EMM_REC structure
+;       as described in the EMM_CTRL sector documentation.
+;
+;               Call SET_RESET to do INT 9/INT 19 setup.
+;               IF the EMM_REC structure we found is the LAST EMM_REC structure
+;                   we cannot edit any sizes and whatever the EMM_KSIZE
+;                   is we stuff it into DEV_SIZE and set the EMM_ISDRIVER
+;                   bit, and we're done.
+;                   NOTE: We DO NOT check that EMM_KSIZE is at least
+;                       16K as we know this EMM_REC was created
+;                       by some PREVIOUS INT13 program who
+;                       DID make sure it was at least 16K
+;               ELSE
+;                   IF EMM_KSIZE == DEV_SIZE
+;                       set EMM_ISDRIVER and we're done
+;                   IF EMM_KSIZE < DEV_SIZE
+;                       either the user has edited his DEVICE = line since
+;                       the last time the system was re-booted, or at the
+;                       time we initially allocated this region EMM_AVAILK
+;                       was less than DEV_SIZE and we had to trim the device
+;                       size back.
+;                       This case is handled at INSUFF_MEM.
+;                       IF the next EMM_REC structure is not allocated
+;                           IF EMM_AVAILK == 0
+;                               We can't do anything, so set DEV_SIZE
+;                               to EMM_KSIZE and we're done.
+;                           ELSE
+;                               allocate appropriate amount off of EMM_AVAILK
+;                               and add it to EMM_KSIZE and we're done.
+;                       ELSE
+;                           We can't do anything, so set DEV_SIZE
+;                           to EMM_KSIZE and we're done.
+;                   ELSE
+;                       This is the EMM_KSIZE > DEV_SIZE case, it means the
+;                       user MUST have edited his DEVICE = line.
+;                       IF next EMM_REC is NOT free
+;                               We can't shrink the allocation block,
+;                               but we'll leave DEV_SIZE set to the user
+;                               specification and let him waste memory.
+;                       ELSE
+;                               SHRINK the allocation block by adding
+;                               the extra memory back onto EMM_AVAILK
+;                               and subtracting it from EMM_KSIZE and
+;                               we're done
+;
+;       ENTRY:
+;            SECTOR_BUFFER containes POSSIBLE EMM_CTRL sector
+;                 MUST BE CHECKED
+;            EXT_K is set to size of extended memory
+;            DEV_SIZE is set to user requested device size
+;       EXIT:
+;           CARRY SET
+;               Error, message already printed
+;           CARRY CLEAR
+;               ES:DI = BASE_ADDR for this drive from EMM_BASE of EMM_REC
+;               EMM_REC is marked EMM_ISDRIVER
+;               TRACK_BUFFER must be written out, it contains an updated
+;                        EMM_CTRL sector
+;               DEV_SIZE set to TRUE size
+;               MY_EMM_REC is the offset in the 1k EMM_CTRL sector of the
+;                       record we allocated.
+;
+;       USES:
+;           ALL but DS
+;
+;       Specific to TYPE 1 drivers
+;
+;   substancial modification to this routine, would have totally changed
+;   if it weren't for the olivetti memory
+;
+;   we are going to be int15 guys from now except for the olivetti memory
+;
+FIND_VDRIVE:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        PUSH    CS
+        POP     ES
+        MOV     DI,OFFSET TRACK_BUFFER
+        MOV     SI,OFFSET EMM_CONTROL
+        MOV     CX,50
+        CLD
+        REPE    CMPSB
+        jnz     no_emm_rec
+;       JNZ     SETCTRL                 ; No EMM_CTRL
+        ADD     SI,EMM_TAIL_SIG - 50
+        ADD     DI,EMM_TAIL_SIG - 50
+        MOV     CX,10
+        REPE    CMPSB
+        jnz     no_emm_rec
+;       JNZ     SETCTRL                 ; No EMM_CTRL
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;       with int15 guys around this is not feasible
+;       MOV     DI,OFFSET TRACK_BUFFER
+;       MOV     AX,[EXT_K]
+;       DEC     AX              ; Size in EMM_CTRL doesn't include EMM_CTRL
+;       CMP     AX,[DI.EMM_TOTALK]
+;       JZ      SCAN_DEV                ; EMM_CTRL is valid
+;SETCTRL:
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+;   modification sunilp
+;
+        dec     [valid_emm]             ; signal prescence of emm record
+no_emm_rec:
+        cmp     [u_switch],0h             ; is it a u driver
+        jne     old_st                  ; if not go to install acc to new int15
+        jmp     new_st                  ; standard
+;
+; for olivetti u memory we still have to install according to ol' microsoft st
+;
+old_st:
+        cmp     [valid_emm],0h          ; do we have a valid emm
+        jne     scan_dev                ; if yes go to scan structures
+set_ctrl:                               ; else we have to install a new one
+        MOV     DI,OFFSET TRACK_BUFFER
+        PUSH    DI
+        MOV     SI,OFFSET EMM_CONTROL
+        MOV     CX,1024/2
+        REP     MOVSW           ; Move in initial EMM_CTRL
+        POP     DI
+        MOV     AX,[EXT_K]
+        DEC     AX              ; Size in EMM_CTRL doesn't include EMM_CTRL
+        MOV     [DI.EMM_TOTALK],AX
+        MOV     [DI.EMM_AVAILK],AX
+SCAN_DEV:
+        MOV     SI,OFFSET TRACK_BUFFER ; DS:SI points to EMM_CTRL
+        MOV     DI,SI
+        ADD     DI,EMM_RECORD         ; DS:DI points to EMM records
+        MOV     CX,EMM_NUMREC
+LOOK_REC:
+        TEST    [DI.EMM_FLAGS],EMM_ALLOC
+        JNZ     CHECK_SYS
+        JMP     GOT_FREE_REC            ; Must alloc new region
+
+CHECK_SYS:
+        CMP     [DI.EMM_SYSTEM],EMM_APPLICATION
+        JNZ     NEXTREC                 ; Not correct type
+        TEST    [DI.EMM_FLAGS],EMM_ISDRIVER
+        JNZ     NEXTRECI                ; Driver already in
+        CALL    SET_RESET               ; Set up INT 19,9
+        MOV     AX,[DI.EMM_KSIZE]
+        CMP     CX,1
+        JBE     OK_SET_DEV              ; If this is last record, must
+                                        ;   select this size
+        CMP     AX,[DEV_SIZE]
+        JZ      OK_SET_DEV              ; Exact match, Okay
+        JB      INSUFF_MEM              ; User asked for more
+    ; Size of found block is bigger than requested size.
+    ;   User MUST have edited CONFIG.SYS.
+        PUSH    DI
+        ADD     DI,SIZE EMM_REC
+        TEST    [DI.EMM_FLAGS],EMM_ALLOC
+        POP     DI
+        JZ      SHRINK_BLOCK    ; Next block is free, shrink
+        MOV     AX,[DEV_SIZE]
+        JMP     SHORT SET_2
+
+SHRINK_BLOCK:
+        SUB     AX,[DEV_SIZE]   ; AX is amount to shrink
+        ADD     [SI.EMM_AVAILK],AX
+        MOV     AX,[DEV_SIZE]
+        MOV     [DI.EMM_KSIZE],AX
+        JMP     SHORT SET_2
+
+INSUFF_MEM:                     ; Size of found block is smaller
+                                ;   than requested size.
+        PUSH    DI
+        ADD     DI,SIZE EMM_REC
+        TEST    [DI.EMM_FLAGS],EMM_ALLOC
+        POP     DI
+        JNZ     OK_SET_DEV      ; Next block is NOT free, can't grow
+TRY_TO_GROW_BLOCK:
+        CMP     [SI.EMM_AVAILK],0
+        JZ      OK_SET_DEV      ; Need SPECIAL check for this case
+        SUB     AX,[DEV_SIZE]
+        NEG     AX              ; AX is amount we would like to grow
+        SUB     [SI.EMM_AVAILK],AX
+        JNC     GOT_THE_MEM
+        ADD     AX,[SI.EMM_AVAILK]    ; AX is MAX we can grow
+        MOV     [SI.EMM_AVAILK],0     ; We take all that's left
+GOT_THE_MEM:
+        ADD     [DI.EMM_KSIZE],AX
+        MOV     AX,[DI.EMM_KSIZE]
+SET_2:
+OK_SET_DEV:
+        MOV     [DEV_SIZE],AX
+        OR      [DI.EMM_FLAGS],EMM_ISDRIVER
+        MOV     [MY_EMM_REC],DI
+        SUB     [MY_EMM_REC],OFFSET TRACK_BUFFER  ; Make start of EMM_CTRL relative
+        LES     DI,[DI.EMM_BASE]
+        XOR     AX,AX                   ; Set zero, clear carry
+        RET
+
+NEXTRECI:
+NEXTREC:
+        ADD     DI,SIZE EMM_REC       ; Next record
+        LOOP    LOOK_RECJ
+VERROR:
+        MOV     DX,OFFSET ERRMSG2
+        CALL    PRINT
+        STC
+        RET
+
+LOOK_RECJ:
+        JMP     LOOK_REC
+
+GOT_FREE_REC:
+        MOV     AX,[SI.EMM_AVAILK]
+        CMP     AX,16
+        JB      VERROR                  ; 16K is smallest device
+        CALL    SET_RESET               ; Set INT 19,9
+        CMP     AX,[DEV_SIZE]
+        JBE     GOTSIZE                 ; Not enough for user spec
+        MOV     AX,[DEV_SIZE]           ; User size is OK
+GOTSIZE:
+        MOV     [DEV_SIZE],AX
+        SUB     [SI.EMM_AVAILK],AX
+        MOV     [DI.EMM_KSIZE],AX
+        MOV     [DI.EMM_SYSTEM],EMM_APPLICATION
+        MOV     [DI.EMM_FLAGS],EMM_ALLOC + EMM_ISDRIVER
+        MOV     [MY_EMM_REC],DI
+        SUB     [MY_EMM_REC],OFFSET TRACK_BUFFER  ; Make start of EMM_CTRL relative
+        PUSH    DI
+        SUB     DI,SIZE EMM_REC       ; Look at prev record to compute base
+        MOV     AX,[DI.EMM_KSIZE]
+        LES     BX,[DI.EMM_BASE]
+        MOV     DI,ES                   ; DI:BX is prev base
+        MOV     CX,1024
+        MUL     CX                      ; Mult size by 1024 to get # bytes
+        ADD     AX,BX                   ; Add size onto base to get next base
+        ADC     DX,DI
+        POP     DI
+        MOV     WORD PTR [DI.EMM_BASE],AX
+        MOV     WORD PTR [DI.EMM_BASE + 2],DX
+        LES     DI,[DI.EMM_BASE]
+        XOR     AX,AX                   ; Set zero, clear carry
+        INC     AX                      ; RESET zero
+        RET
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; the new int15 standard
+;
+new_st:
+        mov     bx,[ext_k]              ; contiguous memory reported by int15
+        cmp     [valid_emm],0           ; is there a valid emm record
+        je      no_adjust               ; if not there no need to adjust
+                                        ; the memory available
+; else we have to find how much memory is already allocated by the microsoft
+; emm control block and subtract this from the amount that is available. the
+; memory allocated is totalk - availk + 1
+;
+        sub     bx,1                    ; subtract the emm ctrl record size
+        mov     di,offset track_buffer  ; set up to address the ctrl record
+                                        ; read in
+        mov     ax,[di.emm_totalk]      ; ax <- totalk
+        sub     ax,[di.emm_availk]      ; ax <- totalk - availk
+        sub     bx,ax                   ; adjust memory available
+        jc      verror                  ; if no memory go to abort
+;
+        cmp     bx,128                  ; is it the minimum required
+        jb      verror                  ; if less go to abort
+;
+; the memory available has been found and is in bx. now compare it with
+; requested device size and take the minimum of the two
+;
+no_adjust:
+        cmp     [dev_size],bx           ;
+        jb      skip_adj_dev_size       ; if enough space we don't need to adj
+                                        ; dev_size
+        mov     [dev_size],bx           ; else we have compromise on dev size
+skip_adj_dev_size:
+;
+; now that we have the correct dev size we should proceed with the installation
+; of a new int 15 handler which will account for the memory grabbed by this guy
+;
+        mov     bx,[ext_k]              ; get memory which was reported by int15
+        add     bx,[special_mem]        ; account for olivetti guys
+        sub     bx,[dev_size]           ;
+        mov     [int15_size],bx         ; this is the size thaat will be reported
+                                        ; by the int 15 handler
+; now install the int15 handler
+;
+        push    ax
+        push    dx
+        push    bx
+        push    es
+        mov     ax,(get_interrupt_vector shl 8) or 15h
+        int     21h
+        mov     word ptr [old_15],bx
+        mov     word ptr [old_15+2],es
+        mov     dx,offset int_15
+        mov     ax,(set_interrupt_vector shl 8) or 15h
+        int     21h
+        pop     es
+        pop     bx
+        pop     dx
+        pop     ax
+;
+;       set up int19 vector
+;
+        call    set_reset
+;
+;       now fill device base address in es:di
+;
+        mov     ax,[ext_k]
+        sub     ax,[dev_size]       ; this now has memory left
+        mov     cx,1024             ; we are going to find size in bytes
+        mul     cx                  ; dx:ax = ax * 1024
+        add     ax,word ptr [base_addr]      ;
+        adc     dx,word ptr [base_addr+2]    ;
+        mov     es,dx               ;
+        mov     di,ax               ;
+        ret
+
+;**     SET_RESET - Set up INT 19/INT 9 vectors
+;
+;       This routine will install the INT 9 and INT 19
+;       code by saving the current INT 9 and INT 19
+;       vectors in OLD_9 and OLD_19 (NOTE: the change in the value of OLD_19
+;       to something other than -1 indicates that the vectors have been
+;       replaced), setting the vectors to point to INT_9 and INT_19.
+;
+;       ENTRY:
+;            NONE
+;       EXIT:
+;            NONE
+;       USES:
+;            None
+;
+;       COMMON TO TYPE 1, 2 drivers
+;
+
+SET_RESET:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        cmp     U_SWITCH,0              ;; don't do this for at&t 6300 plus
+        jnz     ret005
+        PUSH    AX
+        PUSH    DX
+        PUSH    BX
+        PUSH    ES
+        MOV     AX,(Get_Interrupt_Vector SHL 8) OR 19H
+        INT     21H
+        MOV     WORD PTR [OLD_19],BX
+        MOV     WORD PTR [OLD_19 + 2],ES
+        MOV     DX,OFFSET INT_19
+        MOV     AX,(Set_Interrupt_Vector SHL 8) OR 19H
+        INT     21H
+        MOV     AX,(Get_Interrupt_Vector SHL 8) OR 9H
+        INT     21H
+        MOV     WORD PTR [OLD_9],BX
+        MOV     WORD PTR [OLD_9 + 2],ES
+;       MOV     DX,OFFSET INT_9
+;       MOV     AX,(Set_Interrupt_Vector SHL 8) OR 9H
+;       INT     21H
+        POP     ES
+        POP     BX
+        POP     DX
+        POP     AX
+RET005:
+        RET
+
+BREAK   </E INIT Code>
+
+;**     AT_EXT_INIT - Perform /E (TYPE 1) specific initialization
+;
+;       This code does the drive TYPE specific initialization for TYPE 1
+;       drivers.
+;
+;       Make sure running on 80286 IBM PC-AT compatible system by
+;               making sure the model byte at FFFF:000E is FC.
+;       Get the size of extended memory by using 8800H call to INT 15.
+;               and make sure it is big enough to accomodate thr driver.
+;       Limit DEV_SIZE to the available memory found in the previous step
+;               by making DEV_SIZE smaller if necessary.
+;       Initialize the GLOBAL parts of the LOADALL information which
+;               are not set by each call to BLKMOV.
+;       CALL MM_SETDRIVE to look for EMM_CTRL and perform all the
+;               other initialization tasks.
+;       Call DRIVEPARMS to set TERM_ADDR and other drive specific cache parms
+;
+;       ENTRY:
+;           Invokation line parameter values set.
+;       EXIT:
+;           CARRY SET
+;               Error, message already printed. Driver not installed.
+;                       EMM_CTRL not marked (but MAY be initialized if
+;                       a valid one was not found).
+;           CARRY CLEAR
+;               BASE_ADDR set for this drive from EMM_BASE of EMM_REC
+;               BASE_RESET set from BASE_ADDR
+;               TERM_ADDR set
+;               EMM_REC is marked EMM_ISDRIVER
+;               MY_EMM_REC set
+;               DEV_SIZE set to TRUE size
+;               RESET_SYSTEM code and INT 9/INT 19 code included,
+;               INT 19 and 9 vector patched.
+;
+;       USES:
+;           ALL but DS
+;
+;       Code is specific to TYPE 1 driver
+;
+
+AT_EXT_INIT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+        push    ds
+        call    sys_det         ; new routine to do more comprehensive
+        pop     ds
+        jnc     at001           ; checks than before
+        MOV     DX,OFFSET BAD_AT
+ERR_RET:
+        CALL    PRINT
+        STC
+        RET
+
+AT001:
+
+;; If upper extended memory is used on the PLUS, it is necessary to
+;; patch the values of base_reset and base_addr to get the addressing right.
+;;
+        cmp     [U_SWITCH],0            ;; patch the code for /U option
+        jz      AT001A
+        mov     ax,00fah
+        mov     word ptr [emm_ctrl_addr+2],ax   ;; in resident part for reset code
+        mov     word ptr [base_reset+2],ax      ;; patching upper address
+        mov     word ptr [base_addr+2],ax       ;;   to FA from 10
+AT001A:
+        MOV     AX,8800H
+        INT     15H                     ; Get extended memory size
+        MOV     DX,OFFSET NO_MEM
+        OR      AX,AX
+        JZ      ERR_RET
+
+;; If running on a 6300 PLUS, it is necessary to subtract any upper extended
+;; memory from the value obtained by int 15 to determine the correct memory
+;; available for a type /E RAMDrive.  If loading a /U RAMDrive, it is necessary
+;; to find out if there IS any upper extended memory.
+
+        cmp     [U_SWITCH],0            ;; did we ask for upper extended memory
+        jz      olstuff                 ;; no
+        call    UpperMemCheck           ;; yes, see if anything there
+        jc      ERR_RET                 ;; no, quit
+        mov     ax,384                  ;; yes, but max allowed is 384K
+        jmp short at001b
+olstuff:
+        cmp     [S5_FLAG],S_OLIVETTI    ;; if not 6300 PLUS, go on
+        jne     at001b
+        call    UpperMemCheck           ;; yes, see if 384K is there
+        jc      at001b                  ;; no, so int 15h is right
+        sub     ax,384                  ;; yes, subtract 384K
+        mov     [special_mem],384       ;; store special memory size
+AT001B:
+
+        MOV     DX,OFFSET ERRMSG2
+        CMP     AX,128          ; 128k min cache
+        JB      ERR_RET
+        MOV     [EXT_K],AX
+        MOV     BX,AX
+;       DEC     BX              ; BX is MAX possible cache size
+        CMP     [DEV_SIZE],BX
+        JBE     AT002           ; DEV_SIZE OK
+        MOV     [DEV_SIZE],BX   ; Limit DEV_SIZE to available
+AT002:
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 386 modification
+        test    [sys_flg],M_386
+        je      loadall_setup
+        mov     ax,cs
+        mov     word ptr [cod_seg],ax
+; set cs descriptor
+        mov     cx,16
+        mul     cx
+        mov     si,offset cs_des
+        mov     [si].bas_0_15,ax
+        mov     [si].bas_16_23,dl
+        mov     [si].bas_24_31,dh
+; set gdt base
+        mov     si,offset emm_gdt
+        add     ax,offset start_gdt
+        adc     dx,0
+        mov     [si].gdt_base_0,ax
+        mov     [si].gdt_base_2,dx
+        jmp     short common_setup
+    ;
+    ; Init various pieces of LOADALL info
+    ;
+;;;;        SMSW    [LDSW]
+;;;;        SIDT    QWORD PTR [IDTDES]
+;;;;        SGDT    QWORD PTR [GDTDES]
+;;;;    ;
+;;;;    ; NOW The damn SXXX instructions store the desriptors in a
+;;;;    ;     different order than LOADALL wants
+;;;;    ;
+;;;;        MOV     SI,OFFSET IDTDES
+;;;;        CALL    FIX_DESCRIPTOR
+;;;;        MOV     SI,OFFSET GDTDES
+;;;;        CALL    FIX_DESCRIPTOR
+loadall_setup:
+        MOV     [LCSS],CS
+        MOV     SI,OFFSET CSDES
+        MOV     AX,CS
+        CALL    SEG_SET
+common_setup:
+        CALL    MM_SETDRIVE
+        JC      RETXXX
+        CALL    DRIVEPARMS
+        JNC     RETXXX
+        CALL    DISK_ABORT
+        STC
+RETXXX:
+        RET
+
+;;* UpperMemCheck - Called by 6300 PLUS to verify existence of
+;;                  upper extended memory of 384K at FA0000h
+;;
+;;      Returns carry set if no upper extended memory.
+;;
+;;      This routine is called only by a 6300 PLUS, and
+;;      it reads the hardware switch DSW2 to do the job.
+;;
+UpperMemCheck:
+        push    ax
+        in      al,66h
+        and     al,00001111b
+        cmp     al,00001011b
+        pop     ax
+        jnz     nomem
+        clc
+        ret
+nomem:
+        stc
+        ret
+
+BREAK   </A INIT Code>
+
+;**     EMM device driver name
+;
+;       The following datum defines the Above Board EMM 8 character
+;       device driver name that is looked for as part of TYPE 2
+;       specific initialization.
+;
+;       This datum is specific to TYPE 2 drivers
+;
+
+ABOVE_DEV_NAME  DB      "EMMXXXX0"
+
+;**     ABOVE_INIT - Perform /A (TYPE 2) specific initialization
+;
+;       This code performes the driver specific initialization for
+;       type 2 drivers.
+;
+;       Swap ABOVE_BLKMOV code in for TYPE 1 code at BLKMOV
+;       Swap ABOVE_RESET code in for TYPE 1 code at RESET_SYSTEM
+;       Check to make sure EMM Above Board device driver is installed
+;               by looking for device name relative to INT 67H segment
+;               address. This is method 2 described on page 36 and 37
+;               of the Expanded Memory Manager Programming Specification.
+;
+;               WARNING! If run on a version of DOS where all INT vectors
+;               are managed by the kernel, or on a system where some
+;               foreign program (not EMM.SYS) is also using INT 67H, this
+;               method will fail to find the EMM device driver.
+;               The reason this method was used rather than the more portable
+;               method 1 described on pages 33 and 34 of the EMM Programming
+;               Specification is that the DOS Installable Device Driver
+;               document makes a statement about which DOS system calls
+;               may be made in a device initialization routine, and
+;               OPEN, IOCTL, and CLOSE are not included in the allowed
+;               set. Adherance to the Installable Device Driver document,
+;               therefore, excludes the use of method 1.
+;
+;       Check the EMM device status
+;       Get the EMM map window address and set BASE_ADDR
+;       Get the available Above Board memory
+;       Adjust DEV_SIZE to be consistent with the available memory if needed,
+;               and also round DEV_SIZE up so that it is a multiple of the 16K
+;               granularity of the Above Board memory.
+;       Allocate DEV_SIZE worth of Above Board memory and set ABOVE_PID.
+;               After this point we can use CTRL_IO and/or BLKMOV to
+;               read/write the memory we have allocated.
+;       Install the INT 9 and INT 19 code by calling SET_RESET.
+;       Call DRIVEPARMS to set TERM_ADDR and other drive specific cache parms
+;
+;       SEE ALSO
+;           INTEL Expanded Memory Manager Programming Specification
+;
+;       ENTRY:
+;           Invokation line parameter values set.
+;       EXIT:
+;           ABOVE_BLKMOV code swapped in at BLKMOV
+;           ABOVE_RESET code swapped in at RESET_SYSTEM
+;           CARRY SET
+;               Error, message already printed. Driver not installed.
+;                       No Above Board memory allocated.
+;           CARRY CLEAR
+;               BASE_ADDR set to segment address of Above Board map window
+;               ABOVE_PID contains PID of allocated above board memory
+;               DEV_SIZE set to TRUE size
+;               TERM_ADDR set
+;
+;       USES:
+;           ALL but DS
+;
+;       Code is specific to TYPE 2 driver
+;
+
+ABOVE_INIT:
+ASSUME  DS:INT13CODE,ES:NOTHING,SS:NOTHING
+    ;
+    ; Swap above code into place
+    ;
+        PUSH    CS
+        POP     ES
+        MOV     SI,OFFSET ABOVE_CODE
+        MOV     DI,OFFSET DRIVE_CODE
+        MOV     CX,OFFSET DRIVE_END - OFFSET DRIVE_CODE
+        REP     MOVSB
+        MOV     SI,OFFSET ABOVE_RESET
+        MOV     DI,OFFSET RESET_SYSTEM
+        MOV     CX,OFFSET RESET_INCLUDE - OFFSET RESET_SYSTEM
+        REP     MOVSB
+    ;
+    ; Check for presence of Above board memory manager
+    ;
+        MOV     AX,(Get_Interrupt_Vector SHL 8) OR 67H
+        INT     21H
+        MOV     DI,SDEVNAME
+        MOV     SI,OFFSET ABOVE_DEV_NAME
+        MOV     CX,8
+        REPE    CMPSB
+        JZ      GOT_MANAGER
+        MOV     DX,OFFSET NO_ABOVE
+ABOVE_ERR:
+        CALL    PRINT
+        STC
+        RET
+
+GOT_MANAGER:
+    ;
+    ; Check memory status
+    ;
+        MOV     CX,8000H
+STLOOP:
+        MOV     AH,ABOVE_STATUS
+        INT     67H
+        CMP     AH,ABOVE_SUCCESSFUL
+        JZ      MEM_OK
+        CMP     AH,ABOVE_ERROR_BUSY
+        LOOPZ   STLOOP
+ST_ERR:
+        MOV     DX,OFFSET BAD_ABOVE
+        JMP     ABOVE_ERR
+
+MEM_OK:
+    ;
+    ; Get base address of map region and set BASE_ADDR
+    ;
+        MOV     AH,ABOVE_GET_SEG
+        INT     67H
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      MEM_OK
+        CMP     AH,ABOVE_SUCCESSFUL
+        JNZ     ST_ERR
+        MOV     WORD PTR [BASE_ADDR],0
+        MOV     WORD PTR [BASE_ADDR + 2],BX
+    ;
+    ; Allocate drive memory
+    ;
+GET_AVAIL:
+        MOV     AH,ABOVE_GET_FREE
+        INT     67H
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      GET_AVAIL
+        CMP     AH,ABOVE_SUCCESSFUL
+        JNZ     ST_ERR
+        MOV     AX,DX           ; AX is total 16K pages
+                                ; BX is un-allocated 16K pages
+        MOV     DX,OFFSET NO_MEM
+        OR      AX,AX
+        JZ      ABOVE_ERR
+        MOV     DX,OFFSET ERRMSG2
+;
+;   change in allocation strategy new default is all of available pages
+;   < 8192K.
+;
+;   algorithm:      if (free_pages < 8) then    error();
+;                   else {
+;                       if (free_pages >  200h) then free_pages = 200h;
+;                       if (num_arg == 1) then dev_size = free_pages;
+;                       else dev_size = min (dev_size,free_pages)
+
+
+
+        CMP     BX,8            ; 128K = 16K * 8 = Min cache size
+        JB      ABOVE_ERR
+        cmp     bx,0200h        ; 8192K = Max cache size
+        jbe     ab0$1           ; if less  or equal fine
+        mov     bx,0200h        ; else limit it to 8192K
+ab0$1:
+        mov     cx,4            ; to convert number of pages into no of k
+        shl     bx,cl
+        cmp     [num_arg],1     ; is numeric argument 1 ( means none )
+        jne     ab0$2           ; cache size has been requested
+        mov     [dev_size],bx   ; else use all of available cache
+        jmp     short ab001     ;
+ab0$2:
+        cmp     [dev_size],bx   ; minimum of dev size and bx
+        jb      ab001
+        mov     [dev_size],bx   ;
+
+
+ab001:
+        mov     bx,[dev_size]
+        mov     [current_dev_size],bx ; Initialize current device size
+    ;
+    ; BX is K we want to allocate (limited by available K)
+    ;  BX is at least 16
+    ;
+        MOV     AX,BX
+        MOV     CX,4            ; Convert back to # of 16K pages
+        SHR     BX,CL
+        TEST    AX,0FH          ; Even????
+        JZ      OKAYU           ; Yes
+        INC     BX              ; Gotta round up
+        PUSH    BX
+        MOV     CX,4
+        SHL     BX,CL
+        MOV     [DEV_SIZE],BX   ; Correct dev size too by rounding it up to
+                                ;   next multiple of 16K, no sense wasting
+                                ;   part of a page.
+;A
+        mov     [current_dev_size],bx ; Correct current device size also
+;A
+        POP     BX
+OKAYU:
+        MOV     AH,ABOVE_ALLOC
+        INT     67H
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      OKAYU
+        CMP     AH,ABOVE_SUCCESSFUL
+        JZ      GOT_ID
+        CMP     AH,ABOVE_ERROR_MAP_CNTXT
+        JZ      ST_ERRJ
+        CMP     AH,ABOVE_ERROR_OUT_OF_PIDS
+        JB      ST_ERRJ
+        MOV     DX,OFFSET ERRMSG2
+        JMP     ABOVE_ERR
+
+ST_ERRJ:
+        JMP     ST_ERR
+
+GOT_ID:
+        MOV     [ABOVE_PID],DX
+    ;
+    ; INSTALL ABOVE RESET handler
+    ;
+        CALL    SET_RESET
+    ;
+    ; We are now in good shape.
+    ;
+        CALL    DRIVEPARMS
+        JNC     RETYYY
+        CALL    DISK_ABORT
+        STC
+RETYYY:
+        RET
+
+BREAK   <Drive code for /A driver. Swapped in at BLKMOV>
+
+;
+; This label defines the start of the code swapped in at DRIVE_CODE
+;
+ABOVE_CODE      LABEL   WORD
+
+;
+; WARNING DANGER!!!!!!!
+;
+; This code is tranfered over the /E driver code at DRIVE_CODE
+;
+; ALL jmps etc. must be IP relative.
+; ALL data references must be to cells at the FINAL, TRUE location
+;       (no data cells may be named HERE, must be named up at BLKMOV).
+; OFFSET of ABOVE_BLKMOV relative to ABOVE_CODE MUST be the same as
+;       the OFFSET of BLKMOV relative to DRIVE_CODE.
+; SIZE of stuff between ABOVE_CODE and ABOVE_END MUST be less than
+;       or equal to size of stuff between DRIVE_CODE and DRIVE_END.
+
+IF2
+  IF((OFFSET ABOVE_BLKMOV - OFFSET ABOVE_CODE) NE (OFFSET BLKMOV - OFFSET DRIVE_CODE))
+          %out ERROR BLKMOV, ABOVE_BLKMOV NOT ALIGNED
+  ENDIF
+  IF((OFFSET ABOVE_END - OFFSET ABOVE_CODE) GT (OFFSET DRIVE_END - OFFSET DRIVE_CODE))
+          %out ERROR ABOVE CODE TOO BIG
+  ENDIF
+ENDIF
+
+                DD      ?       ; 24 bit address of start of this RAMDRV
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;**     ABOVE_BLKMOV - Perform transfer for TYPE 2 driver
+;
+;       This routine is the transfer routine for moving bytes
+;       to and from the Above Board memory containing the cache.
+;
+;       The Above Board is implemented as 4 16K windows into the Above
+;       Board memory, giving a total window of 64K wich starts on some
+;       16K boundary of the Above Board memory. Given that a DOS I/O
+;       request is up to 64K bytes starting on some sector boundary,
+;       the most general I/O picture is:
+;
+;       |------------|------------|------------|------------|------------|
+;       | Above Brd  | Above Brd  | Above Brd  | Above Brd  | Above Brd  |
+;       |Log page n  |Log page n+1|Log page n+2|log page n+3|Log page n+4|
+;       |------------|------------|------------|------------|------------|
+;       |---|---|                                           |       |
+;       |   |   |---------------- 64K bytes of sectors -------------|
+;          Byte |                                           |       |
+;         offset|------------------|------------------------|       |
+;       of first|              Number of words in           |       |
+;       byte of |              first part of I/O that       |---|---|
+;       I/O in  |              can be performed once          Number
+;       first   |              logical pages n - n+3          of words
+;       Log page|              are mapped into physical       in tail
+;               |              pages 0 - 3                    part of I/O
+;            Location of                                      that have
+;            first byte                                       to be done
+;            of sector M,                                     once logical
+;            the start sector                                 page n+4 is
+;            of the I/O                                       mapped into
+;                                                             physical page
+;                                                             0
+;
+; One or both of "Byte offset of first byte of I/O in first page" and
+; "Number of words in tail part of I/O" may be zero depending on the
+; size of the I/O and its start offset in the first logical page it is
+; possible to map.
+;
+; WARNING: IF A PRE-EMPTIVE MULTITASKING SYSTEM SCHEDULES A TASK WHICH
+;       IS USING THE ABOVE BOARD DURING THE TIME THIS DRIVER IS IN THE
+;       MIDDLE OF PERFORMING AN I/O, THE SYSTEM HAD BETTER MANAGE THE A
+;       BOARD MAPPING CONTEXT CORRECTLY OR ALL SORTS OF STRANGE UNPLEASANT
+;       THINGS WILL OCCUR.
+;
+;       SEE ALSO
+;           INTEL Expanded Memory Manager Programming Specification
+;
+;       ENTRY:
+;           ES:DI is packet transfer address.
+;           CX is number of words to transfer.
+;           DX:AX is 32 bit start byte offset (0 = start of cache)
+;           BH is 1 for WRITE, 0 for READ
+;
+;           BASE_ADDR set to point to Above Board mapping window in main memory
+;               This "input" is not the responsibility of the caller. It
+;               is up to the initialization code to set it up when the
+;               device is installed
+;
+;       EXIT:
+;           Carry Clear
+;                   OK, operation performed successfully
+;           Carry Set
+;                   Error during operation, AL is error number
+;
+;       USES:
+;           ALL
+;
+;       This routine is specific to TYPE 2 driver
+;
+above_blkmov:
+assume ds:int13code,es:nothing,ss:nothing
+;
+;       save mapping context and return with error if save fails
+;
+        save_mapping_context
+        jnc     ab_blk$1
+        ret
+;
+;       find logical page number, offset of i/o in first page
+;
+ab_blk$1:
+        push    cx
+        mov     cx,1024*16      ; 16k bytes / page
+        div     cx              ; dx:ax / 16k --> log page numb in ax
+                                ;             --> offset of i/o in dx
+        mov     si,dx           ; transfer offset to si
+        mov     dx,ax           ; store the page number in dx
+        pop     cx
+;
+;       find case and dispatch accordingly
+;
+;       case 0 : user buffer below page map, can use aaron's code
+;       case 1 : user buffer above page map, can use aaron's code
+;       case 2 : user buffer totally within page map, use pai's code
+;       case 3 : user buffer partly in page map partly below, error
+;       case 4 : user buffer partly in page map partly above, error
+;
+        push    bx
+        push    cx
+;
+;       if( final_user_off < pm_base_addr ) then case 0
+;
+        mov     ax,di           ; get user buffer initial offset into ax
+        shr     ax,1            ; convert to word offset
+        dec     cx              ; convert word count to 0 based number
+        add     ax,cx           ; user buffer final word offset
+        shr     ax,1            ; convert to segment
+        shr     ax,1            ;
+        shr     ax,1            ;
+        mov     bx,es           ; get segment of buffer
+        add     ax,bx           ; now we have the segment of the user buffer
+                                ; with offset < 16
+        sub     ax,word ptr [base_addr+2] ; compare against page map
+        jc      aar_cd          ; if below page map then execute old code
+;
+;       if( initial_user_off < pm_base_addr ) then error
+;       
+        mov     cx,4
+        mov     bp,di           ; get initial offset in bp
+        shr     bp,cl           ;
+        add     bp,bx           ;
+        sub     bp,word ptr [base_addr +2]
+        jc      ab_error        ;
+;
+;       if ( initial_user_off >= pm_end_addr ) then case1
+;
+        cmp     bp,4*1024       ;
+        jae     aar_cd          ;
+;
+;       if ( final_addr >= pm_end_addr ) then error
+;
+        cmp     ax,4*1024
+        jae     ab_error
+;
+;       case 2
+;
+within_pm:      jmp     new_code        ; user buffer in page map
+                                        ; so we need to execute new code
+ab_error:
+        add     sp,4
+        mov     al,0bbh                 ; general failure
+        stc
+        jmp     short REST_CONT         ; RESTORE CONTEXT!!!
+aar_cd:
+        pop     cx
+        pop     bx
+;       
+; Referring back to the diagram given above the following routine is
+; to take care of transfer of the most general case.
+; What this routine does is break every I/O down into the above parts.
+; The first or main part of the I/O is performed by mapping 1 to 4
+; sequential logical pages into the 4 physical pages and executing one
+; REP MOVSW. If the tail word count is non-zero then the fith sequential
+; logical page is mapped into physical page 0 and another REP MOVSW is
+; executed.
+;
+;       METHOD:
+;           Break I/O down as described above into main piece and tail piece
+;           Map the appropriate number of sequential pages (up to 4)
+;             into the page window at BASE_ADDR to set up the main piece
+;             of the I/O.
+;          Set appropriate seg and index registers and CX to perform the
+;             main piece of the I/O into the page window
+;          REP MOVSW
+;          IF there is a tail piece
+;               Map the next logical page into physical page 0
+;               Reset the appropriate index register to point at phsical page 0
+;               Move tail piece word count into CX
+;               REP MOVSW
+;          Restore Above Board page mapping context
+;
+        XOR     BP,BP           ; No tail page
+        PUSH    BX
+    ;
+    ; DX is first page #, SI is byte offset of start of I/O in first page
+    ;
+        MOV     AX,DX
+        MOV     BX,SI
+        SHR     BX,1            ; # Words in first 16k page which are not part
+                                ;       of I/O
+        PUSH    CX
+        ADD     BX,CX           ; # of words we need to map to perform I/O
+        MOV     DX,BX
+        AND     DX,1FFFH        ; DX is number of words to transfer last page
+                                ;    remainder of div by words in 16K bytes
+        MOV     CL,13           ; Div by # words in 16K
+        SHR     BX,CL           ; BX is number of pages to map (may need round up)
+        OR      DX,DX           ; Remainder?
+        JZ      NO_REM
+        INC     BX              ; Need one more page
+NO_REM:
+        MOV     CX,BX           ; CX is total pages we need to map
+        MOV     BX,AX           ; BX is first logical page
+        CMP     CX,4            ; We can map up to 4 pages
+        JBE     NO_TAIL
+        MOV     BP,DX           ; Words to move in tail page saved in BP
+        DEC     CX              ; Need second map for the 5th page
+        POP     AX
+        SUB     AX,DX           ; Words to move in first 4 pages is input
+                                ;   word count minus words in tail page
+        PUSH    AX              ; Count for first mapping back on stack
+NO_TAIL:
+    ; Map CX pages
+        MOV     DX,[ABOVE_PID]
+        MOV     AX,ABOVE_MAP SHL 8 ; Physical page 0
+        PUSH    AX
+MAP_NEXT:
+        POP     AX              ; Recover correct AX register
+        PUSH    AX
+        PUSH    BX
+        PUSH    DX
+        INT     67H             ; Damn call ABOVE_MAP zaps BX,DX,AX
+        POP     DX
+        POP     BX
+        OR      AH,AH
+        JNZ     MAP_ERR1        ; error
+IF2
+        IF (ABOVE_SUCCESSFUL)
+                %out ASSUMPTION IN CODE THAT ABOVE_SUCCESSFUL = 0 IS INVALID
+        ENDIF
+ENDIF
+NEXT_PAGE:
+        INC     BX              ; Next logical page
+        POP     AX
+        INC     AL              ; Next physical page
+        PUSH    AX
+        LOOP    MAP_NEXT
+        POP     AX              ; Clean stack
+        POP     CX              ; Word count for first page mapping
+        POP     AX              ; Operation in AH
+    ;
+    ; BX has # of next logical page (Tail page if BP is non-zero)
+    ; BP has # of words to move in tail page (0 if no tail)
+    ; CX has # of words to move in current mapping
+    ; SI is offset into current mapping of start of I/O
+    ; AH indicates READ or WRITE
+    ;
+        PUSH    AX              ; Save op for possible second I/O
+        OR      AH,AH
+        JZ      READ_A
+    ;
+    ; WRITE
+    ;
+        PUSH    ES
+        PUSH    DI
+        MOV     DI,SI           ; Start page offset to DI
+        POP     SI              ; DS:SI is transfer addr
+        POP     DS
+ASSUME  DS:NOTHING
+        MOV     ES,WORD PTR [BASE_ADDR + 2] ; ES:DI -> start
+        JMP     SHORT FIRST_MOVE
+
+READ_A:
+ASSUME  DS:INT13CODE
+        MOV     DS,WORD PTR [BASE_ADDR + 2]     ; DS:SI -> start
+ASSUME  DS:NOTHING
+FIRST_MOVE:
+        REP     MOVSW
+        OR      BP,BP           ; Tail?
+        JNZ     TAIL_IO         ; Yup
+ALL_DONE:
+        POP     AX
+        CLC
+REST_CONT:
+    ; Restore page mapping context
+        PUSH    AX              ; Save possible error code
+        PUSHF                   ; And carry state
+REST_AGN:
+        MOV     DX,[ABOVE_PID]
+        MOV     AH,ABOVE_RESTORE_MAP_PID
+        INT     67H
+        OR      AH,AH
+        JZ      ROK
+IF2
+        IF (ABOVE_SUCCESSFUL)
+                %out ASSUMPTION IN CODE THAT ABOVE_SUCCESSFUL = 0 IS INVALID
+        ENDIF
+ENDIF
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      REST_AGN
+        CMP     AH,ABOVE_ERROR_NO_CNTXT
+        JZ      ROK             ; Ignore the invalid PID error
+        POP     DX
+        POP     DX              ; Clean stack
+        MOV     AL,0BBH         ; General failure
+        STC
+        RET
+
+ROK:
+        POPF                    ; Recover carry state
+        POP     AX              ; and possible error code
+        RET
+
+TAIL_IO:
+        MOV     DX,[ABOVE_PID]
+MAP_AGN:
+        MOV     AX,ABOVE_MAP SHL 8 ; map logical page BX to phys page 0
+        PUSH    BX
+        PUSH    DX
+        INT     67H             ; Damn call ABOVE_MAP zaps BX,DX,AX
+        POP     DX
+        POP     BX
+        OR      AH,AH
+        JNZ     MAP_ERR2        ; Error
+IF2
+        IF (ABOVE_SUCCESSFUL)
+                %out ASSUMPTION IN CODE THAT ABOVE_SUCCESSFUL = 0 IS INVALID
+        ENDIF
+ENDIF
+SECOND_MOVE:
+        POP     AX              ; Recover Op type
+        PUSH    AX
+        OR      AH,AH
+        JZ      READ_SEC
+    ;
+    ; WRITE
+    ;
+        XOR     DI,DI           ; ES:DI -> start of tail
+        JMP     SHORT SMOVE
+
+READ_SEC:
+        XOR     SI,SI           ; DS:SI -> start of tail
+SMOVE:
+        MOV     CX,BP
+        REP     MOVSW
+        JMP     ALL_DONE
+
+MAP_ERR1:
+        CMP     AH,ABOVE_ERROR_BUSY ; Busy?
+        JZ      MAP_NEXT        ; Yes, wait till not busy (INTs are ON)
+        ADD     SP,6            ; Clean stack
+        JMP     SHORT DNR_ERR
+
+MAP_ERR2:
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      MAP_AGN
+        ADD     SP,2
+DNR_ERR:
+        MOV     AL,0AAH         ; Drive not ready
+        STC
+        JMP     REST_CONT
+;
+;
+;   this code has been written to handle te cases of overlapping usage
+;   of the above board page frame segment by the cache and user buffer
+;   assumption: in dos tracks cannot be more than 64 sectors long so
+;   in the worst case we shall have the user buffer occupying three
+;   pages is the page frame. we attempt to find the page that is
+;   available for the cache and use it repeatedly to access the cache
+;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+;   the algorithm is:
+;   ******************************************************
+;   [STEP1: determine the page we can use for the cache]
+;
+;   if (initial_para_offset_user in page 1 or above ) then  {
+;           physical_cache_page = 0;
+;           cache_segment       = above board segment;
+;               }
+;                                                     else  {
+;           physical_cache_page = 3;
+;           cache_segment       = above_board_segment + 3*1024;
+;               }
+;
+;   ******************************************************
+;   [STEP2: initial setup]
+;
+;   count = user_count_requested;
+;   number_to_be_transferred = min ( count, (16K - si) >> 2 );
+;   exchange source and destination if necessary;
+;
+;   *******************************************************
+;   [STEP3: set up transfer and do it]
+;
+;   count = count - number_to_be_transferred;
+;   map_page cache_handle,physical_cache_page,logical_cache_page
+;   mov data
+;
+;   *******************************************************
+;   [STEP4: determine if another transfer needed and setup if so]
+;
+;   if ( count == 0 ) then exit;
+;   if ( operation == read ) then source_offset = 0;
+;                            else dest_offset   = 0;
+;   number_to_be_transferred = min ( count, 8*1024 );
+;   logical_page_number++ ;
+;
+;   *******************************************************
+;   [STEP5: go to do next block]
+;
+;   goto [STEP3]
+;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+;
+new_code:
+        assume  ds:int13code,es:nothing,ss:nothing
+;
+;       input parameters:
+;
+;       bp : start para offset of user buffer in physical page frame
+;       ax : end para offset of user buffer in physical page frame
+;       di : transfer offset of user buffer
+;       es : transfer segment of user buffer
+;       dx : logical page number in cache
+;       si : offset from start in logical page number
+;
+;       on stack { cx,bx } where cx = number of words, bx = read / write status
+;
+;   [STEP1: finding physical cache page and page frame]
+;
+    ;
+    ; assume is physical page 0
+    ;
+        xor     al,al           ; use page 0 for cache
+        mov     bx,word ptr [base_addr+2]
+    ;
+    ; see if this assumption valid
+    ;
+        cmp     bp,1024         ; is initial in page 1 or above
+        jae     ab$30           ; if so or assumption is valid
+    ;
+    ; else we have to correct our assumption
+    ;
+        mov     al,3            ; use page 3 for cache
+        add     bx,3*1024       ;
+    ;
+    ; initialise page frame segment
+    ;
+ab$30:
+        mov     ds,bx
+    ;
+assume  ds:nothing
+;
+;   [STEP2: initialising transfer parameters]
+;
+    ;
+        pop     bp              ; bp will have count of words left to be transferred
+        pop     bx              ; read / write status
+        push    bx              ; save it back again
+        push    dx              ; save this too
+    ;
+    ; initially si offset into logical page, so we can only do 16*1024 - si
+    ; byte transfer
+    ;
+        mov     cx,16*1024
+        sub     cx,si
+        shr     cx,1            ; convert to word count
+    ;
+    ;   number to be transferred is the minimum of this and the user requested
+    ;   count
+    ;
+        cmp     cx,bp
+        jb      ab$31
+        mov     cx,bp
+    ;
+ab$31:
+    ;
+    ;   see if write, then we have to switch source with destination
+    ;
+        or      bh,bh
+        je      ab$32           ; if read we don't have to do anything
+                                ; else we have to switch
+        src_dest_switch
+ab$32:
+    ;
+    ;   set direction flag so that we don't have to do it repeatedly
+    ;
+        cld
+;
+;   [STEP3: set up transfer and do it]
+;
+ab$33:
+    ;
+    ;   update count of words still left to be transferred after this
+    ;
+        sub     bp,cx
+    ;
+    ;   map the logical page in cache to the physical page  selected
+    ;
+        mov     bx,dx           ; get logical page into bx
+                                ; al already holds the physical page #
+        map_page
+        jnc     ab$34           ; suceeded ?
+    ;
+    ; else report error
+    ;
+        add     sp,4
+        stc
+        jmp     short restore_mp ; and go to restore page map
+ab$34:
+    ;
+    ; succeeded, do the transfer
+    ;
+rep     movsw
+    ;
+;
+;   [STEP4: check if transfer done, if not set up for next block]
+;   [STEP5: go back to STEP3]
+    ;
+    ; check if done
+    ;
+        or      bp,bp           ; count 0
+        je      ab$40           ; yes, go to finish up
+    ;
+    ;   recover original dx and bx, increment dx and then save both again
+    ;
+        pop     dx
+        pop     bx
+        inc     dx
+        push    bx
+        push    dx
+    ;
+    ; words to be transferred minimum of count and 8*1024 words
+    ;
+        mov     cx,8*1024       ; 8k words in a page
+        cmp     cx,bp           ;
+        jbe     ab$35           ; if below or equal this is what we want
+    ;
+        mov     cx,bp           ; else we can transfer the whole count
+ab$35:
+    ;
+    ; see whether cache src or dest and accordingly reset either si or di
+    ;
+        or      bh,bh           ; read?
+        jne     ab$36           ; if write go to modify
+    ;
+    ; read, zero si and go back to step3
+    ;
+        xor     si,si
+        jmp     short ab$33     ; to step 3
+ab$36:
+    ;
+    ; write, zero di and go back to step3
+    ;
+        xor     di,di
+        jmp     short ab$33     ; to step 3
+;
+; finishing up we have to restore the page map
+;
+ab$40:
+        add     sp,4
+        clc
+restore_mp:
+        restore_mapping_context
+        ret
+
+                DW      ?               ; SPACE for ABOVE_PID
+
+;
+; This label defines the end of the code swapped in at DRIVE_CODE
+;
+ABOVE_END       LABEL   WORD
+
+BREAK   <Drive code for /A driver. Swapped in at RESET_SYSTEM>
+
+
+;
+; WARNING DANGER!!!!!!!
+;
+; This code is tranfered over the /E driver code at RESET_SYSTEM
+;
+; ALL jmps etc. must be IP relative.
+; ALL data references must be to cells at the FINAL, TRUE location
+;       (no data cells may be named HERE, must be named up at RESET_SYSTEM).
+; SIZE of stuff between ABOVE_RESET and ABOVE_RESET_END MUST be less than
+;       or equal to size of stuff between RESET_SYSTEM and RESET_INCLUDE.
+;
+; NOTE: EACH ABOVE BOARD driver has an INT 19 and 9 handler. This is
+;       different from /E and RESMEM in which only the first
+;       driver has an INT 19 and 9 handler.
+;
+
+IF2
+  IF((OFFSET ABOVE_RESET_END - OFFSET ABOVE_RESET) GT (OFFSET RESET_INCLUDE - OFFSET RESET_SYSTEM))
+          %out ERROR ABOVE_RESET CODE TOO BIG
+  ENDIF
+ENDIF
+
+;**     ABOVE_RESET perform TYPE 2 (/A) driver specific reboot code
+;
+;       This code issues an ABOVE_DEALLOC call for the memory
+;       associated with this particular TYPE 2 cache since the
+;       system is being re-booted and the driver is "gone".
+;
+;       ENTRY
+;           NONE
+;       EXIT
+;           NONE
+;       USES
+;           NONE
+;
+; This code is specific to TYPE 2 drivers
+;
+
+ABOVE_RESET:
+ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
+        PUSH    AX
+        PUSH    DX
+AGAIN_RESET:
+        MOV     DX,[ABOVE_PID]
+        MOV     AH,ABOVE_DEALLOC        ; Close PID
+        INT     67H
+        CMP     AH,ABOVE_ERROR_BUSY
+        JZ      AGAIN_RESET
+        POP     DX
+        POP     AX
+        RET
+
+;
+; This label defines the end of the code swapped in at RESET_SYSTEM
+;
+ABOVE_RESET_END    LABEL   BYTE
+
+BREAK <messages and common data>
+
+;**     Message texts and common data
+;
+;       Init data. This data is disposed of after initialization.
+;       it is mostly texts of all of the messages
+;
+;       COMMON to TYPE 1 and 2 drivers
+;
+; THIS IS THE START OF DATA SUBJECT TO TRANSLATION
+
+NO_ABOVE db     "SMARTDrive : Expanded Memory Manager not present",13,10,"$"
+BAD_ABOVE db    "SMARTDrive : Expanded Memory Status shows error",13,10,"$"
+BAD_AT  db      "SMARTDrive : Cannot run on this computer",13,10,"$"
+NO_MEM  db      "SMARTDrive : No extended memory available",13,10,"$"
+ERRMSG1 db      "SMARTDrive : Invalid parameter",13,10,"$"
+ERRMSG2 db      "SMARTDrive : Insufficient memory",13,10,"$"
+INIT_IO_ERR db  "SMARTDrive : I/O error accessing cache memory",13,10,"$"
+NOHARD  db      "SMARTDrive : No hard drives on system",13,10,"$"
+BIGTRACK db     "SMARTDrive : Too many bytes per track on hard drive",13,10,"$"
+BADVERMES db    13,10,"SMARTDrive : Incorrect DOS version",13,10,"$"
+
+;
+; This is the Int13 header message.
+;
+HEADERMES db    13,10,"Microsoft SMARTDrive Disk Cache v2.10",13,10,"$"
+
+;
+; This is the status message used to display INT13 configuration
+;  it is:
+;
+;    STATMES1<size in K><STATMES1A|STATMES1E>STATMES2<# tracks in cache>STATMES3
+;    <sectors per track>STATMES4
+;
+; It is up to translator to move the message text around the numbers
+; so that the message is printed correctly when translated
+;
+STATMES1  db    "    Cache size: $"
+STATMES1A db    "K in Expanded Memory$"
+STATMES1E db    "K in Extended Memory$"
+STATMES2  db    13,10,"    Room for $"
+STATMES3  db    " tracks of $"
+STATMES4  db    " sectors each",13,10,13,10,"$"
+ifdef   OMTI
+omti_msg  db    "    OMTI controller release",13,10,"$"
+endif
+
+;-----------------------------------------------------------------------
+;
+; END OF DATA SUBJECT TO TRANSLATION
+;
+
+IF DEBUG
+STATMES5  db    "Device CS = $"
+STATMES6  db    " decimal",13,10,"$"
+s5flagmsg db    " = S5 flag",13,10,"$"
+U_msg     db    " = U Switch", 13,10,'$'
+ENDIF
+
+        db      "This program is the property of Microsoft Corporation."
+
+INT13_END       LABEL   BYTE
+
+INT13CODE ENDS
+        END
+
\ No newline at end of file