MZ is back!

[MS-DOS.git] / v4.0-ozzie / bin / DISK2 / BIOS / BUGCODE.INC

;***    Bugcode.inc - Debug code for including into sysini.asm and ibmbio.asm
;
;       Can't link in via buglib due to memory and relocation games played
;       by these modules.  Each gets a private, local-only copy of these
;       modules.


IFDEF   DEBUGFLG


;**     DPRINTF _ Debug Printf
;
;       Dprintf is a kernel debug print formatting package.  It is intended
;       to produce conviently formatted output.
;
;       Dprintf is called, indirectly, by a macro:
;
;       DEBUG   n,m,"string",<a1,...,an>
;
;       string = format string
;       a1     = first argument
;       an     = last argument
;
;       The format string is an ASCIZ string which can contain 2 types of
;       specifications:  data-format specifications and literal characters.
;       Data format specifications always begin with a '$' character; all
;       characters not part of a data format specification are treated as
;       literal characters.
;
;       Literal characters
;           - any character not part of a format specification.  Special
;             non-printing characters are:
;               \n      - CRLF
;               \t      - tab
;               \b      - bell
;               \\      - \
;               \$      - $
;
;       Format Specifications
;
;       A format specification takes the form:
;            $ [@] <char>
;
;       where <char> =
;
;           x       - print argument as a hex word
;           d       - print argument as decimal word
;           c       - print argument as ascii character
;           b       - print argument as hex byte
;               For each of the above formats, the supplied argument
;               is a 16-bit word - the value to be printed.  The optional @
;               (described below) allows a segmented address to be supplied,
;               instead.
;
;           s[nn]   - print argument as asciz string; if optional decimal
;                     argument follows the format character this specifys
;                     a maximum string length.  Non printing characters are
;                     printed in the form \nnn where "nnn" is the octal byte
;                     value.
;                     Note that this format character cannot be directly
;                     followed by a digit unless that digit is to be taken
;                     as the start of a length argument.
;
;           Bnn     - print argument as hex bytes.  The required following
;                     decimal argument is the number of bytes to print.
;
;               Both of these formats take a long address as their argument.
;               The '@' character is thus invalid for these formats.
;
;       WARNINGS
;           As befitting a debug routine, DPRINTF does not have a whole lot
;           of "failsafe" code in it.  Supplying screwed up formats can
;           muck things up.  Specifically:
;               The @ argument must NOT be specified with the 's' or 'B'
;                    format
;               A string/byte-length argument of 0 is taken as 65536
;           The string "%% BAD FMT %%" appears in the output when
;               1) an illegal format specifier is given, or
;               2) the B format is given a 0 or missing length
;
;       ENTRY   (sp+n  ) = address of format string (offset from return cs value)
;               (sp+n-2) = first argument word
;               (sp+n-4) = second argument word
;                   .
;               (sp+4  ) = last argument word
;               (sp+2  ) = seg of return address
;               (sp    ) = offset of return address
;               (bp) = offset of format string on the stack
;       EXIT    none
;       USES    flags

        PUBLIC  DPRINTF
DPRINTF PROC    near

        push    ds
        push    es
        push    bp
        push    di
        push    si
        push    dx
        push    cx
        push    bx
        push    ax              ; save registers
        cld

        mov     si,[bp]         ; get address of format string
        sub     bp,2
        mov     bx,sp
        mov     ds,ss:20[bx]    ; (ds:si) = address of format string
        push    cs
        pop     ds

;       Scan format string for next character
;
;       (ds:si) = address of format string
;       (ss:bp) = address of next argument

dpf1:   lodsb                   ; (al) = format string byte
        and     al,al
        je      dpf3            ; all done
        cmp     al,'$'
        je      dpf4            ; is data escape
        cmp     al,'\'
        jnz     dpf2            ; got the character

;       it's an "\" escape code - crack the argument character

        lodsb
        and     al,al
        je      dpf3            ; all done, ignore hanging \
        xchg    ah,al
        mov     al,0Ch
        cmp     ah,'n'
        jne     dpf1$5          ; not \n
        mov     al,0dH
        call    putchar
        mov     al,0aH
        jmp     SHORT dpf2      ; print LF

dpf1$5: cmp     ah,'t'
        mov     al,9
        je      dpf2            ; is \t
        cmp     ah,'b'
        mov     al,7
        je      dpf2            ; is \b
        xchg    ah,al
dpf2:   call    putchar
        jmp     dpf1

;       have the end of the format string - exit

dpf3:   pop     ax
        pop     bx
        pop     cx
        pop     dx
        pop     si
        pop     di
        pop     bp
        pop     es
        pop     ds
        ret


;*      Have a '$' character - is data format escape
;
;       Get address of data into es:di
;
;       (bp) = address of data value

dpf4:   mov     di,bp
        push    ss
        pop     es              ; (es:di) = address of data value
        sub     bp,2            ; point to next argument
        lodsb                   ; (al) = format specifier
        cmp     al,'@'
        jne     dpf5            ; not an indirect flag
        les     di,[bp]
        sub     bp,2            ; have an extra 2 for @
        lodsb
dpf5:   cmp     al,'x'
        jne     dpfd1           ; not 'x'

;       is 'x' format - print hex word

        mov     ax,es:[di]
        call    THW             ; type hex word
        jmp     dpf1

dpfd1:  cmp     al,'d'
        jnz     dpfc1           ; not 'd'

;       is 'd' format - print decimal word

        mov     ax,es:[di]
        call    TDW             ; type decimal word
        jmp     dpf1

dpfc1:  cmp     al,'c'
        jne     dpfb1

;       is 'c' format - print character

        mov     al,es:[di]
        call    putchar
        jmp     dpf1

dpfb1:  cmp     al,'b'
        jne     dpfs1

;       is 'b' format - print hex byte

        mov     al,es:[di]
        call    THB             ; type hex byte
        jmp     dpf1

dpfs1:  cmp     al,'s'
        jne     dpfbb1

;       is 's' format - print ASCIZ string.  First, check for
;               optional decimal limit

        public  SSB
SSB:    sub     cx,cx           ; set 65536 limit
        les     di,[bp]         ; (es:DI) = fwa of string
        sub     bp,2            ; argument to 's' was two words
        mov     al,[si]
        cmp     al,'0'
        jb      dpfs2           ; not decimal
        cmp     al,'9'
        ja      dpfs2           ; not decimal
        call    atod            ; (ax) = decimal value, (ds:si) updated
        xchg    cx,ax

;       print asciz string at es:di, max of (cx) characters
;       (cx) = 0  means max of 65536
;
;       Other sections of code in dpf jump here to print strings

dpfs2:  mov     al,es:[di]
        inc     di
        and     al,al
        je      dpfs3
        call    putchar
        loop    dpfs2           ; continue if not at limit
dpfs3:  jmp     dpf1

dpfbb1: cmp     al,'B'
        je      dpfbb2          ; is 'B' format

;       error in format code - print message

dpferr: push    cs
        pop     es
        mov     di,OFFSET dpfa  ; (es:di) = error message
        sub     cx,cx
        jmp     dpfs2

dpfa:   DB      '%% BAD FMT %%',0

;       have B format

dpfbb2: call    atod            ; (ax) = length specifier
        jc      dpferr          ; number not there - error
        xchg    cx,ax
        jcxz    dpferr          ; number is 0 - error
        les     di,[bp]         ; (es:DI) = fwa of string
        sub     bp,2            ; argument to 's' was two words
dpfbb3: mov     al,es:[di]
        call    THB             ; type hex byte
        mov     al,' '
        call    putchar         ; space em out
        inc     di
        loop    dpfbb3          ; do em all
        jmp     dpf1

DPRINTF ENDP


;**     THB - Type Hex Byte
;
;       THB types a hex byte (via "putchar")
;
;       ENTRY   (AL) = byte
;       EXIT    none
;       USES    ax, flags

THBA    DB      '0123456789abcdef'

        PUBLIC  THB
THB     PROC    near

        push    ax
        shr     al,1
        shr     al,1
        shr     al,1
        shr     al,1
        and     ax,0fH
        xchg    bx,ax
        mov     bl,CS:THBA[bx]
        xchg    ax,bx
        call    putchar             ; put first character
        pop     ax
        and     ax,0fH
        xchg    bx,ax
        mov     bl,CS:THBA[bx]
        xchg    ax,bx
        call    putchar
        ret

THB     ENDP




;**     THW - Type Hex Word
;
;       THW types a word in hex (via "putchar")
;
;       ENTRY   (AX) = word
;       EXIT    none
;       USES    AX, flags

        PUBLIC  THW
THW     PROC    near

        push    ax
        xchg    ah,al
        call    THB
        pop     ax
        call    THB
        ret

THW     ENDP



;**     TDW - Type Decimal Word
;
;       TDW types (via "putchar") the unsigned decimal representation
;       of a 16-bit unsigned integer.  Only significant digits are
;       printed; if the number is 0 a "0" is printed.
;
;       ENTRY   (AX) = number
;       EXIT    none
;       USES    AX, flags

        PUBLIC  TDW
TDW     PROC    near

        push    cx              ; preserve registers
        push    dx
        mov     cx,10
        call    tdw$            ; recurse cracking digits
        pop     dx
        pop     cx
        ret

TDW     ENDP


;*      tdw$ - crack number recursively
;
;       tdw$ cracks the least significant decimal digit.  If there
;       are no higher-significant digits, print and return.
;       else, recurse for higher digits
;
;       (AX) = value
;       (CX) = 10

tdw$    PROC    NEAR

        sub     dx,dx
        div     cx              ; (ax) = quotient, (dx) = remainder
        and     ax,ax
        jz      tdw$1           ; this is highest-order, do it
        push    dx
        call    tdw$
        pop     dx
tdw$1:  xchg    ax,dx
        add     al,'0'
        call    putchar
        ret

TDW$    ENDP



;**     ATOD - Convert ASCII string to decimal number
;
;       ATOD is called to convert an ascii string of digits to a
;       decimal number.  Digits are converted until we run out of them.
;
;       ENTRY   (DS:SI) = address of first digit
;       EXIT    'C' clear if OK
;                 (AX) = value
;                 (SI) updated to first non-digit
;               'C' set if error - no digits, or result >65535
;                 (DS:SI) points to error character
;       USES    AX, SI, FLAGS

        PUBLIC  ATOD
ATOD    PROC    near

        push    dx
        push    cx                  ; save registers
        mov     al,[si]
        sub     al,'0'
        jc      atod9               ; error - no digits
        cmp     al,10
        cmc
        jc      atod9               ; error - no digits
        sub     ax,ax               ; clear accumulator
        mov     cx,10               ; base 10

;       crack next digit
;
;       (AX) = number accumulated so near
;       (CX) = 10
;       (DS:SI) = next character

atod1:  xchg    dx,ax           ; keep accum in dx for a while
        lodsb                   ; (al) = character
        sub     al,'0'
        jc      atod7           ; not digit - all done
        cmp     al,9
        ja      atod7           ; not digit - all done
        sub     ah,ah           ; (ax) = digit value (0 - 9)
        push    ax
        xchg    ax,dx
        mul     cx              ; (ax) = 10*accum
        pop     dx              ; (dx) = digit to add
        jo      atod8           ; overflow
        add     ax,dx
        jmp     atod1           ; go back for more

;       Done with number, all OK
;
;       (dx) = number
;       (ds:si) = address+1 of first unused character

atod7:  clc

;       Done with number, error
;       'C' set

atod8:  dec     si              ; backup over non-decimal (or error) char
atod9:  pop     cx
        xchg    ax,dx           ; (ax) = number iff no error
        pop     dx              ; restore registers
        ret                     ; exit

ATOD    ENDP

;**     putchar - put a character on the console
;
;       ENTRY   (al) = character
;       EXIT    none
;       USES    ax,flags


UR_DAT  =       02f8H           ; COM1 = 03f8H, COM2 = 02f8H
UR_IEN  =       UR_DAT+1        ; Interrupt enable
UR_IER  =       UR_DAT+2        ; interrupt ID
UR_LCR  =       UR_DAT+3        ; line control registers
UR_MCR  =       UR_DAT+4        ; modem control register
UR_LSR  =       UR_DAT+5        ; line status register
UR_MSR  =       UR_DAT+6        ; modem status regiser
UR_DLL  =       UR_DAT          ; divisor latch least sig
UR_DLM  =       UR_DAT+1        ; divisor latch most sig

iflag   DB      0               ; != 0 when initialized 8250

;*      inchr - input character
;
;       EXIT    'z' set if no character
;               'z' clear if char
;                 (al) = char

inchr:  mov     dx,UR_LSR
        in      al,dx
        and     al,1
        jz      inchr1
        mov     dx,UR_DAT
        in      al,dx
        and     al,07fh
inchr1: ret


        PUBLIC  putchar
putchar PROC    NEAR
        pushf
        cli
        push    dx
        push    cx
        push    bx
        push    ax              ; (al) = character
        test    iflag,255
        jnz     putc1           ; is initialized
        inc     iflag

;       program the usart

        mov     dx,UR_LCR
        mov     al,80h
        out     dx,al           ; command it
        sub     al,al
        mov     dx,UR_DLM
        out     dx,al
        mov     dx,UR_DLL
        mov     al,12           ; 9600 baud = 12, 19.2 Kbaud = 6
        out     dx,al
        mov     al,3
        mov     dx,UR_LCR
        out     dx,al           ; command normal mode

;       see if CTL-Q or CTL-S

putc1:  pushf
        cli
        call    inchr
        jz      putc3           ; no characters incomming
        cmp     al,19           ; ctl-S?
        jnz     putc3           ; no, ignore

;       have ctl-s.  wait till we see ctl-Q

putc2:  call    inchr
        jz      putc2
        cmp     al,17
        jnz     putc2

putc3:  popf
        mov     dx,UR_LSR
putc4:  in      al,dx
        test    al,020h
        jz      putc4

;       ready.  crank it out!

        mov     dx,UR_DAT

        pop     ax
        out     dx,al

        pop     bx
        pop     cx
        pop     dx
        popf
        ret

putchar ENDP

ENDIF