Not sure if this even helps, but you can use my latest floppy code as a reference:
Code: Select all
;----------------------------------------------------------;
; BOS kernel Christoffer Bubach, 2004-2006. ;
;----------------------------------------------------------;
; ;
; floppy disk driver. ;
; ;
;----------------------------------------------------------;
;---------------------------;
; variables and contants ;
;---------------------------;
fdd_int_done dw 0 ; is the IRQ done?
fdd_motor_on db 0 ; fdd motor on=1, off=0
fdd_drivehead db 0 ; ((head*4)|drive)
fdd_head db 0
fdd_track db 0
fdd_sector db 0
fdd_error db 0 ; should we recalibrate
; at next read/write?
fdd_errorcode db 0
result_ST0 db 0
result_ST1 db 0 ; or pcn
result_ST2 db 0
result_ST3 db 0
result_C db 0
result_H db 0
result_R db 0
result_N db 0
result_extra db 0
;------------------------------------------------------;
; initializes the floppy disk driver ;
; ;
;------------------------------------------------------;
fdc_init:
push eax
push ecx
push edi
xor eax, eax ; get configuration
mov al, 0x10 ; from CMOS.
out 0x70, al
in al, 0x71
shr al, 4
cmp al, 4 ; a 1.44mb?
jnz .no_floppy
mov cl, 0x26 ; hook IRQ 6
mov dx, 0x8 ; CS = 8
mov edi, floppy_irq
call set_int
mov cl, 6 ; enable IRQ6
call enable_irq
call fdd_reset ; reset FDC
.no_floppy:
pop edi
pop ecx
pop eax
ret
;------------------------------------------------------;
; floppy IRQ ;
; ;
;------------------------------------------------------;
floppy_irq:
push ds
push eax
push ebx
mov ax, 0x10
mov ds, ax
mov [fdd_int_done], 1
mov al, 0x20
out 0x20, al
pop ebx
pop eax
pop ds
iret
;------------------------------------------------------;
; wait for a floppy int ;
; out: cf = 1 if timeout ;
;------------------------------------------------------;
wait_int:
push eax
push ecx
mov ecx, 150 ; 50 = 0.5 seconds.
call active_delay ; timer.inc
.l1:
cmp dword [ecx], 0 ; timeup?
je .error
mov ax, [fdd_int_done] ; if not we check for int.
or ax, ax
jz .l1
clc
jmp .end
.error:
stc
.end:
pop ecx
pop eax
ret
;------------------------------------------------------;
; fdd motor off ;
; out: nothing ;
;------------------------------------------------------;
fdd_off:
cmp [fdd_motor_on], 0
je .end
push eax
push edx
mov dx, 0x3F2
mov al, 0x0c ; motor off
out dx, al
mov [fdd_motor_on], 0
pop edx
pop eax
.end:
ret
;------------------------------------------------------;
; fdd motor on ;
; out: nothing ;
;------------------------------------------------------;
fdd_on:
cmp [fdd_motor_on], 1
je .end
push eax
push edx
mov dx, 0x3F2 ; motor 0 on..
mov al, 0x1C
out dx, al
mov ecx, 20 ; 1/5 of a sec. to speed up
call delay ; in timer.inc
mov [fdd_motor_on], 1
pop edx
pop eax
.end:
ret
;------------------------------------------------------;
; send a data byte to the FDC ;
; ;
; in: al = data byte ;
;------------------------------------------------------;
fdc_sendbyte:
push edx
push ecx
push eax
mov ecx, 50 ; 50 = 0.5 seconds.
call active_delay ; timer.inc
.l1:
cmp dword [ecx], 0 ; timeup?
je .error
mov dx, 0x3f4 ; check status reg
in al, dx
and al, 0xC0
cmp al, 0x80 ; are we ok to write
jnz .l1
pop eax
pop ecx
mov dx, 0x3F5 ; send byte
out dx, al
pop edx
clc
ret
.error:
pop eax
pop ecx
pop edx
stc
ret
;------------------------------------------------------;
; read a data byte from the FDC ;
; ;
; out: al = data byte ;
;------------------------------------------------------;
fdc_getbyte:
push edx
push ecx
push eax
mov ecx, 50 ; 50 = 0.5 seconds.
call active_delay ; timer.inc
.l1:
cmp dword [ecx], 0 ; timeup?
je .error
mov dx, 0x3f4 ; check status reg
in al, dx
and al, 0xD0
cmp al, 0xD0 ; are we ok to read
jnz .l1
pop eax
pop ecx
mov dx, 0x3F5 ; get the byte
in al, dx
pop edx
clc
ret
.error:
pop eax
pop ecx
pop edx
stc
ret
;------------------------------------------------------;
; sense interrupt status command ;
; ;
;------------------------------------------------------;
sensei:
push eax
mov al, 0x08 ; fdc command
call fdc_sendbyte
call fdc_getbyte
mov ah, al ; save ST0 in ah
call fdc_getbyte ; read PCN
clc
test ah, 0x80 ; test for error:
jz .end ; "invalid command"
stc
.end:
pop eax
ret
;------------------------------------------------------;
; reset controller ;
; ;
;------------------------------------------------------;
fdd_reset:
push eax
push ecx
push edx
mov byte [fdd_motor_on], 0
mov dx, 0x3f2
mov al, 8 ; off with all motors,
out dx, al ; dma,irq etc..
mov ecx, 5
call delay ; in timer.inc
mov dx, 0x3f7
mov al, 0
out dx, al ; work at 500 kbit/s
mov dx, 0x3f2
mov al, 0x0c
out dx, al ; reenable interrupts
mov [fdd_int_done], 0
call wait_int ; wait for floppy int.
jc .error ; timeout?
mov cx, 0x04
.status: ; 4 dummy-reads.
call sensei
loop .status
mov al, 0x03 ; specify command
call fdc_sendbyte
mov al, 0xDF ; SRT, HUT
call fdc_sendbyte
mov al, 0x02 ; HLT, ND
call fdc_sendbyte
mov al, 1
call fdd_recal_seek
jc .error
call fdd_off
clc
jmp .end
.error:
call fdd_off
stc
.end:
pop edx
pop ecx
pop eax
ret
;------------------------------------------------------;
; fdd recalibrate/seek ;
; ;
; in: al = 0 on seek, 1 on recalibrate ;
; bl = (at seek) track ;
; bh = (at seek) ((head*4)|drive) ;
; ;
;------------------------------------------------------;
fdd_recal_seek:
push eax
call fdd_on ; turn motor on
cmp al, 0
jne .recalibrate
clc
cmp bl, [result_C] ; are we there yet? :D
je .ok
mov al, 0x0F ; seek command
call fdc_sendbyte
mov al, bh ; ((head*4)|drive)
call fdc_sendbyte
mov al, bl ; track
call fdc_sendbyte
mov [result_C], bl ; now on..?
jmp .get_int
.recalibrate:
mov al, 0x07 ; recalibrate command
call fdc_sendbyte
mov al, 0 ; drive number
call fdc_sendbyte
mov [result_C], 0 ; now on track 0
.get_int:
mov [fdd_int_done], 0
call wait_int
jc .error
call sensei ; sense interrupt status
jc .error
.ok:
clc
jmp .end
.error:
stc
.end:
pop eax
ret
;------------------------------------------------------;
; fdd read/write ;
; input: bl = 0 read, 1 write ;
; ch = track/cylinder ;
; cl = sector ;
; dh = head ;
; edi = address to store or read the data ;
; output: al = status ;
; cf = 0 if ok, 1 if error ;
;------------------------------------------------------;
fdd_read_write:
pushad
and dh, 1 ; head 0 or 1?
mov [fdd_head], dh ; store it.
shl dh, 2
or dh, 0 ; drive 0, fd0
mov [fdd_drivehead], dh ; dh = ((head*4)|drive)
mov [fdd_errorcode], 0x04 ; basic error code
cmp ch, 0x51 ; check for allowed
jae .error ; track number.
mov [fdd_track], ch
cmp cl, 0x13 ; check for allowed
jae .error ; sector number.
mov [fdd_sector], cl
cmp [fdd_error], 1
jne .no_previous_error
mov al, 1
call fdd_recal_seek
.no_previous_error:
call fdd_on
mov dx, 0x3F7
mov al, 0 ; 500Kb/sec mode
out dx, al
mov [fdd_errorcode], 0x80 ; error code
xor ecx, ecx
mov cx, 3 ; try seek 3 times
.l2:
mov al, 0
mov bl, [fdd_track]
mov bh, [fdd_drivehead] ; ((head*4)|drive)
call fdd_recal_seek
jnc .l3 ; ok, continue.
loop .l2
jmp .error ; timeout.
.l3:
push ebx
cmp bl, 0
je .read_fdd
.write_fdd:
push edi
mov esi, edi
mov edi, 0x80000 ; copy the stuff we will
mov ecx, 128 ; write to the DMA buffer
rep movsd ; 128*4=512
pop edi
mov bl, 2 ; channel 2
mov esi, 512 ; bytes to write
mov ecx, 0x80000 ; page & offset
mov bh, 1 ; write floppy, read DMA
call dma_transfer
mov al, 0xC5 ; write sector command
call fdc_sendbyte
jmp .cont
.read_fdd:
mov bl, 2 ; channel 2
mov esi, 512 ; bytes to read
mov ecx, 0x80000 ; page & offset
mov bh, 0 ; read floppy, write DMA
call dma_transfer
mov al, 0xE6 ; read sector command
call fdc_sendbyte
.cont:
pop ebx
mov al, [fdd_drivehead] ; ((head*4)|drive)
call fdc_sendbyte
mov al, [fdd_track] ; track/cylinder
call fdc_sendbyte
mov al, [fdd_head] ; head/side 0 or 1
call fdc_sendbyte
mov al, [fdd_sector] ; sector number
call fdc_sendbyte
mov al, 0x02 ; sector size, 512 bytes
call fdc_sendbyte
mov al, 0x12 ; sectors to a track
call fdc_sendbyte
mov al, 0x1B ; gap length
call fdc_sendbyte
mov al, 0xFF ; data length
call fdc_sendbyte
mov [fdd_int_done], 0
call wait_int
jc .error
call fdc_getbyte
mov [result_ST0], al ; ST0
call fdc_getbyte
mov [result_ST1], al ; ST1
call fdc_getbyte
mov [result_ST2], al ; ST2
call fdc_getbyte
mov [result_C], al ; cylinder
call fdc_getbyte
mov [result_H], al ; head
call fdc_getbyte
mov [result_R], al ; sector number.
call fdc_getbyte
mov [result_N], al ; sector size
test [result_ST0], 0xc0 ; test if sr0 is 0xC0
jnz .error
cmp bl, 1 ; did we write the disk?
je .ok
mov ecx, 512 ; sector size in bytes
mov esi, 0x80000 ; copy to dest. in edi
rep movsb
.ok:
mov [fdd_errorcode], 0 ; no error.. :D
mov [fdd_error], 0 ; no recal. next time
clc
jmp .end
.error:
mov [fdd_error], 1 ; recalibrate next time
stc
.end:
call fdd_off ; floppy motor off
popad
mov al, [fdd_errorcode] ; error status
ret
.