page ,132
title PARCHK.ASM -- Replacement for IBM-PC ROM BIOS parity error routines
;*****************************************************************************
;*
;* copyright(C) 1984 Skip Gilbrech (CIS 71445,534)
;* 90 Lexington Ave. #10-G
;* New York, NY 10016
;* 212-685-0551
;*
;* This program may be freely copied/altered for any non-commercial
;* purpose but may not be sold or used in any way as part of any
;* profit-making venture without permission of the author.
;*
;* author = skip gilbrech
;* date written = 02/19/84
;*
;* environment:
;* system = ibm pc (dos 2.0 - but should work on any version)
;* processor = microsoft 8086 macro assembler
;*
;* USAGE: PARCHK /R (or) /D
;* /R = Report all errors which occur
;* /D = Disable reporting after an error
;*
;* PARCHK is a resident program which replaces the ibm pc rom-bios NMI
;* (non-maskable interrupt) handler.
;*
;* It will report any memory parity errors to the operator, but will allow
;* the system to continue running. An installation option lets you choose
;* whether or not to receive continued reports after the first error for
;* a particular channel (system memory or i/o channel). Regardless of the
;* option chosen, however, the first error for each channel will always be
;* reported.
;*
;* I wrote PARCHK mostly because of the frustration I felt a few days ago
;* when the message 'PARITY CHECK 2' appeared suddenly on my pc's screen.
;* I had seen the message a couple of times before, but never at a time
;* like this: The machine contained over 3 hours of unsaved work, and I
;* knew there was not a thing I could do about it, since the parity error
;* handler in the rom-bios simply disables interrupts and issues a HLT
;* instruction to the cpu.
;*
;* I have also read a number of messages on the Compuserve IBM-PC SIG
;* which indicate that I'm not the only one to have had this experience.
;*
;* IBM's approach in the rom-bios makes some sense. The condition of
;* system ram is unknown following a parity error, and continued operation
;* MIGHT result in all sorts of horrible consequences, i.e., hopelessly
;* corrupted data on disk, etc.
;*
;* On my system, though, memory parity errors have been extremely rare,
;* and have probably resulted from a slight glitch on the power line,
;* static, etc. I really have no idea what would have happened if I
;* had been able to continue operation in those cases. However, I have
;* crashed the system often enough (most of the time probably executing
;* random data or instructions somewhere) to have some confidence that the
;* most likely, if not the only possible, outcome of a processor gone wild
;* is simply a dead machine, i.e. interrupt vectors wiped out, etc., which
;* must be powered-down and up.
;*
;* So, for me, the risks of continued operation -- at least until important
;* data in ram are saved -- seem relatively small when balanced against
;* the CERTAINTY of lost data when the rom-bios routine gets control: If
;* data HAS been corrupted, at least there remains the chance of later
;* being able to examine and possibly fix it.
;*
;* Continued operation still DOES represent a risk, however, especially
;* if parity errors occur often, since that probably indicates a serious
;* hardware problem somewhere in the system.
;*
;* If you don't want to take that risk, please don't use this program,
;* as I can't, of course, take responsibility for any damage, real or
;* otherwise, it may cause.
;*
;* On the other hand, if PARCHK is ever responsible for saving a multi-
;* million dollar oil deal which would otherwise have fallen victim to
;* an unruly parity bit...... (suffice it to say that I would deem it
;* an honor to allow you to express your gratitude)
;*
;* The resident part of this code, by the way, uses up a little over 1K
;* of ram. Most of that space is taken up by routines which save the
;* current screen, write the error message, and then restore the screen.
;* I made no particular effort to make that code as compact as possible,
;* so, if space is at a premium, and/or you like doing such things, please
;* feel free to squeeze and optimize to your heart's content... As an
;* alternative, if you don't mind junk on your screen, it would be fairly
;* easy to replace most of the error message code with a short routine which
;* uses the rom-bios 'write teletype' function to print a message, but
;* doesn't waste any memory by saving the screen. It's probably best not
;* to use dos functions here, since a parity error can be reported at any
;* time, even with interrupts disabled and/or while in the middle of a dos
;* routine -- and pc/ms-dos is notoriously non-reentrant.
;*
;**************************************************************************
page
;**************************************************************************
;*
;* constants
;*
;**************************************************************************
; general equates:
false equ 0
true equ not false
cr equ 0dh ; carriage return
lf equ 0ah ; line feed
bell equ 7 ; ascii bell
spc equ ' ' ; ascii space, blank
tab equ 9 ; ascii horizontal tab
; program equates:
dosint equ 21h ; interrupt number for dos functions
prt_str equ 9 ; dos print string function
get_vers equ 30h ; dos get version number function
get_int_vec equ 35h ; dos 2.0 get interrupt vector function
set_int_vec equ 25h ; dos set interrupt vector function
vidint equ 10h ; bios video interrupt number
vid_state equ 15 ; bios - get video state
read_curs_pos equ 3 ; bios - read cursor position
set_curs_pos equ 2 ; bios - set cursor position
set_curs_type equ 1 ; bios - set cursor type
write_teletype equ 14 ; bios - write teletype to display
read_ac equ 8 ; bios - read att/char at curs. position
write_ac equ 9 ; bios - write att/char at curs. position
disp_row equ 10 ; row to display error msg
disp_col equ 25 ; col to display error msg
num_lines equ 3 ; number of text lines to display
normal equ 7 ; normal (white on black) vid. attrib.
reverse_blink equ 0f0h ; reverse-video blinking vid. attrib.
reverse equ 70h ; reverse-video (no blink)
; hardware specific equates:
port_a equ 60h ; system board 8255 port a address
port_b equ 61h ; system board 8255 port b address
port_c equ 62h ; system board 8255 port c address
par_err_mask equ 0c0h ; mask to test for any parity error
par_ch1_mask equ 10000000b ; mask to test for system board parity error
par_ch2_mask equ 01000000b ; mask to test for i/o channel parity error
disa_ch1_mask equ 00010000b ; mask to disable system board parity checking
enab_ch1_mask equ 11101111b ; mask to enable system board parity checking
disa_ch2_mask equ 00100000b ; mask to disable i/o channel parity checking
enab_ch2_mask equ 11011111b ; mask to enable i/o channel parity checking
nmi_int_no equ 2 ; NMI interrupt number
nmi_port equ 0a0h ; NMI control port
enable_nmi equ 80h ; value to output to enable NMI
disable_nmi equ 0 ; value to output to disable NMI
;**************************************************************************
int_vecs segment at 0
int_vecs ends
page
;**************************************************************************
cseg segment
assume cs:cseg,ds:cseg
org 80h ; for processing command line parms.
cmd_ct label byte ; number of chars. in command line
org 100h ; for .COM file
entry:
jmp init ; ck for residency, init if not resident
reenable_flag db false ; enable continued checking after error?
active_page db ? ; current active page
curs_pos dw ? ; current cursor position
orig_nmi_int_vec dd ? ; pointer to orig. NMI service routine
start_row_1 equ $
par_ch1_msg db " PARITY CHECK 1 (System Board) "
length_row equ $ - offset start_row_1
par_ch2_msg db " PARITY CHECK 2 (I/O channel) "
msg_1 db " Parity error reporting for "
msg_1a db " this channel will be disabled "
msg_1b db " this channel will continue "
scn_storage dw (length_row * 5) dup (?) ; storage for current screen
; display
page
;**************************************************************************
;* This is the start of the new NMI interrupt handler code.
;*
;* 1. Check system board 8255 to determine if a parity error has occurred.
;* 2. If not, pass control to the original NMI vector.
;* 3. If a parity error has occurred:
;* a. Disable the NMI temporarily.
;* b. Determine which channel was affected and disable parity reporting.
;* c. Determine whether error reporting will continue, depending on
;* which installation option was selected.
;* d. Print appropriate message and loop for about 10 seconds.
;* e. Re-enable reporting on the error channel if the /R option was selected.
;* f. Re-enable the NMI.
nmi_int_hdlr proc
pushf ; if we jump to orig. vector, arrive in same condition
push ax ;
in al,port_c ; read 8255 port
test al,par_err_mask ; has a parity error occurred?
jnz nmi_1 ; yes, jump to error routine
pop ax ; else, restore entering machine state
popf ;
jmp cs:orig_nmi_int_vec ; and pass control to original vector
nmi_1:
push ax ; save value read from port c
mov al,disable_nmi ; disable NMI
out nmi_port,al ;
pop ax ; restore port c value
sti ; allow further interrupts
push bx ; save possibly affected registers
push cx ;
push dx ;
push si ;
push di ;
push bp ;
push ds ;
push es ;
push ax ; save port value again
mov ax,cs ; set DS and ES to CS
mov ds,ax ;
mov es,ax ;
call save_screen ; save contents of current display
pop ax ; restore port value
test al,par_ch2_mask ; test for i/o channel error
in al,port_b ; get value at 8255 port b
jnz nmi_2 ; jump if i/o channel error
mov ah,disa_ch1_mask ; else, put planar disabling mask in AH
mov si,offset par_ch1_msg ; put adr of system board msg in SI
jmp short nmi_3 ; and continue
nmi_2:
mov ah,disa_ch2_mask ; put i/o channel disabling mask in AH
mov si,offset par_ch2_msg ; put adr of i/o channel msg in SI
nmi_3:
or al,ah ; turn on proper bit
out port_b,al ; disable appropriate channel to reset
push ax ; save mask value in AH
mov ax,offset msg_1 ; put adr of 2nd line of message in AX
mov bx,offset msg_1a ; put adr of 'remain disabled' msg in BX
cmp reenable_flag,false ; is continued checking desired?
pushf ; save result of comparison
je nmi_4 ; no, continue
mov bx,offset msg_1b ; else, put 'reenable' msg adr in BX
nmi_4:
call print_msg ; display our message
; -- loop allow reading the message
mov cx,15 ; trying to hit 10 seconds...
nmi_5:
mov bx,cx ; save outer loop count
sub cx,cx ; do each inner loop 65536 times
nmi_6:
loop nmi_6 ; spin wheels...
nmi_7:
loop nmi_7 ; ...
mov cx,bx ; restore outer loop count
loop nmi_5 ; and spin some more until done...
call restore_screen ; restore original display
popf ; flags show if reenabling desired
pop ax ; restore mask value in AH
je nmi_8 ; continue if reenabling not wanted
not ah ; else, flip bits in AH
in al,port_b ; get 8255 port b value
and al,ah ; turn masked bit off again
out port_b,al ; and reenable the channel
nmi_8:
pop es ; restore machine state
pop ds ;
pop bp ;
pop di ;
pop si ;
pop dx ;
pop cx ;
pop bx ;
mov al,enable_nmi ; reenable NMI
out nmi_port,al ;
pop ax ;
popf ;
iret
nmi_int_hdlr endp
page
;**************************************************************************
; Save current contents of the portion of the screen we will overwrite.
; Also save the current active page and cursor position.
; Registers not preserved.
save_screen proc near
mov ah,vid_state ; get active page
int vidint ; bios video interrupt
mov active_page,bh ; store it for others..
mov ah,read_curs_pos ; get cursor position and type
int vidint ;
mov curs_pos,dx ; store data
mov dx,(disp_row * 256 + disp_col) ; cursor at start of our msg
mov cx,num_lines + 2 ; save enough for top & bot. blank
; lines, and our message
mov di,offset scn_storage ; point DI to buffer
ss_1:
push dx ; save cursor position
push cx ; save outer loop count
mov cx,length_row ; get number of chars. per row
ss_2:
push di ; save buffer ptr
mov ah,set_curs_pos ; set cursor pos.
int vidint ;
mov ah,read_ac ; get attr/char at curs. pos
int vidint ;
pop di ; restore buffer ptr.
stosw ; store attr/char in buffer
inc dl ; bump DL to next column
loop ss_2 ; do for the entire row
pop cx ; restore outer loop count
pop dx ; restore cursor position
inc dh ; bump DH to next row
loop ss_1 ; do for required number of rows
ret
save_screen endp
page
;**************************************************************************
; Restore original contents of the screen.
; Also restore the current cursor position.
restore_screen proc near
mov bh,active_page ; get active page in BH
mov dx,(disp_row * 256 + disp_col) ; cursor at start of our msg
mov cx,num_lines + 2 ; restore amount saved...
mov si,offset scn_storage ; point DI to buffer
rs_1:
push dx ; save cursor pos.
push cx ; save outer loop count
mov cx,length_row ; get number of chars. per row
push si ; save buffer ptr
rs_2:
mov ah,set_curs_pos ; set cursor pos.
int vidint ;
pop si ; restore buffer ptr
lodsw ; get the attr/char in AX, bump SI
push si ; save it...
mov bl,ah ; put attr. where bios wants it
mov ah,write_ac ; write attr/char at curs. pos
push cx ; save row chars remaining
mov cx,1 ; tell bios to write 1 char.
int vidint ;
pop cx ; restore row chars remaining
inc dl ; bump DL to next column
loop rs_2 ; do for the entire row
pop si ; keep stack in order....
pop cx ; restore outer loop count
pop dx
inc dh ; bump DH to next row
loop rs_1 ; do for required number of rows
mov dx,curs_pos ; restore original cursor pos
mov ah,set_curs_pos ;
int vidint ;
ret
restore_screen endp
page
;**************************************************************************
; Print message to console
; 1st and last line blanks - start at current curs. pos.
; SI has adr. of 1st string, AX has second, and BX has third.
print_msg proc near
push bx ; push string addresses
push ax ;
push si ;
mov al,bell ; first put out a beep
mov ah,write_teletype ;
int vidint ;
mov bl,reverse_blink ; reverse-video blinking vid. attrib.
mov bh,active_page ; get active page in BH
mov cx,length_row ; length of a row
mov dx,(disp_row * 256 + disp_col) ; cursor at start of our msg
call blank_line ; put out the first blank line
pop si ; address of 1st line
call char_line ;
pop si ; ...2nd line
mov bl,reverse ; don't blink for the rest of msg
call char_line ;
pop si ; ...3rd line
call char_line ;
call blank_line ; ... and last blank line
mov dx,curs_pos ; restore original cursor pos
mov ah,set_curs_pos ;
int vidint ;
ret
blank_line: ; write CX blanks, bump row position
mov ah,set_curs_pos ; set cursor pos.
int vidint ;
mov ah,write_ac ; write attr/char at curs. pos
mov al,' ' ; write blanks
int vidint ;
inc dh ; bump row position
ret
char_line:
; -- attrib. in BL, active page in BH, count in CX, starting pos. in DX
; get chars. starting at DS:SI
push cx ; save count of chars. in line
push dx ; save starting curs. pos.
push si ; save buffer ptr
cl_1:
mov ah,set_curs_pos ; set cursor pos.
int vidint ;
pop si ; restore buffer ptr
lodsb ; get char. from message string in AL
push si ; save bumped string ptr.
push cx ; save chars. remaining in line
mov cx,1 ; so bios will write one char.
mov ah,write_ac ; write attr/char at curs. pos
int vidint ;
pop cx ; restore chars. remaining in line
inc dl ; bump DL to next column
loop cl_1 ; do for the entire row
pop si ; keep stack in order....
pop dx ; restore starting curs. pos.
inc dh ; bump DH to next row
pop cx ; restore count of chars. in line
ret
print_msg endp
; -- This is the end of the code which will be made permanently resident.
end_nmi_int_hdlr equ $
len_nmi_int_hdlr equ (end_nmi_int_hdlr - nmi_int_hdlr)
page
;**************************************************************************
install_msg db cr,lf,"PARCHK (v 1.0) installed -- Copyright (C) 1984 Skip Gilbrech",cr,lf,'$'
resident_msg db cr,lf,bell,"PARCHK (v 1.0) already resident",cr,lf,'$'
usage_msg db cr,lf
db "PARCHK (v 1.0) -- Copyright (C) 1984 Skip Gilbrech",cr,lf,cr,lf
db "USAGE: PARCHK /R (or) /D",cr,lf
db "/R = Report all errors which occur",cr,lf
db "/D = Disable reporting after an error",cr,lf,cr,lf
db "PARCHK replaces the ibm pc rom-bios NMI (non-maskable interrupt) handler.",cr,lf
db "It will report any memory parity errors to the operator, but will allow",cr,lf
db "the system to continue running. An installation option lets you choose",cr,lf
db "whether or not to receive continued reports after the first error for",cr,lf
db "a particular channel (system memory or i/o channel). Regardless of the",cr,lf
db "option chosen, however, the first error for each channel will always be",cr,lf
db "reported. The source file, PARCHK.ASM, contains some cautions which",cr,lf
db "you should read before using this program.",cr,lf,cr,lf,'$'
page
;**************************************************************************
;* Initialization procedure:
;*
;* 1. Check whether the routine is already resident by getting the current
;* interrupt vector and checking whether our code is servicing it.
;* If so, just print message and exit without installing
;* 2. Check command line to see if continued checking is wanted after
;* error and set flag accordingly. If no parms or unknown parms,
;* print informational message and exit without installing.
;* 3. Otherwise, change vector to point to our handler, print installation
;* message, and execute dos 'terminate but stay resident' interrupt,
;* installing only the code which will actually be used.
;*
;* The idea, and much of the code, for the 'testresident' routine, came
;* from Tony A. Rhea's KEYSTAT program. His copyright notice is reproduced
;* below:
;*
;* KEYSTAT -- Copyright (C) 1983 Tony A. Rhea
;* This program may be copied for non-commercial use.
;* Adapted from KEYFLAGS (PC-World, Oct. 83, page 266) by Morton Kaplon
;*
init proc near
call testresident ; see if handler already resident,
jz init_1 ; ZF set = already resident -- print msg and exit
call get_parms ; see if reenabling NMI desired, set flag
jc init_2 ; if parm error, print usage message
; else, install the handler
mov al,nmi_int_no ; interrupt number in AL
mov ah,set_int_vec ; funct. number for set int. vector
mov dx,offset nmi_int_hdlr ; offset of resident code
int dosint ; set the vector
mov dx,offset install_msg ; print install message
mov ah,prt_str ;
int dosint ;
mov dx,offset end_nmi_int_hdlr ; set DX to end of resident code
int 27h ; dos terminate but stay resident func.
init_1:
mov dx,offset resident_msg ; msg showing already installed
jmp short init_3 ; print it and exit
init_2:
mov dx,offset usage_msg ; general info. msg.
init_3:
mov ah,prt_str ;
int dosint ;
int 20h ; return to dos (nothing made resident)
init endp
page
;**************************************************************************
;* see if our handler is already resident -- zero flag set if it is.
;*
;* AX, BX, CX, SI, DI changed, ES preserved
testresident proc near
push es ;
mov al,nmi_int_no ; interrupt number in AL
call get_vec ; interrupt vector returned in ES:BX
mov orig_nmi_int_vec,bx ; store IP of current servicer
mov orig_nmi_int_vec[2],es ; store CS of current servicer
mov cx,len_nmi_int_hdlr ; number of bytes to match
mov si,offset nmi_int_hdlr ; point DS:SI to our code
mov di,bx ; make ES:DI point to current handler
cld ; auto increment
repe cmpsb ; compare while equal - zero flag set on exit
; if all bytes matched (already resident)
pop es ;
ret
testresident endp
page
;**************************************************************************
;* Get interrupt vector for interrupt number in AL. On exit, ES:BX contain
;* CS:IP for vector.
;*
;* Only ES and BX changed
get_vec proc near
push ax ; save entering value
push ax ; save interrupt number requested
mov ah,get_vers ; dos get version function
int dosint ; major version returned in AL, minor in AH
pop bx ; restore int. number requested
cmp al,2 ; less than 2 = pre dos 2.0
jb gv_direct ; get vector directly
mov al,bl ; move requested interrupt vector into AL
mov ah,get_int_vec ; dos get int. vector function
int dosint ; CS:IP returned in ES:BX
pop ax ;
ret
gv_direct: ; get vector directly
; first, convert number in BL to offset in BX
xor bh,bh ; make sure BH = 0
shl bx,1 ; multiply by 4
shl bx,1 ;
mov ax,int_vecs ; point ES to segment for int. vectors
mov es,ax ;
mov ax,es:[bx+2] ; get CS value into AX
mov bx,es:[bx] ; get IP value into BX
mov es,ax ; mov CS value into ES
pop ax ;
ret
get_vec endp
page
;**************************************************************************
;* Scan command line for /R or /D installation option -- carry set
;* on exit if no valid parm.
;*
;* AX,BX,SI changed
get_parms proc near
mov bx,offset cmd_ct ; BX pts to number of cmd line chars
mov si,[bx] ; get count
inc bx ; point BX to 1st char
and si,0ffh ; max. 127 chars. - set flags
jz gp_err_exit ; no parms, skip the rest
mov byte ptr [bx][si],0 ; make command line null terminated
gp_top_loop:
mov al,[bx] ; get the char
or al,al ; null?
je gp_err_exit ; if so, return error
cmp al,spc ; space?
je gp_bot_loop ; yes, get another char
cmp al,tab ; tab?
je gp_bot_loop ; yes, get another char
cmp al,'/' ; see if possible /R or /D switch
jne gp_err_exit ; no, return error
call ck_switches ; check parm, carry set on error
jc gp_err_exit ; carry set, return error
jmp gp_exit ;
gp_bot_loop:
inc bx ; point to next char
jmp gp_top_loop ; go get it
gp_err_exit:
stc ; set carry to show error
gp_exit: ; if got here by jump, carry is reset
ret
ck_switches: ; ck parms ( BX pts to '/' )
inc bx ; point to possible switch
mov al,[bx] ; get char
cmp al,'Z' ; check if possibly upper-case
jbe ck_sw1 ; no? continue
sub al, 'a' - 'A' ; make upper-case
ck_sw1:
cmp al,'R' ; reenable checking after parity error?
jne ck_sw2 ; no? continue
mov reenable_flag,true ; else, set flag
ret ; and return
ck_sw2:
cmp al,'D' ; disable checking after error?
je ck_sw_exit ; yes, return ok
stc ; else, set carry to show error
ck_sw_exit:
ret
get_parms endp
cseg ends
end entry
XA 6: ; else, set carry to show error
ck_sw_exit:
ret
get_parms endp
cseg e
