Programmer 7500

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

/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / FLOPPIES / VHARD101.ZIP / VHARD.ASM < prev next >

Wrap

Assembly Source File | 1990-07-22 | 56.8 KB | 2,120 lines

title Fake hard disk driver subttl Prologue page 60,132 comment { ****************************************************************************** File VHARD.ASM Author: Aaron L. Brenner BIX mail address albrenner GEnie address A.BRENNER This program is hereby released to the public domain. Purpose: A DOS device driver that will make a floppy drive double as a small hard disk. This is accomplished by spreading the fake HD over a series of diskettes. The disks must be prepared (with VHPREP) by formatting to 10 sectors/track for a capacity of 400KB per diskette. Also, VHPREP will stamp each diskette with a unique ID built from the date and time the first diskette was prepared and the sequence number of it. VHPREP is also responsible for performing the low and high level format on all disks. Formatting is performed by the driver, but under VHPREP control. VHPREP communicates with the driver via a dummy character device driver named VHARDCTL, which will provide access to driver functions. The only driver command supported is IOCTL Write (all others are NOPs), and only 7 bytes are actually used. These 7 bytes are treated as a command block, structured as follows: Format command byte 0 byte track to format (head in bit 7, cylinder in low 7 bits) byte return status dword pointer to format parameter buffer (see details in int 13h) Read Track command byte 1 byte track to read (head in bit 7, cylinder in low 7 bits) byte return status dword pointer to buffer to read into Write Track command byte 2 byte track to write (head in bit 7, cylinder in low 7 bits) byte return status dword pointer to buffer to write from Verify Track command byte 3 byte track to verify (head in bit 7, cylinder in low 7 bits) byte return status Set FAT cache buffer byte 4 byte == 0, disable cache == 1, enable cache == 2, flush cache == 3, disable cache autoflush == 4, enable cache autoflush (DOS 3+, SHARE installed) == 5, return information about the cache byte return status dword pointer to cache buffer This command is used to enable or disable the FAT/directory cache. Once the cache is enabled, logical sectors 1 through 24 will be cached for both read and write. They will only be written when driver function 14 (Device close) is called AND the reference count is 0. To accomodate older versions of DOS, subcommand 2 will manually flush the cache to disk. Subcommands 3 & 4 will disable or enable the auto-flush. Retrieve Driver Data byte 5 byte unused byte set to 0 by VHARD dword pointer to buffer to receive the following data: byte drive number assigned by DOS word VHARD version 19 bytes BPB for VHARD Revision history: 0.90 06/27/90 ALB Created. This version uses 13 360KB diskettes for appx. 5MB of faked hard disk space. Note: cache handling is NOT yet implemented. ****************************************************************************** endcomment { subttl Included files page include dd_defs.inc include vhard.inc ; Some structures we use DEBUG equ 0 subttl Macros and templates page BIOS_seg segment at 40h org 62h active_page db ? org 84h crt_lines db ? BIOS_seg ends ;***************************************************************************** ; ; Version of VHARD ; ;***************************************************************************** VHARD_version equ 100h VHARD_text_ver equ <'1.00'> subttl Device driver headers page vhard_seg segment org 0 assume cs:vhard_seg, ds:nothing, es:nothing, ss:nothing ; ; Declare the header for the dummy char device used to communicate with ; the block driver ; dw offset next_hdr nextdvrseg dw -1 dw DA_IS_CHAR or DA_IOCTL dw strategy dw du_int db 'VHARDCTL' ; ; Declare the header for the device driver ; Attributes: ; block device ; removable media ; next_hdr dw -1, -1 dw DA_IS_BLK or DA_IS_REM dw strategy dw vh_int db 1, 'VHARD ' subttl Device driver data page ; ; Pointer passed by DOS to the request packet ; req_ptr dw 0, 0 ; ; Version of DOS ; dos_ver dw 0 ; ; Local copy of the diskette parameters ; diskparms db 4 dup(0) ; Gets filled in at init time sect_per_track db 0 ; Sectors per track (set at init time) gap_len db 0 db 0 fmt_gap_len db 0 db 3 dup(0) ; ; Save area for old parm pointer ; old_pptr dw 0, 0 ; ; ID and # for the current disk ; curr_disk_id db 'NO NAME',0 db 0 curr_disk_num db 0ffh ; ; Counter of how many sectors read/written ; io_count dw 0 ; ; Count of how many sectors to go ; io_to_go dw 0 ; ; Flag indicating whether or not we have EGA/VGA video available. This is used ; in the prompt_user routine - if have_evga != 0, then we read the number of ; character lines on screen from 40:84. If have_evga == 0, then we always use ; line 24. ; have_evga db 0 last_curs dw 0 ; ; If we're running under DOS 3.10 or higher, we get the drive number assigned ; from the the request block and save it here. ; our_drive db 0ffh ; ; Data used to manage the FAT/dir cache. ; cache_ptr dw 0,0 ; Pointer to the cache cache_flags db 0 ; Bit flags ; ; Messages that get displayed at various times ; need_disk db 'Put disk ID ' pr_disk_id db 8 dup(' ') db ' #' pr_disk_num db ' ' db ' in drive A:, then press a key',0 need_first_disk db 'Put disk #0 of the set you want to use' db ' in drive A:, then press a key',0 ; ; Save area for the chunk of screen we diddle ; screen_save dw 80 dup(0) ; ; Buffer for the boot sector (containing ID, etc.) ; boot_sect_buf db 512 dup(0) ;***************************************************************************** ; ; These 2 tables are used to translate BIOS error codes into the status codes ; expected by DOS and VHPREP, respectively ; ;***************************************************************************** DOS_sts_table db 80h, DE_NOT_READY db 40h, DE_SEEK_ERROR db 20h, DE_GEN_FAIL db 10h, DE_CRC_ERROR db 9, DE_WRITE_FAULT db 8, DE_WRITE_FAULT db 4, DE_NOT_FOUND db 3, DE_WRITE_PROT db 2, DE_GEN_FAIL db 1, DE_GEN_FAIL CMD_sts_table db 80h, STS_TIMEOUT db 40h, STS_BAD_SEEK db 20h, STS_BAD_NEC db 10h, STS_BAD_CRC db 9, STS_DMA_BOUND db 8, STS_BAD_DMA db 4, STS_NOT_FND db 3, STS_WRITE_PROT db 2, STS_ADDR_MARK db 1, STS_BAD_CMD ;***************************************************************************** ; ; BIOS parameter block (BPB) that DOS is going to use ; ;***************************************************************************** our_bpb DOS_BPB <512, 8, 1, 2, 256, (13 * 799), 0fch, 4, 47, 26, 0> our_bpb_array dw offset our_bpb ;***************************************************************************** ; ; For this version, at least, this driver will support the OPEN and CLOSE ; calls. These will increment and decrement a reference counter that will be ; used to know when to the write the FAT cache (if caching is enabled). ; ;***************************************************************************** ref_count dw 0 subttl Device driver STRATEGY and INTERRUPT routines page ;***************************************************************************** ; ; Strategy entry point. Used for both drivers ; ;***************************************************************************** strategy proc far mov cs:req_ptr[0],bx ; Save the pointer mov cs:req_ptr[2],es ; ret ; Return to DOS strategy endp ;***************************************************************************** ; ; Interrupt routine for the VH driver ; ;***************************************************************************** vh_int proc far assume ds:nothing, es:nothing call save_regs ; Save the registers cld ; Make sure of direction push cs ; Set DS to our segment pop ds ; assume ds:vhard_seg if DEBUG call dump_entry endif les si,dword ptr req_ptr ; Point to the request packet mov bl,es:[si].DDrh_command ; Get the command mov es:[si].DDrh_status,0 ; Default to no error cmp bl,DC_REM_MEDIA ; Check for the highest we support jbe vhint_l1 ; Use it - it's in range call err_fnc ; Return that it's a bad command jmp short vhint_exit ; And return vhint_l1: sub bh,bh ; Make the command a word shl bx,1 ; Now a word offset call vh_dispatch[bx] ; Vector to the routine les si,dword ptr req_ptr ; Point back to the request packet or es:[si].DDrh_status,DS_DONE; Say we're done vhint_exit: if DEBUG call dump_exit endif call rest_regs ; Restore the registers ret ; Return to DOS vh_int endp if DEBUG entry_str db 'Entry:',0 exit_str db 'Exit: ',0 dump_entry proc near mov si,offset entry_str jmp short dump_either dump_entry endp dump_exit proc near mov si,offset exit_str dump_either: call outp_str les si,req_ptr mov cl,es:[si] sub ch,ch dmpe_l1: mov al,' ' call outp_char lods byte ptr es:[si] call outp_byte loop dmpe_l1 mov al,13 call outp_char mov al,10 call outp_char ret dump_exit endp outp_str proc near lodsb or al,al jz otps_l1 call outp_char jmp short outp_str otps_l1: ret outp_str endp outp_char proc near push ax push dx sub ah,ah sub dx,dx int 17h pop dx pop ax ret outp_char endp outp_byte proc near push ax shr al,1 shr al,1 shr al,1 shr al,1 call outp_nyb pop ax outp_nyb: and al,0fh add al,90h daa adc al,40h daa call outp_char ret outp_byte endp endif ;***************************************************************************** ; ; Interrupt routine for the dummy VHARDCTL driver ; ;***************************************************************************** du_int proc far call save_regs ; Save all the registers push cs ; Set DS to our segment pop ds assume ds:vhard_seg les si,dword ptr req_ptr ; Point to the request packet mov bl,es:[si].DDrh_command ; Get the command cmp bl,DC_IOCTL_WRITE ; Check for the highest we support jbe duint_l1 ; Use it - it's in range call err_fnc ; Return that it's a bad command jmp short duint_exit ; And return duint_l1: sub bh,bh ; Make the command a word shl bx,1 ; Now a word offset call du_dispatch[bx] ; Vector to the routine les bx,dword ptr req_ptr ; Point back to the request packet or es:[bx].DDrh_status,DS_DONE; Say we're done mov es:[bx].DDir_count,size VH_CMD duint_exit: call rest_regs ; Restore them now ret ; Return to DOS du_int endp subttl Dispatch tables for INTERRUPT routines page ;***************************************************************************** ; ; Dispatch table for the VH driver ; ;***************************************************************************** vh_dispatch dw drv_init ; 0 - Init dw vh_med_check ; 1 - Media check dw vh_build_bpb ; 2 - Build BPB dw err_fnc ; 3 - IOCTL read (not supported) dw vh_read ; 4 - Read dw err_fnc ; 5 - Peek input (not for blk) dw err_fnc ; 6 - Input status (not for blk) dw err_fnc ; 7 - Input flush (not for blk) dw vh_write ; 8 - Write dw vh_write ; 9 - Write w/verify dw err_fnc ; A - Output status (not for blk) dw err_fnc ; B - Output flush (not for blk) dw err_fnc ; C - IOCTL write (not supported) dw vh_open ; D - Device open dw vh_close ; E - Device close dw vh_set_rem ; F - "Removable media" check du_dispatch dw du_init ; 0 - Init dw err_fnc ; 1 - Media check dw err_fnc ; 2 - Build BPB dw err_fnc ; 3 - IOCTL read (not supported) dw err_fnc ; 4 - Read dw err_fnc ; 5 - Peek input (not for blk) dw err_fnc ; 6 - Input status (not for blk) dw err_fnc ; 7 - Input flush (not for blk) dw err_fnc ; 8 - Write dw err_fnc ; 9 - Write w/verify dw err_fnc ; A - Output status (not for blk) dw err_fnc ; B - Output flush (not for blk) dw du_write ; C - IOCTL Write subttl Error function page ;***************************************************************************** ; ; Error function - sets the error bit to 1, and the error code to 3 (Unknown ; command). ; ;***************************************************************************** err_fnc proc near mov al,DE_BAD_COMMAND ; Set error code ; ; Alternate entry point. Call with AL set to error code ; err_return: mov ah,DS_ERROR shr 8 ; Set ERROR bit les bx,dword ptr req_ptr ; Point to the request packet mov es:[bx].DDrh_status,ax ; Set return status ret ; Return to caller err_fnc endp subttl Driver function 1 - Media check page ;***************************************************************************** ; ; Driver function 1 - Media check ; ;***************************************************************************** vh_med_check proc near assume ds:vhard_seg, es:nothing call set_disk_parms ; Set up the diskette parameters call check_boot_sect ; See if the disk ID has changed jc vhmc_error ; Exit if error jz vhmc_nochange ; Return properly if no change les si,dword ptr req_ptr ; Point to the DOS request block mov es:[si].DDmr_return,0ffh; Note that it's changed test cache_flags,CACHE_INSTALLED ; Is the cache there? jz vhmc_l1 ; Nope - never mind test cache_flags,CACHE_DIRTY ; Is there anything in it? jz vhmc_l1 ; Nope - never mind call do_flush_cache ; Flush the FAT cache vhmc_l1: and cache_flags,not (CACHE_VALID or CACHE_DIRTY) mov ref_count,0 ; Force the ref count to 0 call get_disk_0 ; Make sure we get the first disk cmp byte ptr dos_ver[0],3 ; Is it DOS 3.x (or higher)? jb vhmc_exit ; Nope - exit mov word ptr es:[si].DDmr_idptr[0],offset curr_disk_id mov word ptr es:[si].DDmr_idptr[2],cs jmp short vhmc_exit ; vhmc_nochange: les si,dword ptr req_ptr ; Point to the DOS request block mov es:[si].DDmr_return,1 ; Set the return value test cache_flags,CACHE_INSTALLED ; Is the cache there? jz vhmc_exit ; No - never mind test cache_flags,CACHE_VALID ; Does it hold valid data? jnz vhmc_exit ; Yep - just exit call get_disk_0 ; Load the cache jmp short vhmc_exit ; Exit now vhmc_error: mov ax,DE_NOT_READY ; call err_return ; Indicate the error vhmc_exit: call rest_disk_parms ; Restore the diskette parameters ret ; Return to dispatcher vh_med_check endp subttl Driver function 2 - Build BPB page ;***************************************************************************** ; ; Driver function 2 - Build BPB ; ; Also, the disk ID is gotten from the disk in the drive. If there is no disk ; in the drive, we prompt for it. ; ;***************************************************************************** vh_build_bpb proc near assume ds:vhard_seg, es:nothing save si, es mov word ptr es:[si].DDbr_bpb_ptr[0],offset our_bpb mov word ptr es:[si].DDbr_bpb_ptr[2],cs call get_disk_0 ; Get the first disk jnc vhbb_exit ; If they didn't press Esc, exit mov ax,DE_NOT_READY ; Say that the drive wasn't ready call err_return ; vhbb_exit: restore ret ; Return to DOS vh_build_bpb endp subttl Driver function 4 - Read page ;***************************************************************************** ; ; Driver function 4 - Read ; ;***************************************************************************** vh_read proc near assume ds:vhard_seg, es:nothing mov bp,offset sect_read ; Address of I/O routine jmp short vhwt_l1 ; Do the I/O operation vh_read endp subttl Driver functions 8 & 9 - Write & Write w/Verify page ;***************************************************************************** ; ; Driver function 8 - Write (also fn 9, Write w/Verify) ; ;***************************************************************************** vh_write proc near assume ds:vhard_seg, es:nothing mov bp,offset sect_write ; Point to the right routine vhwt_l1: call set_disk_parms ; Set up the diskette parameters mov ax,es:[si].DDir_start ; Get starting sector mov cx,es:[si].DDir_count ; Get the count les bx,es:[si].DDir_buffer ; Point to the buffer or ax,ax ; See if DOS wants a sector that falls jz vhwt_l99 ; in the range 1 to 24 cmp ax,24 ; ja vhwt_l99 ; test cache_flags,CACHE_INSTALLED ; Is the cache there? jz vhwt_l99 ; No - never mind test cache_flags,CACHE_VALID ; Do we have valid data in the cache? jz vhwt_l99 ; No - read from disk dec ax ; Adjust start sector for cache push cx ; Save the count mov cl,9 ; Make sector # offset into cache shl ax,cl ; pop cx mov dx,cx ; Turn sector count into byte count mov cl,9 ; shl dx,cl ; mov cx,dx ; cmp bp,offset sect_read ; Are we reading? jne vhwt_l2 ; No - set up for writing lds si,dword ptr cache_ptr ; Point to the cache add si,ax ; Point to start of first sector mov di,bx ; Point into the buffer jmp short vhwt_l3 ; Continue vhwt_l2: or cache_flags,CACHE_DIRTY ; The cache is dirty now push es ; Need DS:SI pointing to the buffer pop ds ; mov si,bx ; les di,dword ptr cs:cache_ptr; And ES:DI pointing to the cache add di,ax ; Point to the sector in the cache vhwt_l3: shr cx,1 ; Move as many words as possible rep movsw ; rcl cx,1 ; Move the odd byte rep movsb ; push cs ; Set DS back to our segment pop ds ; jmp short vhwt_exit ; Exit now vhwt_l99: call io_operation ; Do the I/O operation jnc vhwt_exit ; Exit if no error mov bx,offset DOS_sts_table ; Point to translation table call xlat_status ; Make it a DOS error code cmp al,DE_WRITE_FAULT ; Generic "Write Fault"? jne vhwt_err ; No - just exit cmp bp,offset sect_write ; Was it a write op? je vhwt_err ; Yep - never mind mov al,DE_READ_FAULT ; Make that a "Read Fault" vhwt_err: call err_return ; Return the error vhwt_exit: call rest_disk_parms ; Restore the disk parameters ret ; Return to int routine vh_write endp ;***************************************************************************** ; ; Perform a disk I/O operation. ; ; Input: ; AX starting sector ; CX # of sectors ; ES:BX pointer to buffer ; BP address of routine to call to read or write ; ; Output: ; CF = 1 an error occurred ; AL = error code to return ; CF = 0: ; CX number of sectors actually transferred ; ; Registers: ; All but AX and CX preserved. ; ;***************************************************************************** io_operation proc near mov io_to_go,cx ; Save count as number to do mov di,ax ; Save start sector for a bit sub ax,ax ; Figure out if it could wrap dec ax ; sub ax,bx ; mov cl,9 ; shr ax,cl ; cmp ax,io_to_go ; Can it hold that many? jae io_op1 ; Yep - never mind mov io_to_go,ax ; Set to just that many io_op1: sub ax,ax ; Clear the current count mov io_count,ax ; mov ax,di ; Get the starting sector back call calc_disk ; Figure out where that is call get_num_disk ; Get the right disk jc io_op_error ; Don't bother if they hit Esc or error ; ; At this point, we have figured out what disk to use, and it's in the drive. ; Now, all we have to do is start reading or writing. ; mov al,11 ; Figure out how many sectors to start sub al,cl ; cbw ; mov si,ax ; Save it for later io_op3: cmp si,io_to_go ; See if there are that many to go jbe io_op4 ; Yep - just do the operation mov si,io_to_go ; Just do that many mov ax,si ; io_op4: call bp ; Call the appropriate routine jc io_op_err2 ; Exit if error io_op5: add io_count,si ; Add to number complete sub io_to_go,si ; Knock that many off the count to do jz io_op_exit ; If it went to 0, we're done mov ax,si ; push cx ; Save it (gets used for shift count) mov cl,9 ; Multiply by 512 shl ax,cl ; pop cx ; add bx,ax ; Move the buffer pointer jnc io_op6 ; If it wraps, we're done clc ; No error jmp short io_op_exit ; Just exit io_op6: mov al,10 ; Do 10 the next time 'round cbw ; mov si,ax ; mov cl,1 ; Start at sector 1 xor dh,1 ; Next head (0 or 1) jnz io_op3 ; If just going to other head, loop inc ch ; Next track cmp ch,40 ; Still on this disk? jb io_op3 ; Yep - do more I/O inc curr_disk_num ; Next disk mov al,curr_disk_num ; Get the disk number call get_num_disk ; Get that disk in the drive jc io_op_error ; Exit if error or Esc pressed mov cx,2 ; Start back at track 0, sector 2 mov ax,9 ; Do up to 9 more sectors on next disk mov si,ax ; jmp short io_op3 ; Loop back io_op_error: mov ah,80h ; Say that it wasn't ready io_op_err2: stc ; io_op_exit: mov cx,io_count ; Get number transferred ret ; Return to caller io_operation endp subttl Driver function 0DH - Device open page ;***************************************************************************** ; ; Driver function 0DH - Device open ; ;***************************************************************************** vh_open proc near inc ref_count ; Just increment the reference count ret ; Return to caller vh_open endp subttl Driver function 0EH - Device close page ;***************************************************************************** ; ; Driver function 0EH - Device close ; ;***************************************************************************** vh_close proc near dec ref_count ; Decrement the reference count jnz vhcl_exit ; If there are still files open, exit test cache_flags,CACHE_INSTALLED ; Is the cache there? jz vhcl_exit ; Nope - just exit test cache_flags,CACHE_AUTO ; Do we want to flush automagically? jz vhcl_exit ; Nope - just exit test cache_flags,CACHE_DIRTY ; Is the cache dirty? jz vhcl_exit ; Nope - never mind call set_disk_parms ; Set up the diskette parameters call do_flush_cache ; Flush that cache call rest_disk_parms ; Get the old diskette parms back vhcl_exit: ret ; Return to caller vh_close endp subttl Driver function 0FH - "Removable media" check page ;***************************************************************************** ; ; Driver function 0FH - "Removable media" check ; ;***************************************************************************** vh_set_rem proc near and es:[si].DDrh_status,not DS_BUSY ; Say we're removable ret ; Return to caller vh_set_rem endp subttl Cache functions page ;***************************************************************************** ; ; Flush the FAT/root dir cache ; ; Registers: ; All preserved. ; ;***************************************************************************** do_flush_cache proc near assume ds:vhard_seg, es:nothing save ax, bx, cx, bp, es les bx,dword ptr cache_ptr ; Point to the cache mov bp,offset sect_write ; Routine to do the I/O dflc_l1: mov ax,1 ; Start with logical sector 1 mov cx,24 ; Write 24 Sectors call io_operation ; jc dflc_l1 ; No matter what, it must be done and cache_flags,not CACHE_DIRTY ; Turn off the "dirty" bit restore ret ; Return to caller do_flush_cache endp subttl VHARDCTL IOCTL write function page ;***************************************************************************** ; ; This is the only driver function supported by the dummy control driver ; VHARDCTL. It dispatches to one of the commands. ; On entry, ES:SI points to the driver request packet. ; ;***************************************************************************** du_write proc near assume ds:vhard_seg, es:nothing mov es:[si].DDrh_status,0 ; Start with no error les bx,es:[si].DDir_buffer ; Point to the buffer mov al,es:[bx].VC_cmd_code ; Get the command to perform cmp al,LAST_CMD ; Valid command? jbe duwr_ok ; Yep - dispatch it call err_fnc ; Report an invalid driver command jmp short duwr_exit ; Exit now duwr_ok: cbw ; Make it a word shl ax,1 ; Make it a dispatch table offset mov di,ax ; Into a usable register call cmd_dispatch[di] ; Call the routine duwr_exit: ret ; Return to caller du_write endp subttl VHARDCTL handling routines page ;***************************************************************************** ; ; The following routines handle the commands to VHARDCTL. Each of them expects ; ES:BX to point to the command block (NOT the driver request block!), and ; DS to be the same as CS. ; ;***************************************************************************** ;***************************************************************************** ; ; Called when VHARDCTL gets a "Format Track" command ; ;***************************************************************************** cmd_format_trk proc near assume ds:vhard_seg, es:nothing push bp ; Save retry counter call set_disk_parms ; Set up the diskette parameters mov al,es:[bx].VC_track ; Get the track/head to format mov ch,7fh ; Mask to keep track and ch,al ; Get the track rol al,1 ; Get the head and al,1 ; mov dh,al ; Get the head in the right place mov dl,$OUR_DRIVE ; mov bp,3 ; 3 tries cfmt_l1: mov ax,50ah ; Format command push es ; Save these push bx ; les bx,es:[bx].VC_buffer ; Point to the buffer int 13h ; Call BIOS to do it pop bx ; Get pointer back pop es ; jnc cfmt_l3 ; If it went, continue dec bp ; Count off a try jz cfmt_l2 ; If it failed, return error mov ah,0 ; Do a disk reset int 13h ; jnc cfmt_l1 ; If it FAILED to reset, drop cfmt_l2: push bx ; Save cmd block ptr mov bx,offset CMD_sts_table ; Point to translation table call xlat_status ; Translate to our error code pop bx ; Point back to the cmd block mov es:[bx].VC_status,al ; Set the return status jmp short cfmt_exit ; Exit now cfmt_l3: mov es:[bx].VC_status,STS_OK; Report success cfmt_exit: call rest_disk_parms ; Restore the diskette parameters pop bp ; Get back what we used ret ; Return to caller cmd_format_trk endp ;***************************************************************************** ; ; Called when VHARDCTL gets a "Read Track" command ; ;***************************************************************************** cmd_read_trk proc near call set_disk_parms ; Set up the diskette parameters mov al,es:[bx].VC_track ; Get the track to read mov ch,7fh ; Get mask for the track and ch,al ; Get the track mov cl,1 ; Start with sector 1 rol al,1 ; Get the head and al,1 ; Mask it out mov dh,al ; Into the right register mov dl,$OUR_DRIVE ; Drive to read from mov al,10 ; Number to read push bx ; Save this ptr so we can set status push es ; les bx,es:[bx].VC_buffer ; Point to the buffer call sect_read ; Try to read 'em pop es ; Restore the pointer pop bx ; jnc crdt_ok ; If ok, return success push bx mov bx,offset CMD_sts_table ; Point to the translation table call xlat_status ; Get the status code we want pop bx ; Get the pointer back mov es:[bx].VC_status,al ; Set the return status jmp short crdt_exit ; Exit now crdt_ok: mov es:[bx].VC_status,STS_OK; Return that it succeeded crdt_exit: call rest_disk_parms ; Restore the diskette parameters ret ; Return to caller cmd_read_trk endp ;***************************************************************************** ; ; Called when VHARDTCL gets a "Write Track" command ; ;***************************************************************************** cmd_write_trk proc near call set_disk_parms ; Set up the diskette parameters mov al,es:[bx].VC_track ; Get the track to write mov ch,7fh ; Get mask for the track and ch,al ; Get the track mov cl,1 ; Start with sector 1 rol al,1 ; Get the head and al,1 ; Mask it out mov dh,al ; Into the right register mov dl,$OUR_DRIVE ; Drive to write to mov al,10 ; Number to write push bx ; Save this ptr so we can set status push es ; les bx,es:[bx].VC_buffer ; Point to the buffer call sect_write ; Try to write 'em pop es ; Restore the pointer pop bx ; jnc cwrt_ok ; If ok, return success push bx mov bx,offset CMD_sts_table ; Point to the translation table call xlat_status ; Get the status code we want pop bx ; Get the pointer back mov es:[bx].VC_status,al ; Set the return status jmp short cwrt_exit ; Exit now cwrt_ok: mov es:[bx].VC_status,STS_OK; Return that it succeeded cwrt_exit: call rest_disk_parms ; Restore the diskette parameters ret ; Return to caller cmd_write_trk endp ;***************************************************************************** ; ; Called when VHARDCTL gets a "Verify Track" command ; ;***************************************************************************** cmd_verify_trk proc near call set_disk_parms ; Set up the diskette parameters mov al,es:[bx].VC_track ; Get the track to verify mov ch,7fh ; Get mask for the track and ch,al ; Get the track mov cl,1 ; Start with sector 1 rol al,1 ; Get the head and al,1 ; Mask it out mov dh,al ; Into the right register mov dl,$OUR_DRIVE ; Drive to read from mov al,10 ; Number to verify call sect_verify ; Try to verify 'em jnc crdt_ok ; If ok, return success push bx mov bx,offset CMD_sts_table ; Point to the translation table call xlat_status ; Get the status code we want pop bx ; Get the pointer back mov es:[bx].VC_status,al ; Set the return status jmp short crdt_exit ; Exit now cvft_ok: mov es:[bx].VC_status,STS_OK; Return that it succeeded cvft_exit: call rest_disk_parms ; Restore the diskette parameters ret ; Return to caller cmd_verify_trk endp ;***************************************************************************** ; ; Called when VHARDCTL gets a "Set Cache" command ; ; There are 5 sub-commands supported. The subcommand is gotten from the byte ; used by the other routines to specify the track. ; ; The 6 sub-commands are: ; 0 disable the cache ; On return, the status byte will be set to either STS_OK, ; STS_NOT_ENAB (meaning that the cache is not installed), or ; STS_CACHE_DIRTY (meaning that the cache needs to be flushed). ; If the cache is successfully disabled, the VC_track byte will ; be set to the current flags for the cache and the VC_buffer ; will be set to the address of the cache. ; 1 enable the cache ; On return, the status byte will be set to either STS_OK or ; STS_ALREADY (meaning that the cache is already installed). ; If the cache is already installed, the VC_track byte will be ; set to the current flags for the cache and the VC_buffer will ; be set to the current cache address. ; 2 flush the cache ; On return, the status byte will be set to indicate the result. ; If the cache isn't dirty, this is a no-op. ; ; 3 disable cache autoflush ; ; 4 enable cache autoflush. VHCACHE will only make this call if ; the DOS version is 3.00 or higher AND SHARE.EXE is loaded. ; ; 5 get cache status. Returns the following at VC_buffer: ; byte cache flags ; dword address of cache ; ;***************************************************************************** cmd_set_cache proc near mov al,es:[bx].VC_track ; Get the sub-command cmp al,5 ; See if it's valid jbe cmsc_l1 ; Yep - handle it mov es:[bx].VC_status,STS_UNK_CMD ; Return a bad command ret ; Return to caller cmsc_l1: cbw ; Make it a word shl ax,1 ; Make it a table offset mov di,ax ; Into a pointer reg jmp cache_dispatch[di] ; Switch to the appropriate routine cmd_set_cache endp ;***************************************************************************** ; ; Handle a "Cache Disable" command ; ; If the cache isn't enabled, return STS_NOT_ENAB. ; If the CACHE_DIRTY bit is set (meaning that the cache needs to be flushed), ; set ES:[BX].VC_track to the current cache flags, set ES:[BX].VC_buffer to ; point to the cache, and return STS_CACHE_DIRTY. ; ; Otherwise, disable it, set ES:[BX].VC_track to the current ; cache flags, set ES:[BX].VC_buffer to point to the cache, and return STS_OK. ; ;***************************************************************************** disable_cache proc near test cache_flags,CACHE_INSTALLED ; Is the cache installed? jnz dsch_l1 ; Yep - see if it's dirty mov es:[bx].VC_status,STS_NOT_ENAB ; Return it wasn't installed jmp short dsch_exit ; Exit now dsch_l1: test cache_flags,CACHE_DIRTY ; Is the cache dirty? jz dsch_l2 ; Nope - disable it mov al,cache_flags ; Get the current flags mov es:[bx].VC_track,al ; Return 'em mov al,STS_CACHE_DIRTY ; Report it's dirty jmp short dsch_l3 ; Continue dsch_l2: mov al,STS_OK ; Return it's ok mov cache_flags,0 ; Get rid of all cache flags dsch_l3: mov es:[bx].VC_status,al ; Save return status mov ax,cache_ptr[0] ; Return address of cache mov word ptr es:[bx].VC_buffer[0],ax; mov ax,cache_ptr[2] ; mov word ptr es:[bx].VC_buffer[2],ax; dsch_exit: ret ; Return to caller disable_cache endp ;***************************************************************************** ; ; Handle a "Cache Enable" command. ; ; If the cache is enabled already, set ES:[BX].VC_track to the current cache ; flags, set ES:[BX].VC_buffer to point to the cache, and return STS_ALREADY. ; ; Otherwise, set our internal cache pointer to ES:[BX].VC_buffer, set the ; cache flags to CACHE_INSTALLED, and return STS_OK. ; ;***************************************************************************** enable_cache proc near test cache_flags,CACHE_INSTALLED ; Is it installed? jz ench_l1 ; No - install now mov es:[bx].VC_status,STS_ALREADY ; Say it's already installed mov al,cache_flags ; Get the current flags mov es:[bx].VC_track,al ; Return 'em mov ax,cache_ptr[0] ; Return cache address mov word ptr es:[bx].VC_buffer[0],ax; mov ax,cache_ptr[2] ; mov word ptr es:[bx].VC_buffer[2],ax; jmp short ench_exit ; Exit now ench_l1: ; ; The cache isn't installed yet. Install it now. ; Address is in ES:[BX].VC_buffer. ; mov ax,word ptr es:[bx].VC_buffer[0]; Point to new cache mov cache_ptr[0],ax ; mov ax,word ptr es:[bx].VC_buffer[2]; mov cache_ptr[2],ax ; mov cache_flags,CACHE_INSTALLED ; mov es:[bx].VC_status,STS_OK ; Return ok status ench_exit: ret enable_cache endp ;***************************************************************************** ; ; Handle a "Flush Cache" command. ; ; If the cache is not installed, return STS_NOT_ENAB. ; ; If the cache is not dirty, return STS_OK. ; ; Otherwise, try to flush the cache, returning the status from the disk I/O ; operation. ; ;***************************************************************************** flush_cache proc near test cache_flags,CACHE_INSTALLED ; Is the cache installed? jnz flch_l1 ; Yep - see if it's dirty mov al,STS_NOT_ENAB ; Return that it ain't there jmp short flch_done flch_l1: test cache_flags,CACHE_DIRTY ; Is it dirty? jz flch_ok ; No - just return ok call set_disk_parms ; Set the diskette parameters call do_flush_cache ; Do the flush pushf ; Save result flag call rest_disk_parms ; Restore the parameters popf ; Get error flag back jnc flch_ok ; If it went, return success push bx ; Save command blk ptr mov bx,offset CMD_sts_table ; Point to translate table call xlat_status ; Translate the status pop bx ; jmp short flch_done ; Exit now flch_ok: mov al,STS_OK ; Return success flch_done: mov es:[bx].VC_status,al ; Save the status ret flush_cache endp ;***************************************************************************** ; ; Handle the "Disable Auto-Flush" command. ; ; If the cache is not installed, return STS_NOT_ENAB. ; ;***************************************************************************** disab_auto proc near test cache_flags,CACHE_INSTALLED ; Is that baby installed? jnz dsau_l1 ; Yep - disable autoflush mov es:[bx].VC_status,STS_NOT_ENAB ; Return it ain't there jmp short dsau_exit ; Exit now dsau_l1: mov es:[bx].VC_status,STS_OK ; Return success and cache_flags,not CACHE_AUTO ; Disable it dsau_exit: ret ; Return to caller disab_auto endp ;***************************************************************************** ; ; Handle the "Enable Autoflush" command ; ; If the cache is not installed, return STS_NOT_ENAB. ; ;***************************************************************************** enab_auto proc near test cache_flags,CACHE_INSTALLED ; Is that baby installed? jnz enau_l1 ; Yep - disable autoflush mov es:[bx].VC_status,STS_NOT_ENAB ; Return it ain't there jmp short enau_exit ; Exit now enau_l1: mov es:[bx].VC_status,STS_OK ; Return success or cache_flags,CACHE_AUTO ; Enable it enau_exit: ret ; Return to caller enab_auto endp ;***************************************************************************** ; ; Handle a "Get Cache Information" command. ; ; Returns the cache flags and the address of the cache. ; ;***************************************************************************** get_cache_info proc near mov es:[bx].VC_status,STS_OK; Always returns success les di,es:[bx].VC_buffer ; Point to the buffer mov al,cache_flags ; Get the current cache flags stosb ; Return 'em mov ax,cache_ptr[0] ; Get the cache address offset stosw ; Stuff it mov ax,cache_ptr[2] ; Same with the cache address segment stosw ; ret ; Return to caller get_cache_info endp ;***************************************************************************** ; ; Called when VHARDCTL gets a "Get Driver Data" command. This copies data from ; our data area into the buffer. ; Data returned in the buffer: ; byte drive number assigned by DOS ; word VHARD version ; struc BPB used ; ;***************************************************************************** cmd_get_vhdata proc near les di,es:[bx].VC_buffer ; Point to their buffer mov al,our_drive ; Get the drive number stosb ; Store it mov ax,VHARD_version ; Store the driver version stosw ; mov si,offset our_bpb ; Copy our BPB mov cx,size DOS_BPB ; rep movsb ; ret ; Return to caller cmd_get_vhdata endp ;***************************************************************************** ; ; This dispatch table is used to handle the special commands called via ; VHARDCTL. ; ;***************************************************************************** cmd_dispatch dw cmd_format_trk ; Format a track dw cmd_read_trk ; Read a track dw cmd_write_trk ; Write a track dw cmd_verify_trk ; Verify a track dw cmd_set_cache ; Deal with the cache dw cmd_get_vhdata ; Get data ;***************************************************************************** ; ; Yet another dispatch table (this one's for the cache commands) ; ;***************************************************************************** cache_dispatch dw disable_cache ; Disable the cache dw enable_cache ; Enable the cache dw flush_cache ; Flush the cache dw disab_auto ; Disable auto-flush dw enab_auto ; Enable auto-flush dw get_cache_info ; Get cache information subttl Utility routines page ;***************************************************************************** ; ; U T I L I T Y R O U T I N E S ; ;***************************************************************************** ;***************************************************************************** ; ; Save all registers ; ;***************************************************************************** save_regs proc near assume ss:nothing save ax, bx, cx, dx, si, di, ds, es mov ax,bp ; Get current BP value mov bp,sp ; Point into the stack xchg ax,[bp + 16] ; Swap it with the return address push ax ; Put that on the stack mov ax,[bp + 14] ; Set AX back to original value mov bp,[bp + 16] ; Same with BP ret ; Return to caller save_regs endp ;***************************************************************************** ; ; Restore all registers ; ;***************************************************************************** rest_regs proc near pop ax ; Get return address mov bp,sp ; Get a pointer into the stack xchg ax,[bp + 16] ; Swap retaddr with the saved BP value mov bp,ax ; This restores BP restore ret ; Return to caller rest_regs endp ;***************************************************************************** ; ; Read sectors from disk. ; ; Input: ; DH Head number ; CH Track number ; CL Starting sector number ; AL Number of sectors to read ; ES:BX Address of buffer ; ; Output: ; AH Status returned by BIOS ; CF Error indicator ; ; Registers: ; BP preserved, all others trashed. ; ;***************************************************************************** sect_read proc near save si, bp mov bp,3 ; Retry 3 times mov si,ax ; Save # of sectors sctr_l1: mov ah,2 ; BIOS function to read mov dl,$OUR_DRIVE ; Drive to read from int 13h ; Call the BIOS to do the work jnc sctr_exit ; If it went, exit now dec bp ; That was 1 try jz sctr_exit ; If that was the last, exit mov ah,0 ; Do a reset int 13h ; jc sctr_exit ; If that fails, we got problems... mov ax,si ; Get # to read again jmp short sctr_l1 ; Try again sctr_exit: restore ret ; Return to caller sect_read endp ;***************************************************************************** ; ; Verify sectors. ; ; Input: ; DH Head number ; CH Track number ; CL Starting sector number ; AL Number of sectors to verify ; ; Output: ; AH Status returned by BIOS ; CF Error indicator ; ; Registers: ; BP preserved, all others trashed. ; ;***************************************************************************** sect_verify proc near save si, bp mov bp,3 ; Retry 3 times mov si,ax ; Save # of sectors sctv_l1: mov ah,4 ; BIOS function to verify mov dl,$OUR_DRIVE ; Drive to read from int 13h ; Call the BIOS to do the work jnc sctv_exit ; If it went, exit now dec bp ; That was 1 try jz sctv_exit ; If that was the last, exit mov ah,0 ; Do a reset int 13h ; jc sctv_exit ; If that fails, we got problems... mov ax,si ; Get # to read again jmp short sctv_l1 ; Try again sctv_exit: restore ret ; Return to caller sect_verify endp ;***************************************************************************** ; ; Write sectors to disk. ; ; Input: ; DH Head number ; CH Track number ; CL Starting sector number ; AL Number of sectors to write ; ES:BX Address of buffer ; ; Output: ; AH Status returned by BIOS ; CF Error indicator ; ; Registers: ; BP preserved, all others trashed. ; ;***************************************************************************** sect_write proc near save si,bp mov bp,3 ; Retry 3 times mov si,ax ; Save # to write sctw_l1: mov ah,3 ; BIOS function to write mov dl,$OUR_DRIVE ; Drive to write to int 13h ; Call the BIOS to do the work jnc sctw_exit ; If it went, exit now dec bp ; That was 1 try jz sctw_exit ; If that was the last, exit mov ah,0 ; Do a reset int 13h ; jc sctw_exit ; If that fails, we got problems... mov ax,si ; Get # to write jmp short sctw_l1 ; Try again sctw_exit: restore ret ; Return to caller sect_write endp ;***************************************************************************** ; ; Set the diskette parameters for 10 sectors per track ; ; Input: ; None. ; ; Output: ; An internal copy of the parameters is made, the address at the vector ; for int 1eh is saved, and the vector is set to point to our copy. ; ; Registers: ; All preserved. ; ;***************************************************************************** set_disk_parms proc near assume ds:vhard_seg, es:nothing save cx, si, di, es push ds ; Save our segment, too sub si,si ; Set it to segment for int vectors mov ds,si ; lds si,ds:[1eh * 4] ; Point to the current disk parms mov cs:old_pptr[0],si ; Save it for restore later mov cs:old_pptr[2],ds ; push cs ; Set ES to our segment pop es assume ds:nothing, es:vhard_seg mov di,offset diskparms ; Point to our copy of the parameters mov cx,11 ; Only need 11 bytes cld ; Make sure of direction rep movsb ; Copy them pop ds ; Get our segment back assume ds:vhard_seg mov sect_per_track,10 ; Set that aright mov gap_len,14h mov fmt_gap_len,20h sub cx,cx ; Point back to the vectors mov es,cx ; mov word ptr es:[1eh * 4],offset diskparms mov es:[(1eh * 4) + 2],cs ; Set pointer to new parms restore ret ; Return to caller set_disk_parms endp ;***************************************************************************** ; ; Restore the diskette parameters ; ; Input: ; None. ; ; Output: ; The vector for int 1eh is restored. ; ; Registers: ; All preserved. ; ;***************************************************************************** rest_disk_parms proc near assume ds:vhard_seg, es:nothing save ax, es sub ax,ax ; Get segment for int vectors mov es,ax ; mov ax,old_pptr[0] ; Restore the old parm pointer mov es:[1eh * 4],ax ; mov ax,old_pptr[2] ; mov es:[(1eh * 4) + 2],ax ; restore ret ; Return to caller rest_disk_parms endp ;***************************************************************************** ; ; Translate a BIOS error code to a status code according to the table at BX. ; ; Input: ; AH BIOS return code ; DS:BX Pointer to translation table ; ; Output: ; AL Corresponding status code ; ; Registers: ; AX trashed; all others preserved ; ;***************************************************************************** xlat_status proc near assume ds:vhard_seg save bx, cx mov cx,10 ; Check for 10 BIOS codes xlts_l1: cmp ah,[bx] ; Is it this one? je xlts_l2 ; Yep - return the status code inc bx ; Point to next one inc bx loop xlts_l1 ; mov al,STS_BAD_ERROR ; Unknown error code jmp short xlts_exit xlts_l2: mov al,1[bx] ; Get the corresponding status code xlts_exit: restore ret ; Return to caller xlat_status endp ;***************************************************************************** ; ; Calculate the disk, track, head, and sector for a given logical sector. ; ; Input: ; AX DOS' logical sector ; ; Output: ; AX Disk number ; DH Head number ; CH Track number ; CL Sector number ; ; Registers: ; All register not used for parameters are preserved. ; ;***************************************************************************** calc_disk proc near save bx, si mov bx,799 ; Divide by # of sectors/disk sub dx,dx ; to get AX = disk #, div bx ; DX = logical sector on that disk mov si,ax ; Save the disk # mov ax,dx ; Get the logical sector on the disk inc ax ; Allow for boot sector mov bx,10 ; Divide by # of sectors/track sub dx,dx ; to get AX = track, div bx ; DX = logical sector on the track mov cl,dl ; Get the sector inc cl ; Since sectors start at 1... shr ax,1 ; Figure out the cylinder rcl dh,1 ; Set DH to the head mov ch,al ; Return the track mov ax,si ; Get the disk # back restore ret ; Return to caller calc_disk endp ;***************************************************************************** ; ; Read in the boot sector, checking to see if the ID matches our current ID. ; ; Input: ; curr_disk_id the ID we're expecting. ; ; Output: ; CF = 1 if the diskette can't be read ; ZF = 1 if the disk IDs match ; ; Registers: ; All preserved. ; ;***************************************************************************** check_boot_sect proc near assume ds:vhard_seg, es:vhard_seg save ax, bx, cx, dx, si, di, es push cs ; Make sure ES is right pop es assume es:vhard_seg call read_boot_sect ; Try to read the boot sector jc ckbs_exit ; Return w/error flag set if problem mov si,offset boot_sect_buf.BS_disk_id mov di,offset curr_disk_id mov cx,8 ; Check 8 bytes rep cmpsb ; clc ; Clear error flag ckbs_exit: restore ret ; Return to caller check_boot_sect endp ;***************************************************************************** ; ; Read the boot sector of the diskette in drive A: into the buffer at ; boot_sect_buf. ; ; Input: ; None. ; ; Output: ; CF = 0 Success. ; = 1 Unable to read the diskette. ; ; Registers: ; All preserved. ; ;***************************************************************************** read_boot_sect proc near assume ds:vhard_seg, es:nothing save ax, bx, cx, dx, es mov dh,0 ; Need to read Track 0, Head 0, Sect 1 mov cx,1 ; mov al,1 ; Just 1 sector push cs ; Into our buffer pop es ; assume es:vhard_seg mov bx,offset boot_sect_buf ; call sect_read ; Read it restore ; assume es:nothing ret ; Return to caller read_boot_sect endp ;***************************************************************************** ; ; Save the last line of the screen, display a prompt there, and wait for a ; keystroke. ; ; Input: ; DS:SI pointer to prompt to display ; ; Output: ; CF = 1 Esc was pressed ; ; Registers: ; All preserved. ; ;***************************************************************************** prompt_user proc near assume ds:vhard_seg, es:nothing save ax, bx, cx, dx, si, es mov dh,24 ; Assume no EGA/VGA mov ax,40h ; Get at the number of lines on screen mov es,ax ; assume es:BIOS_seg cmp have_evga,0 ; Do we have an EGA/VGA on board? je prpu_l1 ; No - use line 24 mov dh,es:[crt_lines] ; Get last line on screen prpu_l1: mov bh,es:[active_page] ; Get the current video page push cs ; Set ES to our segment pop es ; assume es:vhard_seg push dx ; Save line to use mov ah,3 ; Get the current cursor position int 10h ; mov last_curs,dx ; Save it pop dx ; mov dl,0 ; Start at the beginning of the line mov bl,4fh ; Use hi-white on red mov cx,1 ; Only doing 1 char at a time mov di,offset screen_save ; Point to save area prpu_l2: lodsb ; Get a character to display or al,al ; Done yet? jz prpu_l3 ; Yep - exit push ax ; Save it for a sec mov ah,2 ; Set the cursor position int 10h ; mov ah,8 ; Read the char/attr there int 10h ; stosw ; Save it pop ax ; Get the new one back mov ah,9 ; Write that character int 10h ; inc dl ; Next column jmp short prpu_l2 ; Loop back for more prpu_l3: mov ah,1 ; See if there are any keys int 16h ; jz prpu_l31 ; No - wait for one mov ah,0 ; Read the key int 16h ; jmp short prpu_l3 ; Loop until buffer is empty prpu_l31: sub ah,ah ; Read a key int 16h ; push ax ; Save the key read mov si,offset screen_save ; Point back to the save area mov dl,0 ; Start back at the beginning of line prpu_l4: cmp si,di ; Reached the end yet? je prpu_l5 ; Nope - keep restoring lodsw ; Get char/attr mov bl,ah ; Get the attribute for the write push ax ; Save the character to write mov ah,2 ; Set the cursor int 10h ; pop ax ; Get the character back mov ah,9 ; Write it out now int 10h inc dl ; Next column jmp short prpu_l4 prpu_l5: mov ah,2 ; Set cursor back to last position mov dx,last_curs ; int 10h ; pop ax ; Get keystroke back cmp ax,11bh ; Escape key? je prpu_exit ; Yep - return w/CF=1 stc ; Return CF=0 prpu_exit: cmc ; Make CF the way we want restore ret ; Return to caller prompt_user endp ;***************************************************************************** ; ; Prompt for a specific disk, waiting for a key. ; ; Input: ; curr_disk_id ID of the disk set ; curr_disk_num disk number to prompt for ; ; Output: ; CF = 1 The user pressed Esc. This indicates that they ; want an error returned to DOS. ; ; Registers: ; All preserved. ; ;***************************************************************************** prompt_for_disk proc near assume ds:vhard_seg, es:nothing save ax, cx, si, di, es push cs ; Make sure ES is right pop es ; assume es:vhard_seg mov si,offset curr_disk_id ; Point to the ID to ask for mov di,offset pr_disk_id ; Point to where to put it mov cx,4 ; Copy 8 bytes (4 words) rep movsw ; mov al,curr_disk_num ; Get the number to ask for aam ; Split it up or ax,3030h ; Make it 2 ASCII digits xchg al,ah ; Put 'em in the right order mov word ptr pr_disk_num,ax ; Store 'em in the string mov si,offset need_disk ; Point to the prompt string call prompt_user ; Prompt them for it restore ret ; Return to caller prompt_for_disk endp ;***************************************************************************** ; ; Prompt for the first disk of a set, and make sure it's loaded. ; ; Input: ; None. ; ; Output: ; CF = 0 Disk is successfully loaded ; ; Reserved: ; All preserved. ; ;***************************************************************************** get_disk_0 proc near save ax, bx, cx, si, di, bp, es call read_boot_sect ; Load the boot sector jnc gtd0_l2 ; If we got it, continue gtd0_l1: mov si,offset need_first_disk; Prompt for a disk call prompt_user ; jc gtd0_exit ; Exit if Esc pressed call read_boot_sect ; Read the boot sector jc gtd0_l1 ; Loop back if unable gtd0_l2: cmp boot_sect_buf.BS_disk_num,0 ; Is it disk 0? jne gtd0_l1 ; No - try again mov si,offset boot_sect_buf.BS_disk_id ; Copy disk ID mov di,offset curr_disk_id ; mov cx,4 ; push cs ; pop es ; rep movsw ; mov curr_disk_num,0 ; Set the disk to 0 test cache_flags,CACHE_INSTALLED ; Is the cache there? jz gtd0_l3 ; No - just get the ID test cache_flags,CACHE_VALID ; Is it already valid? jnz gtd0_l3 ; Yep - just get the ID mov bp,offset sect_read ; Routine to use for the I/O mov ax,1 ; Start at sector 1 mov cx,24 ; Read 24 sectors les bx,cache_ptr ; Point to the cache call io_operation ; Read 'em jc gtd0_exit ; If error, return it or cache_flags,CACHE_VALID ; It's got valid data now gtd0_l3: clc ; Indicate success gtd0_exit: restore ret ; Return to caller get_disk_0 endp ;***************************************************************************** ; ; Prompt for a disk, and make sure it's loaded ; ; Input: ; AL Number of disk to prompt for ; ; Output: ; CF = 0 Disk is successfully loaded ; ; Registers: ; All preserved. ; ;***************************************************************************** get_num_disk proc near cmp curr_disk_num,0ffh ; Do we have one yet? mov curr_disk_num,al ; jne gtnd_l1 ; Yes - never mind call get_disk_0 ; Get disk 0 to get a disk ID jc gtnd_exit ; Exit if unable or al,al ; Do we want disk 0? jz gtnd_l2 ; Yep - don't bother reading again gtnd_l1: call check_boot_sect ; Check the boot sector jc gtnd_exit ; Exit if error jnz gtnd_l11 ; If IDs don't match, prompt for it cmp al,boot_sect_buf.BS_disk_num ; Right number? je gtnd_l2 ; Yep - exit w/CF clear gtnd_l11: call prompt_for_disk ; Prompt for the disk jc gtnd_exit ; Exit if Esc was pressed jmp short gtnd_l1 ; Loop back now gtnd_l2: clc ; Clear error flag gtnd_exit: ret ; Return to caller get_num_disk endp $drv_end label byte subttl INIT routines for both drivers page ;***************************************************************************** ; ; INIT routine for VHARD itself ; ;***************************************************************************** drv_init proc near assume ds:vhard_seg, es:nothing mov es:[si].DDir_media_id,1 ; Just 1 unit mov word ptr es:[si].DDir_buffer,offset $drv_end mov word ptr es:[si].DDir_buffer[2],cs mov word ptr es:[si].DDir_count,offset our_bpb_array mov word ptr es:[si].DDir_start,cs mov ah,30h ; Get the DOS version int 21h ; xchg al,ah ; mov dos_ver,ax ; Save it cmp ax,30ah ; At least 3.10? jb drvi_l0 ; Nope - can't get the drive mov al,byte ptr es:22[si] ; Get the drive assigned mov our_drive,al ; Save it drvi_l0: mov ax,1a00h ; See if there's a VGA on board mov bx,0a5a5h ; int 10h ; cmp bx,0a5a5h ; Did it change? jne drvi_l1 ; Yep - say that we have EGA/VGA mov ah,12h ; See if we have an EGA mov bx,0ff10h ; int 10h ; cmp bh,0ffh ; Did it change? je drvi_exit ; No - no EGA or VGA drvi_l1: or have_evga,1 ; Set the flag drvi_exit: mov dx,offset banner ; Display the program banner mov ah,9 ; int 21h ; ret ; Return to dispatcher drv_init endp banner db 13, 10, 'VHARD virtual disk driver v' % db VHARD_text_ver db ' - Public Domain Software', 13, 10, '$' du_init proc near mov word ptr es:[si][0].DDir_buffer,offset $drv_end mov word ptr es:[si][2].DDir_buffer,cs ret du_init endp vhard_seg ends end