Power-Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power-Programmierung / CD1.mdf / assemblr / library / sampler0 / parchk.asm < prev next >

Wrap

Assembly Source File | 1980-01-01 | 30.3 KB | 580 lines

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