Blame |
Last modification |
View Log
| Download
| RSS feed
| ?url?
;******************************************************************************
;* *
;* SECDRIVE - Treiber fuer einen 2. HD-Kontroller im PC *
;* *
;* Historie: 12. 8.1993 Grundsteinlegung, Definitionen *
;* 16. 8.1993 Dispatcher *
;* Basislesefunktionen *
;* 17. 8.1993 Partitionsinformationen zusammenkratzen *
;* 18. 8.1993 Laufwerksparameter initialisieren *
;* 19. 8.1993 Zylinder/Sektorregister setzen *
;* Partitiossektorbaum durchgehen *
;* 24. 8.1993 BPB aufbauen *
;* 25. 8.1993 Parameteruebersetzung *
;* Einlesen *
;* Sektoren schreiben *
;* 26. 8.1993 Fehlerbehandlung *
;* Verify *
;* 1. Restore-Versuch mit Seek *
;* 7. 9.1993 Versuch Version 1.39 mit Proc's *
;* 28. 9.1993 etwas gekrzt *
;* 27.12.1994 leichte Korrekturen im Restore *
;* 28.12.1994 Trennung Low-Level-Routinen begonnen *
;* 19. 1.1995 Fehlermeldungen im Klartext *
;* *
;******************************************************************************
;******************************************************************************
;* globale Definitionen *
;******************************************************************************
; A C H T U N G : Mono.SYS muá fr Debugging geladen sein !!!!
debug equ 0
debug2 equ 0
include bitfuncs.inc
cpu 80186 ; WD 1003 fordert min. 80286
Diag_NoError equ 01h ; Selbstdiagnosecodes: kein Fehler
Diag_ContError equ 02h ; Controller-Fehler
Diag_SBufError equ 03h ; Sektorpuffer defekt
Diag_ECCError equ 04h ; Fehlerkorrektor defekt
Diag_ProcError equ 05h ; Steuerprozessor defekt
Diag_Timeout equ 06h ; Controller antwortet nicht
ParTab struct
BFlag db ? ; Partitionseintrag: Partition aktiv ?
FHead db ? ; Startkopf
FSecCyl dw ? ; Startzylinder/sektor
Type db ? ; Partitionstyp
LHead db ? ; Endkopf
LSecCyl dw ? ; Endzylinder/sektor
LinSec dd ? ; Anzahl Sektoren
NSecs dd ? ; linearer Startsektor
endstruct
DErr_WrProtect equ 00h ; Treiberfehlercodes: Schreibschutz
DErr_InvUnit equ 01h ; unbekannte Geraetenummer
DErr_NotReady equ 02h ; Laufwerk nicht bereit
DErr_Unknown equ 03h ; Unbekannes Treiberkommando
DErr_CRCError equ 04h ; Pruefsummenfehler
DErr_InvBlock equ 05h ; ungueltiger Request-Header
DErr_TrkNotFnd equ 06h ; Spur nicht gefunden
DErr_InvMedia equ 07h ; Unbekanntes Traegerformat
DErr_SecNotFnd equ 08h ; Sektor nicht gefunden
DErr_PaperEnd equ 09h ; Papierende im Drucker
DErr_WrError equ 0ah ; allg. Schreibfehler
DErr_RdError equ 0bh ; allg. Schreibfehler
DErr_GenFail equ 0ch ; allg. Fehler
DErr_InvChange equ 0fh ; unerlaubter Diskettenwechsel
DErr_UserTerm equ 0ffh ; Fehlercode Abbruch durch Benutzer
SecSize equ 512 ; Sektorgroesse in Bytes
MaxPDrives equ 2 ; Maximalzahl physikalischer Laufwerke
MaxDrives equ 10 ; Maximalzahl verwaltbarer Laufwerke
MaxParts equ 4 ; Maximalzahl Partitionen in einem Sektor
MaxRetry equ 2 ; max. 2 Lese/Schreibversuche
StackSize equ 512 ; etwas mehr wg. Rekursion
DrPar_Offset equ 1aeh ; Offset Parametertabelle im Part.-Sektor
ParTab_Offset equ 1beh ; Offset Partitionstabelle " " "
ParSecID_Offset equ 1feh ; Offset Partitionssektorflag (55aa)
BPBOfs equ 11 ; Offset BPB im Bootsektor
INT_DOS equ 21h ; DOS-Funktionsaufruf
INT_Mono equ 60h ; Haken zum VT100-Treiber
INT_Clock equ 1ah ; BIOS-Uhreneinstieg
INT_Keyboard equ 16h ; BIOS-Tastatureinstieg
DOS_WrString equ 9 ; DOS-Funktionen
DOS_WrChar equ 6
DOS_RdString equ 10
DOS_RdChar equ 8
HD_ID equ 0f8h ; Media-ID fuer Festplatten
CR equ 13
LF equ 10
BEL equ 7
ESC equ 27
AUML equ 84h
OUML equ 94h
UUML equ 81h
SZLIG equ 0e1h
;******************************************************************************
; Makros *
;******************************************************************************
;jmp macro adr
; !jmp long adr
; endm
beep macro
push ax
mov ax,0e07h
int 10h
pop ax
endm
PrMsg macro Adr ; Meldung ausgeben
push dx ; Register retten
lea dx,[Adr]
mov ah,DOS_WrString
int INT_DOS
pop dx ; Register zurueck
endm
PrChar macro Zeichen ; Zeichen ausgeben
push dx ; Register retten
push ax
mov dl,Zeichen
mov ah,DOS_WrChar
int INT_DOS
pop ax
pop dx ; Register zurueck
endm
;------------------------------------------------------------------------------
btst macro op,bit ; ein einzelnes Bit testen
test op,(1<<bit)
endm
;------------------------------------------------------------------------------
ljnz macro adr ; lange Spruenge
jz Next
jmp adr
Next:
endm
ljne macro adr
je Next
jmp adr
Next:
endm
ljc macro adr
jnc Next
jmp adr
Next:
endm
lje macro adr
jne Next
jmp adr
Next:
endm
ljz macro adr
jnz Next
jmp adr
Next:
endm
ljb macro adr
jnb Next
jmp adr
Next:
endm
;------------------------------------------------------------------------------
proc macro name
section name
public name:parent
name label $
endm
globproc macro name
section name
public name
name label $
endm
endp macro
endsection
endm
;------------------------------------------------------------------------------
; Fehlermakro
JmpOnError macro Drv,Adr
jnc GoOn ; kein Fehler, weitermachen
mov ah,Drv
call WrErrorCode ; Fehler-->ausgeben...
jmp Adr ; ...Abbruch
GoOn:
endm
;******************************************************************************
;* Treiberkopf *
;******************************************************************************
assume cs:code,ds:nothing,ss:nothing,es:nothing
org 0
DriverHead: dd -1 ; Zeiger auf Nachfolger
dw 0000100000000010b ; Attribut
; ^ ^ ^
; | | +- kann 32-Bit-Setornummern verarbeiten
; | +----------- kennt Close/Open/Removeable
; +--------------- Blocktreiber
dw StrategyProc ; Zeiger auf Strategieroutine
dw InterruptProc ; Zeiger auf eigentlichen Treibercode
NrOfVols: db 0 ; Zahl log. Laufwerke
db "SECDRIV" ; bei Blocktreibern unbenutzt
;******************************************************************************
;* residente Daten *
;******************************************************************************
Rh_Ptr dd ? ; Speicher fuer Request-Header
JmpTable dw Init ; Sprungtabelle: Initialisierung
dw MediaCheck ; Medium gewechselt ?
dw BuildBPB ; Parameterblock laden
dw IOCTLRead ; Steuerdaten vom Treiber
dw Read ; Daten lesen
dw ND_Read ; Lesen, ohne Pufferstatus zu ndern
dw InputStatus ; Daten im Eingabepuffer ?
dw InputFlush ; Eingabepuffer loeschen
dw Write ; Daten schreiben
dw Write_Verify ; Daten mit Prueflesen schreiben
dw OutputStat ; Ausgabepuffer leer ?
dw OutputFlush ; Ausgabepuffer loeschen
dw IOCTLWrite ; Steuerdaten zum Treiber
dw DeviceOpen ; DOS hat eine Datei darauf geoeffnet
dw DeviceClose ; DOS hat eine Datei darauf geschlossen
dw Removeable ; Ist Datentraeger wechselbar ?
dw OutputTillBusy ; Ausgabe, bis Puffer voll
dw GenIOCTL ; genormtes IOCTL
dw GetLogical ; Laufwerkszuordnung lesen
dw SetLogical ; Laufwerkszuordnung setzen
dw IOCTLQuery ; Abfrage, ob GenIOCTL unterstuetzt
SectorBuffer: db SecSize dup (?) ; Sektorpuffer fuer Treiber selber
db StackSize dup (?) ; Treiberstack
DriverStack:
BPBSize equ 36
DrTab struct ; Laufwerkstabelle:
StartHead db ? ; Startkopf
StartCyl dw ? ; Startzylinder
StartSec db ? ; Startsektor
LinStart dd ? ; lin. Startsektor
SecCnt dd ? ; Gesamtsektorzahl
Drive db ? ; Laufwerk
BPB db BPBSize dup (?) ; BPB
endstruct
DrTab db DrTab_Len*MaxDrives dup (?)
DrTab_BPBs dd 2*MaxDrives dup (?)
DrCnt db 0 ; Anzahl gefundener Laufwerke
DrOfs db 0 ; erster freier Laufwerksbuchstabe
DrPar struct ; Plattenparametersatz:
Cyls dw ? ; Zylinderzahl
Heads db ? ; Kopfzahl
RedWr dw ? ; Startzylinder reduzierter Schreibstrom
PrComp dw ? ; Startzylinder Praekompensation
ECCLen db ? ; max. korrigierbarer Fehlerburst (Bits)
CByte db ? ; Wert fuers Plattensteuerregister
TOut db ? ; genereller Timeout
FTOut db ? ; Timeout Formatierung
CTOut db ? ; Timeout fuer Pruefung
LZone dw ? ; Landezylinder
NSecs db ? ; Sektorzahl
Dummy db ? ; unbenutzt
endstruct
DrPars db DrPar_Len*MaxPDrives dup (0)
;******************************************************************************
;* Strategieroutine *
;******************************************************************************
StrategyProc: mov word ptr [Rh_Ptr],bx ; Zeiger speichern
mov word ptr [Rh_Ptr+2],es
retf
;******************************************************************************
;* Treiberdispatcher *
;******************************************************************************
Rh struct
Size db ? ; gemeinsame Headerteile: Laenge Block
Unit db ? ; angesprochenes Laufwerk
Func db ? ; Treibersubfunktion
Status dw ? ; Ergebnis
Resvd db 8 dup (?) ; unbenutzt
endstruct
InterruptProc: pusha ; alle Register retten
cli ; Stack umschalten
mov si,ss ; alten zwischenspeichern
mov di,sp
mov ax,cs ; neuen setzen
mov ss,ax
lea sp,[DriverStack]
push di ; alten auf neuem (!) speichern
push si
sti
mov ax,cs ; DS auf Treibersegment
mov ds,ax
assume ds:code
les bx,[Rh_Ptr] ; Zeiger laden
mov word ptr es:[bx+Rh_Status],0 ; Status loeschen
mov al,es:[bx+Rh_Func] ; Subfunktion ausrechnen
if debug
call PrByte
endif
mov ah,0
add ax,ax
mov si,ax
jmp JmpTable[si]
jmp Init
;******************************************************************************
;* gemeinsames Ende *
;******************************************************************************
StateError: btst al,1 ; Bit 1: Spur 0 nicht gefunden
jz StateError_N1
mov al,DErr_TrkNotFnd
jmp StateError_End
StateError_N1: btst al,2 ; Bit 2: abgebrochenes Kommando
jz StateError_N2
btst ah,5 ; Bit S5: Schreibfehler
jz StateError_N21
mov al,DErr_WrError
jmp StateError_End
StateError_N21: btst ah,4 ; Bit S4: Positionierung nicht vollstaendig
jnz StateError_N22
mov al,DErr_TrkNotFnd
jmp StateError_End
StateError_N22: btst ah,6 ; Bit S6: Laufwerk nicht bereit
jnz StateError_N23
mov al,DErr_NotReady
jmp StateError_End
StateError_N23: mov al,DErr_GenFail ; Notnagel 1
jmp StateError_End
StateError_N2: test al,11h ; Bit 0/4: Sektor nicht gefunden
jz StateError_N3
mov al,DErr_SecNotFnd
jmp StateError_End
StateError_N3: btst al,6 ; Bit 6: Pruefsummenfehler
jz StateError_N4
mov al,DErr_CRCError
jmp StateError_End
StateError_N4: mov al,DErr_GenFail ; Notnagel 2
StateError_End: les bx,[Rh_Ptr] ; Code einspeichern
mov es:[bx+Rh_Status],al
jmp Error
Unknown: les bx,[Rh_Ptr]
mov byte ptr es:[bx+Rh_Status],DErr_Unknown ; unbek. Funktion
Error: or byte ptr es:[bx+Rh_Status+1],80h ; Fehler-Flag setzen
jmp Done
Busy: les bx,[Rh_Ptr]
or byte ptr es:[bx+Rh_Status+1],2 ; Busy-Flag setzen
Done: les bx,[Rh_Ptr]
or byte ptr es:[bx+Rh_Status+1],1 ; Done-Flag setzen
if debug
call NxtLine
endif
cli ; Stack zurueckschalten
pop si
pop di ; alten in SI:DI laden
mov sp,di ; einschreiben
mov ss,si
sti
popa ; Register zurueck
retf
;******************************************************************************
;* Debugginghilfe *
;******************************************************************************
if debug||debug2
HexTab db "0123456789ABCDEF"
PrByte: push es ; Register retten
push di
push bx
push ax
lea bx,[HexTab]
db 0d4h,10h ; AAM 16
push ax
mov al,ah
xlat
mov ah,0eh
int 10h
pop ax
xlat
mov ah,0eh
int 10h
pop ax ; Register zurueck
pop bx
pop di
pop es
ret
PrWord: xchg ah,al ; Hi-Byte
call PrByte
xchg ah,al
call PrByte
ret
PrChar: push ax
mov ah,0eh
int 10h
pop ax
ret
NxtLine: push ax ; Register retten
push bx
push dx
mov ax,0e0dh
int 10h
mov ax,0e0ah
int 10h
pop dx ; Register zurueck
pop bx
pop ax
endif
;******************************************************************************
;* residente Subfunktionen *
;******************************************************************************
;******************************************************************************
;* eine logische Laufwerksnummer ueberpruefen *
;* In : AL = Laufwerk *
;* Out : C = 1, falls Fehler *
;******************************************************************************
proc ChkDrive
cmp al,[DrCnt] ; C=1, falls < (d.h. OK)
cmc ; Deshalb noch einmal drehen
jnc OK ; C=0, alles in Butter
les bx,[Rh_Ptr] ; ansonsten Fehlerstatus setzen
mov byte ptr es:[bx+Rh_Status],DErr_InvUnit
OK: ret
endp
;******************************************************************************
;* Adresse der phys. Laufwerkstabelle errechnen *
;* In : AL = Laufwerk *
;* Out : DI = Adresse *
;******************************************************************************
proc GetPTabAdr
mov ah,DrPar_Len ; relative Adresse berechnen
mul ah
lea di,[DrPars] ; Offset dazu
add di,ax
ret
endp
;******************************************************************************
;* Adresse eines Partitionsdeskriptors errechnen *
;* In : AL = log. Laufwerk *
;* Out : DI = Adresse *
;******************************************************************************
proc GetTabAdr
mov ah,DrTab_Len ; relative Adresse berechnen
mul ah
lea di,[DrTab] ; Offset dazu
add di,ax
ret
endp
;******************************************************************************
;* logische Parameter in physikalische uebersetzen *
;* In : BL = log. Laufwerk *
;* DX:AX = relative Sektornummer *
;* Out : AL = phys. Laufwerk *
;* AH = Kopf *
;* BX = Zylinder *
;* CH = Sektor *
;******************************************************************************
proc TranslateParams
push di ; Register retten
xchg bx,ax ; Adresse Parametertabelle holen
call GetTabAdr
add bx,[di+DrTab_LinStart] ; in absolute Sektornummer
adc dx,[di+DrTab_LinStart+2] ; umrechnen
mov al,[di+DrTab_Drive] ; phys. Laufwerksnummer holen
push ax ; bis zum Ende retten
call GetPTabAdr ; von dieser phys. Platte die Tabelle holen
mov ax,bx ; Sektor# wieder nach DX:AX
mov bl,[di+DrPar_NSecs] ; Sektorzahl auf 16 Bit
mov bh,0 ; aufblasen
div bx
mov ch,dl ; Modulo-Rest ist Sektornummer auf
inc ch ; Spur: Vorsicht, Numerierung ab 1 !!!
sub dx,dx ; wieder auf 32 Bit erweitern
mov bl,[di+DrPar_Heads] ; Kopfnummer herausfummeln
div bx
mov bx,ax ; Quotient ist Zylinder
pop ax ; Laufwerk zurueck
mov ah,dl ; Rest ist Kopf
pop di ; Register zurueck
ret
endp
;******************************************************************************
;* Einbindung Low-Level-Routinen *
;******************************************************************************
; definiert werden muessen:
; LowLevelIdent: Meldung ueber unterstuetzte Hardware ausgeben
; ContDiag: Kontroller-Selbsttest durchfuehren
; Ergebniskode in AL
; Recalibrate: Laufwerk [AL] auf Zylinder 0 fahren
; Fehlerflag in C, Fehlerkode in AX
; SetDriveParams: dem Kontroller die Geometrie fuer Laufwerk [AL] einbleuen
; Fehlerflag in C
; ReadSectors: von Laufwerk [AL] ab Zylinder [BX], Kopf [AH], Sektor [CH]
; [CL] Sektoren in Puffer ab ES:DI lesen
; Fehlerflag in C, Fehlerkode in AX
; WriteSectors: auf Laufwerk [AL] ab Zylinder [BX], Kopf [AH], Sektor [CH]
; [CL] Sektoren von Puffer ab ES:SI schreiben
; Fehlerflag in C, Fehlerkode in AX
; VeriSectors: auf Laufwerk [AL] ab Zylinder [BX], Kopf [AH], Sektor [CH]
; [CL] Sektoren verifizieren
; Fehlerflag in C, Fehlerkode in AX
; FormatUnit: Laufwerk [AL] mit Interleave [AH] formatieren, Fehlerkode
; in AX
; FormatTrack: Zylinder [BX], Kopf [AH] auf Laufwerk [AL] mit Interleave
; [CL] formatieren, Fehlerkode in AX
; MarkBad: Zylinder [BX], Kopf [AH] auf Laufwerk [AL] als defekt
; markieren, Fehlerkode in AX
include "lowlevel.inc"
;******************************************************************************
;* Bootsektor eines log. Laufwerkes lesen *
;* In : AL = Laufwerksnummer *
;* Out : C+AX = Fehlerstatus *
;******************************************************************************
proc ReadBootSec
push es ; Register retten
push bx
push cx
push di
call GetTabAdr ; Eintrag in Laufwerkstabelle ermitteln
mov al,[di+DrTab_Drive] ; davon ersten Sektor lesen
mov ah,[di+DrTab_StartHead]
mov bx,[di+DrTab_StartCyl]
mov cl,1
mov ch,[di+DrTab_StartSec]
mov di,cs
mov es,di
lea di,[SectorBuffer]
call ReadSectors
pop di ; Register zurueck
pop cx
pop bx
pop es
ret
endp
;******************************************************************************
;* Funktion 1: Test, ob Medium gewechselt *
;******************************************************************************
proc MediaCheck
Rh_MediaID equ Rh_Resvd+8 ; erwartetes Media-ID
Rh_Return equ Rh_MediaID+1 ; Ergebnis-Flag
Rh_VolName equ Rh_Return+1 ; Adresse alter Laufwerksname
cmp byte ptr es:[bx+Rh_MediaID],HD_ID ; gueltige ID ?
je OK
mov byte ptr es:[bx+Rh_Status],DErr_InvMedia ; nein...
jmp Error
OK: mov byte ptr es:[bx+Rh_Return],1 ; nie gewechselt
jmp Done
endp
;******************************************************************************
;* Funktion 2: BPB aufbauen *
;******************************************************************************
proc BuildBPB
Rh2 struct
db Rh_Len dup (?)
MediaID db ? ; erwartetes Media-ID
FATSector dd ? ; Pufferadresse 1. FAT-Sektor
BPBAddress dd ? ; Adresse neuer BPB
endstruct
mov al,es:[bx+Rh_Unit]
call ChkDrive ; Laufwerksnummer gueltig ?
ljc Error ; nein-->Fehler & Ende
call ReadBootSec ; Bootsektor lesen
ljc StateError ; bei Fehlern Ende
les bx,[Rh_Ptr] ; Zeiger neu laden
mov al,es:[bx+Rh_Unit] ; Tabellenadresse aufbauen
call GetTabAdr
lea di,[di+DrTab_BPB] ; DI auf BPB-Speicher
mov es:[bx+Rh2_BPBAddress],di ; BPB-Zeiger abspeichern
mov es:[bx+Rh2_BPBAddress+2],cs
mov si,cs ; BPB umkopieren
mov es,si
lea si,[SectorBuffer+BPBOfs]
cld
mov cx,BPBSize
rep movsb
jmp Done
endp
;******************************************************************************
IOCTLRead: jmp Unknown
;******************************************************************************
;* Funktion 4: Sektoren lesen *
;******************************************************************************
Rh4 struct
db Rh_len dup (?)
MediaID db ? ; Media-ID Laufwerk
BufOfs dw ? ; Adresse Datenpuffer
BufSeg dw ?
NSecs dw ? ; Anzahl zu lesender Bloecke
FirstSec dw ? ; Startsektor bzw. $FFFF fuer 32-Bit-Nummern
VolID dd ? ; Adresse Laufwerksname
LFirstSec dw ? ; lange Startsektornummer
HFirstSec dw ?
endstruct
Read: mov al,es:[bx+Rh_Unit] ; Laufwerksnummer pruefen
call ChkDrive
ljc Error
mov ch,al ; Laufwerksnummer retten
mov ax,es:[bx+Rh4_FirstSec] ; Sektor holen (BIGDOS beachten)
sub dx,dx
cmp ax,-1
jne Read_SmallSec
mov ax,es:[bx+Rh4_LFirstSec]
mov dx,es:[bx+Rh4_HFirstSec]
Read_SmallSec: mov cl,es:[bx+Rh4_NSecs] ; Sektorzahl laden (muss <=128 sein)
les di,es:[bx+Rh4_BufOfs] ; Zieladresse laden
mov bl,ch ; Laufwerksnummer nach BL
if debug
push ax
push cx
mov cx,ax
mov al,' '
call PrChar
mov al,bl ; Laufwerksnummer
call PrByte
mov al,' '
call PrChar
mov ax,dx ; Startsektor
call PrWord
mov ax,cx
call PrWord
mov al,' '
call PrChar
pop cx
mov al,cl ; Sektorzahl
call PrByte
mov al,' '
call PrChar
mov ax,es ; Startadresse
call PrWord
mov al,':'
call PrChar
mov ax,di
call PrWord
pop ax
endif
call TranslateParams ; umrechnen lassen
call ReadSectors ; der eigentliche Lesevorgang
ljc StateError ; bei Fehlern...
jmp Done ; ansonsten o.k.
;******************************************************************************
ND_Read: jmp Unknown
InputStatus: jmp Unknown
InputFlush: jmp Unknown
;******************************************************************************
;* Funktion 8: Sektoren schreiben *
;******************************************************************************
Rh8 struct
db Rh_len dup (?)
MediaID db ? ; Media-ID Laufwerk
BufOfs dw ? ; Adresse Datenpuffer
BufSeg dw ?
NSecs dw ? ; Anzahl zu lesender Bloecke
FirstSec dw ? ; Startsektor bzw. $FFFF fuer 32-Bit-Nummern
VolID dd ? ; Adresse Laufwerksname
LFirstSec dw ? ; lange Startsektornummer
HFirstSec dw ?
endstruct
DoWrite: if debug2
mov al,es:[bx+Rh_Unit]
call PrByte
mov al,' '
call PrChar
mov ax,es:[bx+Rh8_FirstSec]
call PrWord
mov al,' '
mov ax,es:[bx+Rh8_HFirstSec]
call PrWord
mov ax,es:[bx+Rh8_LFirstSec]
call PrWord
call NxtLine
endif
mov al,es:[bx+Rh_Unit]
mov ch,al ; Laufwerksnummer retten
mov ax,es:[bx+Rh8_FirstSec] ; Sektor holen (BIGDOS beachten)
sub dx,dx
cmp ax,-1
jne DWrite_SmallSec
mov ax,es:[bx+Rh8_LFirstSec]
mov dx,es:[bx+Rh8_HFirstSec]
DWrite_SmallSec:mov cl,es:[bx+Rh8_NSecs] ; Sektorzahl laden (muss <=128 sein)
les si,es:[bx+Rh8_BufOfs] ; Zieladresse laden
mov bl,ch ; Laufwerksnummer nach BL
if debug
push ax
push cx
mov cx,ax
mov al,' '
call PrChar
mov al,bl ; Laufwerksnummer
call PrByte
mov al,' '
call PrChar
mov ax,dx ; Startsektor
call PrWord
mov ax,cx
call PrWord
mov al,' '
call PrChar
pop cx
mov al,cl ; Sektorzahl
call PrByte
mov al,' '
call PrChar
mov ax,es ; Startadresse
call PrWord
mov al,':'
call PrChar
mov ax,si
call PrWord
pop ax
endif
call TranslateParams ; umrechnen lassen
call WriteSectors ; der eigentliche Lesevorgang
ret
Write: mov al,es:[bx+Rh_Unit] ; Laufwerksnummer pruefen
call ChkDrive
ljc Error
call DoWrite
ljc StateError ; bei Fehlern...
jmp Done ; ansonsten o.k.
;******************************************************************************
;* Funktion 9: Sektoren schreiben mit Ueberpruefung *
;******************************************************************************
Rh9 struct
db Rh_len dup (?)
MediaID db ? ; Media-ID Laufwerk
BufOfs dw ? ; Adresse Datenpuffer
BufSeg dw ?
NSecs dw ? ; Anzahl zu lesender Bloecke
FirstSec dw ? ; Startsektor bzw. $FFFF fuer 32-Bit-Nummern
VolID dd ? ; Adresse Laufwerksname
LFirstSec dw ? ; lange Startsektornummer
HFirstSec dw ?
endstruct
Write_Verify: mov al,es:[bx+Rh_Unit] ; Laufwerksnummer pruefen
call ChkDrive
ljc Error
call DoWrite ; schreiben
ljc StateError ; bei Fehlern vorher abbrechen
les bx,[Rh_Ptr] ; Parameter nochmal fuer Verify laden
mov al,es:[bx+Rh_Unit]
mov ch,al
mov ax,es:[bx+Rh9_FirstSec]
sub dx,dx
cmp ax,-1
jne VWrite_SmallSec
mov ax,es:[bx+Rh9_LFirstSec]
mov dx,es:[bx+Rh9_HFirstSec]
VWrite_SmallSec:mov cl,es:[bx+Rh9_NSecs]
mov bl,ch
call TranslateParams ; nochmal umrechen...
call VeriSectors ; und prueflesen
jmp Done ; alles gut gegangen
;******************************************************************************
OutputStat: jmp Unknown
OutputFlush: jmp Unknown
IOCTLWrite: jmp Unknown
;******************************************************************************
;* kein Device wechselbar, Oeffnen/Schliessen interessiert nicht *
;******************************************************************************
DeviceOpen: jmp Done
DeviceClose: jmp Done
Removeable: jmp Done
;******************************************************************************
OutputTillBusy: jmp Unknown
GenIOCTL: jmp Unknown
GetLogical: jmp Unknown
SetLogical: jmp Unknown
IOCTLQuery: jmp Unknown
;******************************************************************************
;* Funktion 0: Initialisierung *
;******************************************************************************
include "secparam.inc"
Rh0 struct
db Rh_len dup (?)
Units db ? ; Zahl bedienter Laufwerke
EndOfs dw ? ; Endadresse Offset
EndSeg dw ? ; Endadresse Segment
ParamOfs dw ? ; Parameter Offsetadresse
ParamSeg dw ? ; Parameter Segmentadresse
FirstDrive db ? ; erstes freies Laufwerk
MsgFlag db ? ; Flag, ob DOS Fehler ausgeben darf
endstruct
Init: PrMsg HelloMsg ; Meldung ausgeben
call LowLevelIdent ; Startmeldung des Low-Level-Treibers
mov byte ptr es:[bx+Rh0_Units],0 ; noch keine Laufwerke
mov al,es:[bx+Rh0_FirstDrive] ; Startlaufwerk retten
mov [DrOfs],al
mov ax,cs ; ES auf gem. Segment
mov es,ax
; Schritt 1: Controller pruefen
PrMsg DiagMsg0
call ContDiag ; Diagnose ausfuehren
sub al,Diag_NoError
cmp al,6 ; ausserhalb ?
jae Diag_Over
add al,al ; Meldung ausrechnen
mov ah,0
mov si,ax
mov dx,DiagMsgTable[si]
mov ah,9
int INT_DOS
or si,si ; fehlerfrei ?
ljnz Init_Err ; Nein, Fehler
jmp Init_ChkDrives ; Ja, weiter zum Laufwerkstest
Diag_Over: push ax
PrMsg UndefDiagMsg ; undefinierter Fehlercode
pop ax
add al,Diag_NoError ; Meldung rueckkorrigieren
db 0d4h,10h ; AAM 16
add ax,'00'
push ax
mov al,ah
mov ah,14
int 10h
pop ax
mov ah,14
int 10h
PrChar CR
PrChar LF
jmp Init_Err
; Schritt 2: Laufwerke testen
; Menueaufruf?
Init_ChkDrives: mov ax,40h ; CTRL gedrueckt ?
mov es,ax
btst byte ptr es:[17h],2
jz Init_Menu
call DiskMenu
; Schritt 2a: Laufwerk rekalibrieren
Init_Menu: mov al,[MomDrive]
call Recalibrate
ljc Init_NextDrive ; Fehler: Laufwerk ueberspringen
; Schritt 2b: Masterpartitionssektor lesen
ReadMaster: mov al,[MomDrive]
mov ah,0 ; Kopf...
sub bx,bx ; ...Zylinder...
mov cx,0101h ; ...ein Sektor ab Sektor 1
mov di,ds
mov es,di
lea di,[SectorBuffer] ; in den Sektorpuffer
call ReadSectors
JmpOnError [MomDrive],Init_NextDrive ; Fehler ?
; Schritt 2c: Laufwerksparameter initialisieren
lea si,[SectorBuffer+DrPar_Offset] ; Quelladresse im Sektor
mov al,[MomDrive] ; Zieladresse ausrechnen
call GetPTabAdr
mov cx,DrPar_Len
cld
rep movsb
sub di,DrPar_Len ; Laufwerk nicht initialisiert ?
cmp word ptr[di+DrPar_Cyls],0
je DoQuery
cmp byte ptr[di+DrPar_Heads],0
je DoQuery
cmp byte ptr[di+DrPar_NSecs],0
jne NoQuery
DoQuery: mov al,[MomDrive] ; wenn ja, dann nachfragen
mov ah,1 ; Rueckschreiben hier erlaubt
call QueryParams
or al,al ; =0-->Laufwerk ignorieren
jz Init_NextDrive
dec al ; =1-->nochmal lesen
jz ReadMaster ; ansonsten weitermachen
NoQuery: mov al,[MomDrive] ; Laufwerksparameter ausgeben...
call PrintPDrive
mov al,[MomDrive] ; ...und dem Controller einbleuen
call SetDriveParams
JmpOnError [MomDrive],Init_NextDrive
mov al,[MomDrive]
call Recalibrate
JmpOnError [MomDrive],Init_NextDrive
; Schritt 2d: durch die Partitionssektoren hangeln
mov al,[MomDrive] ; Laufwerk : momentanes
cbw ; Kopf : 0
push ax
sub ax,ax
push ax ; Zylinder : 0
inc ax ; Sektor : 1
push ax
dec ax
push ax ; lin. Sektornummer 0
push ax
call ScanParts
Init_NextDrive: inc [MomDrive] ; Zaehler weitersetzen
cmp [MomDrive],MaxPDrives
ljb Init_ChkDrives
cmp [DrCnt],0 ; keine Partitionen gefunden ?
jne Init_PDrives
PrMsg ErrMsgNoDrives ; ja: meckern
jmp Init_Err
Init_PDrives: PrMsg LDriveMsg
mov [MomDrive],0 ; Parameter der Partitionen ausgeben
lea bp,[DrTab_BPBs] ; und BPB-Tabelle aufbauen
cld
Init_PLDrives: mov al,[MomDrive]
call PrintLDrive
mov al,[MomDrive] ; Bootsdektor lesen
call ReadBootSec
lea si,[SectorBuffer+BPBOfs] ; BPB rauskopieren
mov al,[MomDrive]
call GetTabAdr
lea di,[di+DrTab_BPB]
mov ax,cs
mov es,ax
mov ds:[bp],di ; Adresse nebenbei ablegen
add bp,2
mov cx,BPBSize
rep movsb
inc [MomDrive]
mov al,[MomDrive]
cmp al,[DrCnt]
jb Init_PLDrives
PrChar LF ; sieht besser aus...
les bx,[Rh_Ptr] ; Zeiger auf BPB-Zeiger einschreiben
lea ax,[DrTab_BPBs]
mov es:[bx+Rh0_ParamOfs],ax
mov es:[bx+Rh0_ParamSeg],cs
jmp Init_OK ; Initialisierung erfolgeich zu Ende
Init_Err: PrMsg WKeyMsg
xor ah,ah ; damit Meldung lesbar bleibt
int 16h
sub ax,ax ; Treiber aus Speicher entfernen
jmp Init_End
Init_OK: mov al,[DrCnt] ; Laufwerkszahl holen
les bx,[Rh_Ptr]
mov es:[bx+Rh0_Units],al ; im Request Header eintragen
mov [NrOfVols],al ; im Treiberkopf eintragen
lea ax,[Init] ; residenten Teil installieren
Init_End: les bx,[Rh_Ptr]
mov es:[bx+Rh0_EndOfs],ax ; Endadresse setzen
mov es:[bx+Rh0_EndSeg],cs
jmp Done
;******************************************************************************
;* transiente Unterroutinen *
;******************************************************************************
;******************************************************************************
;* Partitionsbaum durchgehen *
;* In : dw Kopf/Laufwerk *
;* dw Zylinder *
;* dw Sektor *
;* dd lineare Nummer des Sektors *
;******************************************************************************
ScParts_DrHd equ 12 ; Parameteradressen auf Stack
ScParts_Cyl equ 10
ScParts_Sec equ 8
ScParts_LinSec equ 4
ScParts_ParTab equ 0-(MaxParts*ParTab_Len) ; Kopie Partitionstabelle
ScParts_LocSize equ 0-ScParts_ParTab ; belegter Stack
ScanParts: enter ScParts_LocSize,0
; Partitionssektor lesen
mov ax,[bp+ScParts_DrHd]
mov bx,[bp+ScParts_Cyl]
mov ch,[bp+ScParts_Sec]
mov cl,1
mov di,cs
mov es,di
lea di,[SectorBuffer]
call ReadSectors
JmpOnError [MomDrive],ScanParts_End
; Partitionssektorkennung o.k. ?
cmp word ptr SectorBuffer[ParSecID_Offset],0aa55h
ljne ScanParts_End
; Partitionstabelle auslesen
lea si,[SectorBuffer+ParTab_Offset] ; Quelladresse
mov di,ss ; Zieladresse auf Stack
mov es,di
lea di,[bp+ScParts_ParTab]
mov cx,MaxParts*ParTab_Len ; Laenge
cld
rep movsb
; Partitionstabelle durchgehen
mov si,ScParts_ParTab ; vorne anfangen
mov cx,MaxParts ; alle durchgehen
ScanParts_Scan: push cx
mov al,[bp+si+ParTab_Type] ; Typ der Partition lesen
lea bx,[AccPartTypes-1] ; auf Suchtabelle
ScanParts_LAcc: inc bx ; einen Eintrag weiter
cmp byte ptr [bx],0 ; Tabellenende ?
je ScanParts_Next ; ja-->war nix
cmp al,[bx] ; gefunden ?
jne ScanParts_LAcc ;
mov bx,[bp+si+ParTab_LinSec] ; linearen Startsektor ausrechnen
mov cx,[bp+si+ParTab_LinSec+2]
add bx,[bp+ScParts_LinSec] ; in CX:BX
adc cx,[bp+ScParts_LinSec+2]
cmp al,5 ; extended partition ?
jne ScanParts_Enter
push si ; ja: Zeiger fuer Rekursion retten
mov al,[bp+ScParts_DrHd] ; Laufwerk & Kopf zusammenbauen
mov ah,[bp+si+ParTab_FHead]
push ax
mov ax,[bp+si+ParTab_FSecCyl] ; Zylinder ausfiltern
xchg ah,al
shr ah,6
push ax
mov al,[bp+si+ParTab_FSecCyl] ; Sektor ausfiltern
and ax,63
push ax
push cx
push bx
call ScanParts
pop si ; Zeiger zurueck
jmp ScanParts_Next
ScanParts_Enter:mov al,[DrCnt] ; Partition in Tabelle eintragen
call GetTabAdr ; dazu Adresse neuen Eintrags holen
cld
mov ax,cs ; Ziel im Segment
mov es,ax
mov al,[bp+si+ParTab_FHead] ; Kopf kopieren
stosb
mov ax,[bp+si+ParTab_FSecCyl] ; Zylinder kopieren
xchg ah,al
shr ah,6
stosw
mov al,[bp+si+ParTab_FSecCyl] ; Sektor kopieren
and al,63
stosb
mov ax,bx ; linearen Startsektor kopieren
stosw
mov ax,cx
stosw
mov ax,[bp+si+ParTab_NSecs] ; Sektorzahl kopieren
stosw
mov ax,[bp+si+ParTab_NSecs+2]
stosw
mov al,[bp+ScParts_DrHd] ; Laufwerksnummer kopieren
stosb
inc [DrCnt] ; ein log. Laufwerk mehr
ScanParts_Next: add si,ParTab_Len ; auf naechste Partition
pop cx
dec cx
ljnz ScanParts_Scan
ScanParts_End: leave
ret 10
;******************************************************************************
;* Daten eines physikalischen Laufwerks ausgeben *
;* In : AL = Laufwerk *
;******************************************************************************
proc PrintPDrive
push cx ; Register retten
push dx
push di
cbw ; AH loeschen
push ax ; Laufwerk ausgeben
PrMsg PDriveMsg1
pop ax
push ax
inc ax
mov cl,1
call WriteDec
PrMsg PDriveMsg2
pop ax ; Adresse Laufwerkstabelle berechnen
call GetPTabAdr
mov ax,[di+DrPar_Cyls] ; Zylinder ausgeben
mov cl,5
call WriteDec
PrMsg PDriveMsg3
mov al,[di+DrPar_Heads] ; Koepfe ausgeben
mov ah,0
mov cl,3
call WriteDec
PrMsg PDriveMsg4
mov al,[di+DrPar_NSecs] ; Sektoren ausgeben
mov ah,0
mov cl,4
call WriteDec
PrMsg PDriveMsg5
mov al,[di+DrPar_Heads] ; Gesamtsektorzahl berechnen
mul byte ptr [di+DrPar_NSecs]
mul word ptr [di+DrPar_Cyls]
call WriteMBytes
PrMsg PDriveMsg6
pop di ; Register zurueck
pop dx
pop cx
ret
endp
;******************************************************************************
;* Daten eines logischen Laufwerks ausgeben *
;* In : AL = Laufwerk *
;******************************************************************************
proc PrintLDrive
push cx ; Register retten
push dx
push di
mov dx,ax ; Laufwerk retten
push dx
mov cx,3 ; ausgeben
call WriteSpc
add dl,[DrOfs]
add dl,'A'
mov ah,DOS_WrChar
int INT_DOS
PrChar ':'
pop ax ; Tabelle holen
call GetTabAdr
mov al,[di+DrTab_Drive] ; Laufwerk ausgeben...
inc al
cbw
mov cl,9
call WriteDec
mov ax,[di+DrTab_StartCyl] ; ...Zylinder...
mov cl,10
call WriteDec
mov al,[di+DrTab_StartHead] ; ...Kopf...
cbw
mov cl,7
call WriteDec
mov al,[di+DrTab_StartSec] ; ...Sektor...
cbw
mov cl,8
call WriteDec
mov cx,2
call WriteSpc
mov ax,[di+DrTab_SecCnt] ; ...Groesse
mov dx,[di+DrTab_SecCnt+2]
call WriteMBytes
PrMsg PDriveMsg6 ; Meldung wiederverwertet...
pop di ; Register zurueck
pop dx
pop cx
ret
endp
;******************************************************************************
;* Fehlercode eines Laufwerks ausgeben *
;* In : AL = Fehlercode *
;* AH = Laufwerksnummer (0,1...) *
;******************************************************************************
proc WrErrorCode
push bx ; Register retten
push cx
push dx
add ah,'1' ; LW-Nummer in ASCII umrechnen...
mov [DrvErrorMsg2],ah ; ...und einschreiben
mov ch,al ; Kode sichern
PrMsg DrvErrorMsg
mov cl,7 ; bei Bit 0 anfangen
ErrLoop: rol ch,1 ; fagl. Bit in Carry
jnc NoErrBit
mov bl,cl ; Bit gefunden: Index ausrechnen
mov bh,0
add bx,bx
mov dx,[bx+Pointers]
mov ah,DOS_WrString
int INT_DOS
NoErrBit: dec cl ; naechstes Bit
jnz ErrLoop
pop dx ; Register zurueck
pop cx
pop bx
ret
DrvErrorMsg: db "Fehler auf Festplatte "
DrvErrorMsg2: db "0:",CR,LF,'$'
Pointers dw Msg0,Msg1,Msg2,Msg3,Msg4,Msg5,Msg6,Msg7
Msg0 db " Adre",SZLIG,"marke nicht gefunden",CR,LF,'$'
Msg1 db " Spur 0 nicht gefunden",CR,LF,'$'
Msg2 db " Kommandoabbruch",CR,LF,'$'
Msg3 db "$"
Msg4 db " Sektor nicht gefunden",CR,LF,'$'
Msg5 db "$"
Msg6 db " Datenfehler",CR,LF,'$'
Msg7 db " Sektor als defekt markiert",CR,LF,'$'
endp
;******************************************************************************
;* Sektorenzahl als MBytes ausgeben *
;* In: DX:AX = Sektorzahl *
;******************************************************************************
proc WriteMBytes
SecsPerMByte equ (2^20)/SecSize
push cx ; Register retten
push dx
add ax,SecsPerMByte/20 ; wg. Rundung
adc dx,0
mov cx,SecsPerMByte ; durch 2048 teilen = MByte
div cx
push dx ; Nachkommastellen retten
mov cl,6
call WriteDec
PrChar '.' ; Nachkommastelle
pop ax ; holen
cwd
mov cx,SecsPerMByte/10 ; Sektoren pro 100 KByte
div cx
mov cl,1 ; ausgeben
call WriteDec
pop dx ; Register zurueck
pop cx
ret
endp
;******************************************************************************
;* transiente Daten *
;******************************************************************************
HelloMsg: db CR,LF,"Sekundrlaufwerkstreiber V0.4",CR,LF,'$'
ErrMsgNoDrives: db CR,LF,"Fehler: keine Partitionen gefunden",CR,LF,'$'
DiagMsg0: db CR,LF,"Controller-Selbsttest: ",'$'
DiagMsg1: db "OK",CR,LF,'$'
DiagMsg2: db "Controller fehlerhaft",CR,LF,'$'
DiagMsg3: db "Sektorpuffer defekt",CR,LF,'$'
DiagMsg4: db "Fehlerkorrektur defekt",CR,LF,'$'
DiagMsg5: db "Steuerprozessor defekt",CR,LF,'$'
DiagMsg6: db "Timeout",CR,LF,'$'
DiagMsgTable dw DiagMsg1,DiagMsg2,DiagMsg3,DiagMsg4,DiagMsg5,DiagMsg6
UndefDiagMsg db "Unbekannter Fehlercode #$"
WKeyMsg: db "Weiter mit beliebiger Taste...",CR,LF,'$'
PDriveMsg1: db "Festplatte $"
PDriveMsg2: db " :$"
PDriveMsg3: db " Zylinder,$"
PDriveMsg4: db " K",OUML,"pfe,$"
PDriveMsg5: db " Sektoren,$"
PDriveMsg6: db " MByte",CR,LF,'$'
LDriveMsg: db CR,LF,"vorhandene Partitionen:",CR,LF
db "Laufwerk Platte Zylinder Kopf"
db " Sektor Kapazit",AUML,"t",CR,LF,'$'
AccPartTypes db 1 ; akzeptierte Partitionstypen: DOS 2.x FAT12
db 4 ; DOS 3.x FAT16
db 5 ; DOS 3.3 extended
db 6 ; DOS 3.31 >32 MByte
db 0 ; Tabellenende
MomDrive db 0 ; momentan gescanntes Laufwerk
end