; Drive detection by: Lee Hamel (hamell@cs.pdx.edu) - July 6th, 1994

; Partial credit to : Paul Schlyter

;

; Goes thru drives A-Z and determines if they:

; 1) Exist

; 2) Are removable or fixed

; 3) Are local, remote, or shared

; 4) Are a floppy, hard, RAM, subst, or CD-ROM drive

.model tiny

.286

DRIVEXISTS      EQU     1

REMOVEDRV       EQU     0

FIXEDDRV        EQU     1

LOCALDRV        EQU     0

REMOTEDRV       EQU     1

SHAREDRV        EQU     2

FLOPPY          EQU     0

HARD            EQU     1

RAM             EQU     2

SUBST           EQU     3

CDROM           EQU     4

.code

        org     100h

start:          mov     ah,19h

                int     21h             ; get start drive

                mov     [curdrive],al

                mov     ax,40h

                mov     es,ax

                mov     bh,es:[10h]     ; 40:10h is # of floppies-1

                shr     bh,6

                inc     bh              ; # of actual floppy drives

                mov     bl,1

                mov     di,offset drives

nextchkfloppy:  mov     ax,4409h        ; check if drive exists

                int     21h

                jc      nextsetfloppy

                test    dh,10000000b    ; check if SUBST drive

                jz      chkfloppy

                dec     bh              ; dec actual drive count

                mov     byte ptr [di 3],SUBST

setfloppyexist: mov     byte ptr [di],DRIVEXISTS

                jmp     nextsetfloppy

chkfloppy:      dec     bh              ; dec actual drive count

                js      nextsetfloppy

                mov     byte ptr [di 1],REMOVEDRV

                mov     byte ptr [di 3],FLOPPY

                jmp     setfloppyexist

nextsetfloppy:  add     di,4

                inc     bl

                cmp     bl,2            ; if B then jump back

                je      nextchkfloppy

                mov     ch,24           ; loop 24 times (drives C - Z)

                mov     cl,3            ; start at C:

drivechkloop:   mov     ax,4409h        ; check if drive exists

                mov     bl,cl           ; set drive letter

                int     21h             ; 0 = default, 1 = A:, etc.

                jc      nextsetdrv

                mov     byte ptr [di],DRIVEXISTS

                mov     ax,4408h        ; check if removable

                int     21h

                mov     byte ptr [di 1],al      ; set REMOVABLE or FIXED

                mov     bx,dx

                mov     dl,dh

                shr     dl,7

                and     dh,00010000b

                shr     dh,4

                mov     byte ptr [di 2],dh      ; set REMOTE or LOCAL

                or      dl,dl                   ; if not SUBST, then jump

                jz      chkremote

                mov     byte ptr [di 3],SUBST

                jmp     nextsetdrv

chkremote:      cmp     dh,REMOTEDRV    ; if REMOTE, then check for CD ROM

                je      chkcdrom

                test    bh,00000010b    ; sharable?

                jz      drivenoshare

                mov     byte ptr [di 2],SHAREDRV

drivenoshare:   test    bl,00000010b    ; RAM drive?

                jnz     nextsetdrv

                mov     byte ptr [di 3],RAM

                jmp     nextsetdrv

chkcdrom:       push    cx

                mov     ax,1500h

                xor     bx,bx

                int     2fh

                pop     cx

                or      bx,bx           ; MSCDEX driver found?

                jz      nextsetdrv      ; if not, jump to next drive setup

                mov     ax,150bh

                dec     cl              ; 0=A:, etc.

                int     2fh

                inc     cl

                or      ax,ax

                jz      nextsetdrv      ; drive supported by MSCDEX?

                mov     byte ptr [di 3],CDROM

nextsetdrv:     add     di,4

                inc     cl

                dec     ch

                jnz     drivechkloop

                mov     ah,0eh

                mov     dl,[curdrive]

                int     21h             ; reset start drive

                mov     cl,'A'          ; output all existing drives

                mov     di,offset drives

                mov     ah,9

drvdumploop:    cmp     byte ptr [di],DRIVEXISTS

                jne     nextdrvdump

                mov     al,cl

                int     29h

                xor     dh,dh

                mov     dl,byte ptr [di 1]

                shl     dx,4

                add     dx,offset removablemsg

                int     21h

                xor     dh,dh

                mov     dl,byte ptr [di 2]

                shl     dx,3

                add     dx,offset localmsg

                int     21h

                xor     dh,dh

                mov     dl,byte ptr [di 3]

                shl     dx,3

                add     dx,offset typemsg

                int     21h

                mov     dx,offset crlf

                int     21h

nextdrvdump:    add     di,4

                inc     cl

                cmp     cl,'Z'

                jbe     drvdumploop

                ret

curdrive        db      0

drives          db      26 dup(0,1,0,1)

        ; default to not exist, fixed, local, hard drive

crlf            db      10,13,'$'

removablemsg    db      ':    Removable $'

                db      ':        Fixed $'

localmsg        db      'Local  $'

                db      'Remote $'

                db      'Shared $'

typemsg         db      'Floppy $'

                db      'Hard   $'

                db      'RAM    $'

                db      'Subst  $'

                db      'CD-ROM $'

        end     start