ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/UTILITY/SYSTEM/UMM03.ZIP/UMM.ASM

Assembly Source File | 1991-12-14 | 11.9 KB | 563 lines

;; umm.asm v0.3
;; Upper Memory Manager for MS-DOS
;; Copyright (C) 1991  Kenneth Gober
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2 of the License, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;
;; To contact the author about changes, enhancements, bug reports, or
;; other comments, send electronic mail to:
;;
;;    snow@drycas (from Bitnet sites)
;;    [e-mail] (from Internet sites)
;;
;; If you are unable to contact the author through electronic mail,
;; try sending a letter (as a last resort, only) to the following address:
;;
;;    Kenneth Gober
;;    412 Robin Road
;;    Cedar Hill, TX 75104 (USA)
;;
;; Please note that mail sent to this address may not yield a response
;; for several months!
;;
;; Version History:
;;
;;    0.0    Initial release for 80386 only.
;;    0.1    Provided 80286 support.
;;    0.2    Memory test added.  Bug in UMB merge code fixed by
;;          [e-mail] (Antonio Julio Raposo).
;;    0.3    Resident portion relocated to upper memory.
;;

    ideal                ; Use TASM Ideal mode syntax
    p286n                ; Assemble for the 80286 (real mode)
    locals    $$            ; local labels preceded by '$$'

mbds    equ    (mb ds:0)
mbes    equ    (mb es:0)
rhds    equ    (rh ds:si)
rhes    equ    (rh es:di)

struc    rh                ; request header
len    db    ?
dev    db    ?
cmd    db    ?
st    dw    ?
rsvd    dq    ?
ct    db    ?
aoff    dw    ?
aseg    dw    ?
dptr    dd    ?
ends

struc    mb                ; UMB header
nxt    dw    ?            ; next UMB in chain
siz    dw    ?            ; size of UMB (without header)
mlo    dw    ?            ; magic number (low word)
mhi    dw    ?            ; magic number (high word)
extra    dq    ?            ; extra (unused)
ends

group    umm    umml, ummh, umm0

segment    umml    use16            ; low-memory resident segment

devhdr    dd    -1            ; device header
devflg    dw    0a000h
devstr    dw    ummstr
devint    dw    ummint0
devnam    db    'UMMXXXX0'

label    rhptr    dword            ; pointer to request header
rhoff    dw    ?
rhseg    dw    ?

proc    ummstr    far            ; strategy routine
    assume    cs:umml

    mov    [umml:rhoff], bx
    mov    [umml:rhseg], es
    ret
endp

proc    ummint    far            ; resident interrupt routine
    assume    cs:umml

    push    si            ; save registers
    push    ds
    lds    si, [umml:rhptr]    ; ds:si = request header
    mov    [rhds.st], 8103h    ; return error (unknown command)
    pop    ds            ; restore registers
    pop    si
    ret
endp

label    endl    unknown            ; HEADER SECTION ENDS HERE

ends    umml

segment    ummh    use16            ; upper-memory resident segment

label    begh    unknown

freep    dw    -1            ; segment of first free UMB

label    xmmptr    dword            ; pointer to XMM
xmmoff    dw    ?
xmmseg    dw    ?

rpopf:    iret                ; for reliable popf

proc    ummctl    far            ; UMM control function
    assume    cs:ummh

    jmp    short $$1        ; XMS requires this
    nop
    nop
    nop

$$1:    pushf                ; save flags
    push    cs
    cmp    ah, 10h            ; request UMB
    je    short $$2
    cmp    ah, 11h            ; release UMB
    je    short $$3
    call    ummh:rpopf        ; restore flags
    jmp    [ummh:xmmptr]        ; chain to old XMM

$$2:    push    ds            ; save segment registers
    push    es
    call    ummh:requmb        ; request UMB
    jmp    short $$4

$$3:    push    ds            ; save segment registers
    push    es
    call    ummh:relumb        ; release UMB

$$4:    pop    es            ; restore segment registers
    pop    ds
    call    ummh:rpopf        ; restore flags before returning
    ret
endp

proc    requmb    near            ; request UMB
    assume    cs:ummh

    cmp    [ummh:freep], -1    ; any UMBs available?
    jne    short $$1
    xor    ax, ax            ; return failure code
    mov    bl, 0b1h        ; no UMBs available
    ret

$$1:    push    cs            ; get paragraph address of freep
    pop    ds
    push    cx
    xor    cx, cx

$$2:    cmp    [mbds.nxt], -1        ; last UMB?
    jne    short $$3
    xor    ax, ax            ; return failure code
    mov    bl, 0b0h        ; smaller UMB available
    mov    dx, cx
    pop    cx
    ret

$$3:    mov    ax, ds            ; save previous UMB
    mov    ds, [mbds.nxt]        ; move to next UMB
    cmp    [mbds.siz], cx        ; remember size of largest UMB
    jbe    short $$4
    mov    cx, [mbds.siz]

$$4:    cmp    cx, dx            ; big enough?
    jb    short $$2
    sub    cx, dx            ; split into two UMBs if necessary
    cmp    cx, 1
    ja    short $$5
    mov    es, ax            ; unlink current UMB
    mov    ax, [mbds.nxt]
    mov    [mbes.nxt], ax
    jmp    short $$6

$$5:    mov    ax, ds            ; determine address of new UMB
    add    ax, cx
    dec    cx            ; shorten old UMB
    mov    [mbds.siz], cx
    mov    ds, ax            ; initialize new UMB
    mov    [mbds.siz], dx
    mov    [mbds.mlo], 4c4bh
    mov    [mbds.mhi], 0047h

$$6:    mov    ax, 1            ; return success code
    mov    bx, ds            ; return address of UMB
    inc    bx
    pop    cx
    ret
endp

proc    relumb    near            ; release UMB
    assume    cs:ummh

    push    dx
    dec    dx
    mov    es, dx
    cmp    [mbes.mlo], 4c4bh    ; check magic number
    jne    short $$1
    cmp    [mbes.mhi], 0047h
    je    short $$2

$$1:    xor    ax, ax            ; return failure code
    mov    bl, 0b2h        ; invalid UMB
    pop    dx
    ret

$$2:    push    cs            ; get paragraph address of freep
    pop    ds

$$3:    cmp    [mbds.nxt], dx        ; step through linked list
    ja    short $$4
    mov    ds, [mbds.nxt]
    jmp    short $$3

$$4:    mov    ax, [mbds.nxt]        ; link UMB back into list
    mov    [mbes.nxt], ax
    mov    [mbds.nxt], dx
    push    cs
    pop    ds            ; try to merge adjacent UMBs
    mov    ds, [mbds.nxt]

$$5:    cmp    [mbds.nxt], -1        ; end of chain?
    jne    short $$6
    mov    ax, 1            ; return success code
    pop    dx
    ret

$$6:    mov    ax, ds            ; advance to next UMB
    mov    ds, [mbds.nxt]
    mov    es, ax            ; see if UMBs are adjacent
    add    ax, [mbes.siz]
    inc    ax
    mov    dx, ds
    cmp    ax, dx
    jne    short $$5
    mov    ax, [mbds.nxt]        ; unlink second UMB
    mov    [mbes.nxt], ax
    mov    ax, [mbds.siz]        ; merge UMBs
    inc    ax
    add    [mbes.siz], ax
    push    es            ; try merging this UMB again
    pop    ds
    jmp    short $$5
endp

label    endh    unknown            ; RESIDENT SECTION ENDS HERE

ends    ummh

segment    umm0    use16            ; initialization segment

oldsp    dw    ?            ; original stack
oldss    dw    ?

proc    ummint0    far            ; initial interrupt routine
    assume    cs:umm, ds:umm

    pushf                ; save flags
    push    cs
    pusha                ; save registers
    push    ds
    push    es
    push    cs
    pop    ds
    les    di, [rhptr]        ; es:di = request header
    mov    [rhes.st], 8103h    ; assume error (unknown command)
    mov    al, [rhes.cmd]        ; only cmd 0, INIT is legal
    or    al, al
    jnz    short $$1
    call    init

$$1:    pop    es            ; restore registers
    pop    ds
    popa
    call    rpopf            ; restore flags before returning
    ret
endp

proc    init    near            ; initialize driver
    assume    cs:umm, ds:umm

    mov    [oldss], ss        ; save old stack
    mov    [oldsp], sp
    mov    bx, ds
    mov    ss, bx            ; enable new stack
    mov    sp, offset stktop
    mov    ah, 9            ; write banner
    mov    dx, offset eHello
    int    21h
    mov    [devint], offset ummint    ; enable resident interrupt routine
    mov    ax, 4300h        ; check for an XMS driver
    int    2fh
    cmp    al, 80h            ; is the XMS driver loaded?
    je    short lexer
    mov    dx, offset eNoXMS

abort:    call    error            ; abort installation
    mov    [rhes.aseg], cs        ; discard everything after header
    mov    [rhes.aoff], offset endl
    mov    [rhes.st], 810ch    ; return error (general failure)
    mov    ss, [oldss]        ; restore old stack
    mov    sp, [oldsp]
    ret

badch:    pop    ds            ; bad character found by lexer
    mov    dx, offset eLexer
    jmp    short abort

lexer:    push    ds            ; lexical analyzer
    lds    si, [rhes.dptr]        ; ds:si = command line arguments
    cld

s0:    lodsb                ; state 0, skip filename
    call    eol
    je    short done
    call    blank
    jne    short s0

s1:    lodsb                ; state 1, skip blanks
    call    eol
    je    short done
    call    blank
    je    short s1
    call    digit
    ja    short badch

    cbw
    mov    cx, ax
s2:    lodsb                ; state 2, found 1 decimal digit
    cmp    al, '@'
    je    short s4
    call    digit
    ja    short badch

    imul    cx, 10
    add    cx, ax
s3:    lodsb                ; state 3, found 2 decimal digits
    cmp    al, '@'
    jne    short badch

s4:    lodsb                ; state 4, get first hex digit (a-f)
    call    hexaf
    ja    short badch
    add    al, 10
    mov    bh, al

s5:    lodsb                ; state 5, get second hex digit (0-f)
    mov    bl, al
    call    digit
    jbe    short $$1
    mov    al, bl
    call    hexaf
    ja    short badch
    add    al, 10

$$1:    shl    bh, 4
    or    bh, al
    xor    bl, bl

s6:    lodsb                ; state 6, get third hex digit (0)
    cmp    al, '0'
    jne    short badch

s7:    lodsb                ; state 7, get fourth hex digit (0)
    cmp    al, '0'
    jne    short badch
    call    newumb            ; create new UMB
    jmp    short s1

done:    pop    ds            ; command-line processing done
    mov    [rhes.aseg], cs        ; discard initialization section
    mov    [rhes.aoff], offset endh
    mov    [rhes.st], 0100h    ; return success code
    mov    cx, offset ummh:endh    ; relocate resident portion
    mov    dx, cx            ; find size in paragraphs
    add    dx, 15
    shr    dx, 4
    mov    bx, cs            ; call UMM control function
    mov    ax, offset begh        ; find segment
    shr    ax, 4
    add    bx, ax
    mov    ah, 10h
    push    bx            ; save ummh segment value
    push    cs            ; push return address
    push    offset $$ret
    push    bx            ; push call address
    push    offset ummh:ummctl
    retf                ; this is a far call
$$ret:    test    ax, ax            ; UMB available?
    jz    hook
    pop    ax            ; replace saved ummh segment value
    push    bx            ; and relocate ummh to UMB
    mov    [rhes.aoff], offset endl
    mov    es, bx
    mov    si, offset begh
    xor    di, di
    cld
    rep    movsb

hook:    mov    ax, 4310h        ; hook XMS control function
    int    2fh
$$2:    cmp    [byte es:bx], 0ebh    ; does it start with a short jump?
    je    short $$3
    les    bx, [es:bx+1]        ; if not, follow far jump
    jmp    short $$2
$$3:    mov    [byte es:bx], 0eah    ; change to a long jump
    inc    bx            ; load byte displacement
    mov    al, [byte es:bx]
    cbw                ; convert to word offset
    add    ax, bx
    inc    ax
    pop    ds            ; restore saved ummh segment value
    assume    cs:umm, ds:ummh
    mov    [ummh:xmmoff], ax    ; link ourselves into the chain
    mov    [ummh:xmmseg], es
    mov    [word es:bx], offset ummh:ummctl
    mov    [word es:bx+2], ds
    mov    ss, [oldss]        ; restore old stack
    mov    sp, [oldsp]
    ret
endp

proc    eol    near            ; check if al is an eol or eof
    assume    cs:umm

    cmp    al, 13
    je    short $$1
    cmp    al, 26
$$1:    ret
endp

proc    blank    near            ; check if al is a space or tab
    assume    cs:umm

    cmp    al, 32
    je    short $$1
    cmp    al, 9
$$1:    ret
endp

proc    digit    near            ; check if al is a decimal digit
    assume    cs:umm

    sub    al, '0'
    cmp    al, 9
    ret
endp

proc    hexaf    near            ; check if al is in the range 'a'-'f'
    assume    cs:umm

    or    al, 32
    sub    al, 'a'
    cmp    al, 5
    ret
endp

proc    error    near            ; write an error message
    assume    cs:umm, ds:umm

    mov    ah, 9
    push    dx
    mov    dx, offset eError    ; write error prefix
    int    21h
    pop    dx            ; specify which error
    int    21h
    ret
endp

proc    newumb    near            ; create a new UMB
    assume    cs:umm

    push    ds
    push    es
    mov    dx, cs            ; get paragraph address of freep
    mov    ax, offset freep
    shr    ax, 4
    add    dx, ax
    mov    es, dx

$$1:    cmp    [mbes.nxt], bx        ; step through linked list
    ja    short $$2
    mov    es, [mbes.nxt]
    jmp    short $$1

$$2:    push    es            ; memory test
    push    bx
    push    cx
    push    di
    mov    dx, cx
     mov    ax, 0a396h        ; test pattern

$$3:    mov    es, bx            ; write test pattern to page
    mov    cx, 2048
    xor    di, di
    rep    stosw
    mov    cx, 2048        ; read test pattern from page
    xor    di, di
    repe    scasw
    jne    short $$4
    inc    bh            ; move to next page
    dec    dx
    jnz    short $$3
    jmp    short $$5

$$4:    add    sp, 14            ; error in memory test
    pop    ds
    les    di, [ds:rhptr]
    mov    dx, offset eNoMem
    jmp    abort

$$5:    pop    di            ; memory tested ok
    pop    cx
    pop    bx
    pop    es
    xchg    cl, ch            ; convert pages to paragraphs
    dec    cx
    mov    ds, bx
    mov    ax, [mbes.nxt]        ; link UMB into list
    mov    [mbds.nxt], ax
    mov    [mbes.nxt], bx
    mov    [mbds.siz], cx        ; initialize UMB
    mov    [mbds.mlo], 4c4bh
    mov    [mbds.mhi], 0047h
    pop    es
    pop    ds
    ret
endp

eHello    db    'Upper Memory Manager v0.3', 13, 10
    db    'Copyright (C) 1991  Kenneth Gober'
eNL    db    13, 10, 13, 10, '$'
eError    db    'Error installing UMM:  $'
eNoXMS    db    'XMS driver not found', 13, 10, '$'
eLexer    db    'Invalid arguments', 13, 10, '$'
eNoMem    db    'Memory test failed', 13, 10, '$'

    align    4            ; start stack on dword boundary

stkbot    db    512 dup (?)        ; initialization stack
label    stktop    word

ends    umm0
    end