| 0,0 → 1,960 |
|---|
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| $Revision$ |
| |
| |
| ;********************************************************** |
| ; Direct work with floppy disk drive |
| ;********************************************************** |
| ; Source code author - Kulakov Vladimir Gennadievich. |
| ; Adaptation and improvement - Mario79. |
| |
| ;give_back_application_data: ; give back to application |
| ; mov edi,[TASK_BASE] |
| ; mov edi,[edi+TASKDATA.mem_start] |
| ; add edi,ecx |
| give_back_application_data_1: |
| mov esi, FDD_BUFF;FDD_DataBuffer ;0x40000 |
| mov ecx, 128 |
| cld |
| rep movsd |
| ret |
| |
| ;take_data_from_application: ; take from application |
| ; mov esi,[TASK_BASE] |
| ; mov esi,[esi+TASKDATA.mem_start] |
| ; add esi,ecx |
| take_data_from_application_1: |
| mov edi, FDD_BUFF;FDD_DataBuffer ;0x40000 |
| mov ecx, 128 |
| cld |
| rep movsd |
| ret |
| |
| ; Controller operations result codes (FDC_Status) |
| FDC_Normal = 0 ; normal finish |
| FDC_TimeOut = 1 ; time out error |
| FDC_DiskNotFound = 2 ; no disk in drive |
| FDC_TrackNotFound = 3 ; track not found |
| FDC_SectorNotFound = 4 ; sector not found |
| |
| ; Maximum values of the sector coordinates (specified |
| ; values correspond to the parameters of the standard |
| ; 3-inch 1.44 MB floppy disk) |
| MAX_Track = 79 |
| MAX_Head = 1 |
| MAX_Sector = 18 |
| |
| uglobal |
| ; Timer tick counter |
| TickCounter dd ? |
| ; Operation completion code with the floppy disk drive controller |
| FDC_Status DB ? |
| ; Interrupt flag from floppy disk drive |
| FDD_IntFlag DB ? |
| ; The moment of the beginning of the last operation with FDD |
| FDD_Time DD ? |
| ; Drive number |
| FDD_Type db 0 |
| ; Sector coordinates |
| FDD_Track DB ? |
| FDD_Head DB ? |
| FDD_Sector DB ? |
| |
| ; Operation result block |
| FDC_ST0 DB ? |
| FDC_ST1 DB ? |
| FDC_ST2 DB ? |
| FDC_C DB ? |
| FDC_H DB ? |
| FDC_R DB ? |
| FDC_N DB ? |
| ; Read operation repetition counter |
| ReadRepCounter DB ? |
| ; Recalibration operation repetition counter |
| RecalRepCounter DB ? |
| endg |
| ; Memory area for storing the readed sector |
| ;FDD_DataBuffer: times 512 db 0 ;DB 512 DUP (?) |
| fdd_motor_status db 0 |
| timer_fdd_motor dd 0 |
| |
| ;************************************** |
| ;* INITIALIZATION OF DMA MODE FOR FDD * |
| ;************************************** |
| Init_FDC_DMA: |
| pushad |
| mov al, 0 |
| out 0x0c, al; reset the flip-flop to a known state. |
| mov al, 6 ; mask channel 2 so we can reprogram it. |
| out 0x0a, al |
| mov al, [dmamode]; 0x46 -> Read from floppy - 0x4A Write to floppy |
| out 0x0b, al |
| mov al, 0 |
| out 0x0c, al; reset the flip-flop to a known state. |
| mov eax, 0xD000 |
| out 0x04, al; set the channel 2 starting address to 0 |
| shr eax, 8 |
| out 0x04, al |
| shr eax, 8 |
| out 0x81, al |
| mov al, 0 |
| out 0x0c, al; reset flip-flop |
| mov al, 0xff;set count (actual size -1) |
| out 0x5, al |
| mov al, 0x1;[dmasize] ;(0x1ff = 511 / 0x23ff =9215) |
| out 0x5, al |
| mov al, 2 |
| out 0xa, al |
| popad |
| ret |
| |
| ;*********************************** |
| ;* WRITE BYTE TO FDC DATA PORT * |
| ;* Parameters: * |
| ;* AL - byte to write. * |
| ;*********************************** |
| FDCDataOutput: |
| ; DEBUGF 1,'K : FDCDataOutput(%x)',al |
| ; pusha |
| push eax ecx edx |
| mov AH, AL ; remember byte to AH |
| ; Reset controller state variable |
| mov [FDC_Status], FDC_Normal |
| ; Check the readiness of the controller to receive data |
| mov DX, 3F4h ; (FDC state port) |
| mov ecx, 0x10000 ; set timeout counter |
| @@TestRS: |
| in AL, DX ; read the RS register |
| and AL, 0C0h ; get digits 6 and 7 |
| cmp AL, 80h ; check digits 6 and 7 |
| je @@OutByteToFDC |
| loop @@TestRS |
| ; Time out error |
| ; DEBUGF 1,' timeout\n' |
| mov [FDC_Status], FDC_TimeOut |
| jmp @@End_5 |
| ; Write byte to data port |
| @@OutByteToFDC: |
| inc DX |
| mov AL, AH |
| out DX, AL |
| ; DEBUGF 1,' ok\n' |
| @@End_5: |
| ; popa |
| pop edx ecx eax |
| ret |
| |
| ;****************************************** |
| ;* READ BYTE FROM FDC DATA PORT * |
| ;* Procedure doesnt have input params. * |
| ;* Output : * |
| ;* AL - byte read. * |
| ;****************************************** |
| FDCDataInput: |
| push ECX |
| push DX |
| ; Reset controller state variable |
| mov [FDC_Status], FDC_Normal |
| ; Check the readiness of the controller to receive data |
| mov DX, 3F4h ;(FDC state port) |
| mov ecx, 0x10000 ; set timeout counter |
| @@TestRS_1: |
| in AL, DX ; read the RS register |
| and AL, 0C0h ; get digits 6 and 7 |
| cmp AL, 0C0h ; check digits 6 and 7 |
| je @@GetByteFromFDC |
| loop @@TestRS_1 |
| ; Time out error |
| ; DEBUGF 1,'K : FDCDataInput: timeout\n' |
| mov [FDC_Status], FDC_TimeOut |
| jmp @@End_6 |
| ; Get byte from data port |
| @@GetByteFromFDC: |
| inc DX |
| in AL, DX |
| ; DEBUGF 1,'K : FDCDataInput: %x\n',al |
| @@End_6: |
| pop DX |
| pop ECX |
| ret |
| |
| ;********************************************* |
| ;* FDC INTERRUPT HANDLER * |
| ;********************************************* |
| FDCInterrupt: |
| ; dbgstr 'FDCInterrupt' |
| ; Set the interrupt flag |
| mov [FDD_IntFlag], 1 |
| mov al, 1 |
| ret |
| |
| ;******************************************* |
| ;* WAIT FOR INTERRUPT FROM FDC * |
| ;******************************************* |
| WaitFDCInterrupt: |
| pusha |
| ; Reset operation status byte |
| mov [FDC_Status], FDC_Normal |
| ; Zero out the tick counter |
| mov eax, [timer_ticks] |
| mov [TickCounter], eax |
| ; Wait for the floppy disk interrupt flag to be set |
| @@TestRS_2: |
| call change_task |
| cmp [FDD_IntFlag], 0 |
| jnz @@End_7 ; interrupt occured |
| mov eax, [timer_ticks] |
| sub eax, [TickCounter] |
| cmp eax, 200;50 ;25 ;5 ; wait 5 ticks |
| jb @@TestRS_2 |
| ; jl @@TestRS_2 |
| ; Time out error |
| ; dbgstr 'WaitFDCInterrupt: timeout' |
| mov [FDC_Status], FDC_TimeOut |
| @@End_7: |
| popa |
| ret |
| |
| ;*********************************** |
| ;* Turn on the motor of drive "A:" * |
| ;*********************************** |
| FDDMotorON: |
| ; dbgstr 'FDDMotorON' |
| pusha |
| ; cmp [fdd_motor_status],1 |
| ; je fdd_motor_on |
| mov al, [flp_number] |
| cmp [fdd_motor_status], al |
| je fdd_motor_on |
| ; Reset the FDD controller |
| mov DX, 3F2h ; motor control port |
| mov AL, 0 |
| out DX, AL |
| ; Select and turn on the drive motor |
| cmp [flp_number], 1 |
| jne FDDMotorON_B |
| ; call FDDMotorOFF_B |
| mov AL, 1Ch ; Floppy A |
| jmp FDDMotorON_1 |
| FDDMotorON_B: |
| ; call FDDMotorOFF_A |
| mov AL, 2Dh ; Floppy B |
| FDDMotorON_1: |
| out DX, AL |
| ; Zero out the tick counter |
| mov eax, [timer_ticks] |
| mov [TickCounter], eax |
| ; wait 0.5 s |
| @@dT: |
| call change_task |
| mov eax, [timer_ticks] |
| sub eax, [TickCounter] |
| cmp eax, 50 ;10 |
| jb @@dT |
| ; Read results of RESET command |
| push 4 |
| ; DEBUGF 1,'K : floppy reset results:' |
| @@: |
| mov al, 8 |
| call FDCDataOutput |
| call FDCDataInput |
| ; DEBUGF 1,' %x',al |
| call FDCDataInput |
| ; DEBUGF 1,' %x',al |
| dec dword [esp] |
| jnz @b |
| ; DEBUGF 1,'\n' |
| pop eax |
| cmp [flp_number], 1 |
| jne fdd_motor_on_B |
| mov [fdd_motor_status], 1 |
| jmp fdd_motor_on |
| fdd_motor_on_B: |
| mov [fdd_motor_status], 2 |
| fdd_motor_on: |
| call save_timer_fdd_motor |
| popa |
| ret |
| |
| ;***************************************** |
| ;* SAVING TIME STAMP * |
| ;***************************************** |
| save_timer_fdd_motor: |
| mov eax, [timer_ticks] |
| mov [timer_fdd_motor], eax |
| ret |
| |
| ;***************************************** |
| ;* CHECK THE MOTOR SHUTDOWN DELAY * |
| ;***************************************** |
| proc check_fdd_motor_status_has_work? |
| cmp [fdd_motor_status], 0 |
| jz .no |
| mov eax, [timer_ticks] |
| sub eax, [timer_fdd_motor] |
| cmp eax, 500 |
| jb .no |
| .yes: |
| xor eax, eax |
| inc eax |
| ret |
| .no: |
| xor eax, eax |
| ret |
| endp |
| |
| align 4 |
| check_fdd_motor_status: |
| cmp [fdd_motor_status], 0 |
| je end_check_fdd_motor_status_1 |
| mov eax, [timer_ticks] |
| sub eax, [timer_fdd_motor] |
| cmp eax, 500 |
| jb end_check_fdd_motor_status |
| call FDDMotorOFF |
| mov [fdd_motor_status], 0 |
| end_check_fdd_motor_status_1: |
| end_check_fdd_motor_status: |
| ret |
| |
| ;********************************** |
| ;* TURN OFF MOTOR OF DRIVE * |
| ;********************************** |
| FDDMotorOFF: |
| ; dbgstr 'FDDMotorOFF' |
| push AX |
| push DX |
| cmp [flp_number], 1 |
| jne FDDMotorOFF_1 |
| call FDDMotorOFF_A |
| jmp FDDMotorOFF_2 |
| FDDMotorOFF_1: |
| call FDDMotorOFF_B |
| FDDMotorOFF_2: |
| pop DX |
| pop AX |
| ; clearing caching flags due to information obsolescence |
| or [floppy_media_flags+0], FLOPPY_MEDIA_NEED_RESCAN |
| or [floppy_media_flags+1], FLOPPY_MEDIA_NEED_RESCAN |
| ret |
| |
| FDDMotorOFF_A: |
| mov DX, 3F2h ; motor control port |
| mov AL, 0Ch ; Floppy A |
| out DX, AL |
| ret |
| |
| FDDMotorOFF_B: |
| mov DX, 3F2h ; motor control port |
| mov AL, 5h ; Floppy B |
| out DX, AL |
| ret |
| |
| ;******************************* |
| ;* RECALIBRATE DRIVE "A:" * |
| ;******************************* |
| RecalibrateFDD: |
| ; dbgstr 'RecalibrateFDD' |
| pusha |
| call save_timer_fdd_motor |
| ; Clear the interrupt flag |
| mov [FDD_IntFlag], 0 |
| ; Send the "Recalibration" command |
| mov AL, 07h |
| call FDCDataOutput |
| mov AL, [flp_number] |
| dec AL |
| call FDCDataOutput |
| ; Wait for the operation to complete |
| call WaitFDCInterrupt |
| cmp [FDC_Status], 0 |
| jne .fail |
| ; Read results of RECALIBRATE command |
| ; DEBUGF 1,'K : floppy recalibrate results:' |
| mov al, 8 |
| call FDCDataOutput |
| call FDCDataInput |
| push eax |
| ; DEBUGF 1,' %x',al |
| call FDCDataInput |
| ; DEBUGF 1,' %x',al |
| ; DEBUGF 1,'\n' |
| pop eax |
| test al, 0xC0 |
| jz @f |
| mov [FDC_Status], FDC_DiskNotFound |
| @@: |
| .fail: |
| call save_timer_fdd_motor |
| popa |
| ret |
| |
| ;***************************************************** |
| ;* TRACK SEARCH * |
| ;* Parameters are passed through global variables: * |
| ;* FDD_Track - track number (0-79); * |
| ;* FDD_Head - head number (0-1). * |
| ;* Result of operation is written to FDC_Status. * |
| ;***************************************************** |
| SeekTrack: |
| ; dbgstr 'SeekTrack' |
| pusha |
| call save_timer_fdd_motor |
| ; Clear the interrupt flag |
| mov [FDD_IntFlag], 0 |
| ; Send "Search" command |
| mov AL, 0Fh |
| call FDCDataOutput |
| ; Send head / drive number byte |
| mov AL, [FDD_Head] |
| shl AL, 2 |
| call FDCDataOutput |
| ; Send track number byte |
| mov AL, [FDD_Track] |
| call FDCDataOutput |
| ; Wait for the operation to complete |
| call WaitFDCInterrupt |
| cmp [FDC_Status], FDC_Normal |
| jne @@Exit |
| ; Save search result |
| mov AL, 08h |
| call FDCDataOutput |
| call FDCDataInput |
| mov [FDC_ST0], AL |
| call FDCDataInput |
| mov [FDC_C], AL |
| ; Check search result |
| ; Is search finished? |
| test [FDC_ST0], 100000b |
| je @@Err |
| ; Is the specified track found? |
| mov AL, [FDC_C] |
| cmp AL, [FDD_Track] |
| jne @@Err |
| ; Does the head number match the specified one? |
| ; The H bit (Head Address) in ST0 will always return a "0" (c) 82077AA datasheet, |
| ; description of SEEK command. So we can not verify the proper head. |
| ; mov AL, [FDC_ST0] |
| ; and AL, 100b |
| ; shr AL, 2 |
| ; cmp AL, [FDD_Head] |
| ; jne @@Err |
| ; Operation completed successfully |
| ; dbgstr 'SeekTrack: FDC_Normal' |
| mov [FDC_Status], FDC_Normal |
| jmp @@Exit |
| @@Err: ; Track not found |
| ; dbgstr 'SeekTrack: FDC_TrackNotFound' |
| mov [FDC_Status], FDC_TrackNotFound |
| @@Exit: |
| call save_timer_fdd_motor |
| popa |
| ret |
| |
| ;******************************************************* |
| ;* READING A DATA SECTOR * |
| ;* Parameters are passed through global variables: * |
| ;* FDD_Track - track number (0-79); * |
| ;* FDD_Head - head number (0-1); * |
| ;* FDD_Sector - sector number (1-18). * |
| ;* Result of operation is written to FDC_Status. * |
| ;* If the read operation is successful, the contents * |
| ;* of the sector will be written to FDD_DataBuffer. * |
| ;******************************************************* |
| ReadSector: |
| ; dbgstr 'ReadSector' |
| pushad |
| call save_timer_fdd_motor |
| ; Clear the interrupt flag |
| mov [FDD_IntFlag], 0 |
| ; Set transmit speed to 500 Kb / s |
| mov AX, 0 |
| mov DX, 03F7h |
| out DX, AL |
| ; Initialize the DMA channel |
| mov [dmamode], 0x46 |
| call Init_FDC_DMA |
| ; Send "Data read" command |
| mov AL, 0E6h ; reading in multi-track mode |
| call FDCDataOutput |
| mov AL, [FDD_Head] |
| shl AL, 2 |
| or AL, [flp_number] |
| dec AL |
| call FDCDataOutput |
| mov AL, [FDD_Track] |
| call FDCDataOutput |
| mov AL, [FDD_Head] |
| call FDCDataOutput |
| mov AL, [FDD_Sector] |
| call FDCDataOutput |
| mov AL, 2 ; sector size code (512 byte) |
| call FDCDataOutput |
| mov AL, 18 ;+1; 3Fh ;number of sectors per track |
| call FDCDataOutput |
| mov AL, 1Bh ; GPL value |
| call FDCDataOutput |
| mov AL, 0FFh; DTL value |
| call FDCDataOutput |
| ; Waiting for an interrupt at the end of the operation |
| call WaitFDCInterrupt |
| cmp [FDC_Status], FDC_Normal |
| jne @@Exit_1 |
| ; Read the operation completion status |
| call GetStatusInfo |
| test [FDC_ST0], 11011000b |
| jnz @@Err_1 |
| ; dbgstr 'ReadSector: FDC_Normal' |
| mov [FDC_Status], FDC_Normal |
| jmp @@Exit_1 |
| @@Err_1: |
| ; dbgstr 'ReadSector: FDC_SectorNotFound' |
| mov [FDC_Status], FDC_SectorNotFound |
| @@Exit_1: |
| call save_timer_fdd_motor |
| popad |
| ret |
| |
| ;******************************************************* |
| ;* READ SECTOR (WITH RETRY OF OPERATION ON FAILURE) * |
| ;* Parameters are passed through global variables: * |
| ;* FDD_Track - track number (0-79); * |
| ;* FDD_Head - head number (0-1); * |
| ;* FDD_Sector - sector number (1-18). * |
| ;* Result of operation is written to FDC_Status. * |
| ;* If the read operation is successful, the contents * |
| ;* of the sector will be written to FDD_DataBuffer. * |
| ;******************************************************* |
| ReadSectWithRetr: |
| pusha |
| ; Reset the recalibration repetition counter |
| mov [RecalRepCounter], 0 |
| @@TryAgain: |
| ; Reset the read operation retry counter |
| mov [ReadRepCounter], 0 |
| @@ReadSector_1: |
| call ReadSector |
| cmp [FDC_Status], 0 |
| je @@Exit_2 |
| cmp [FDC_Status], 1 |
| je @@Err_3 |
| ; Three times repeat reading |
| inc [ReadRepCounter] |
| cmp [ReadRepCounter], 3 |
| jb @@ReadSector_1 |
| ; Three times repeat recalibration |
| call RecalibrateFDD |
| call SeekTrack |
| inc [RecalRepCounter] |
| cmp [RecalRepCounter], 3 |
| jb @@TryAgain |
| @@Exit_2: |
| popa |
| ret |
| @@Err_3: |
| popa |
| ret |
| |
| ;******************************************************* |
| ;* WRITE DATA SECTOR * |
| ;* Parameters are passed through global variables: * |
| ;* FDD_Track - track number (0-79); * |
| ;* FDD_Head - head number (0-1); * |
| ;* FDD_Sector - sector number (1-18). * |
| ;* Result of operation is written to FDC_Status. * |
| ;* If the write operation is successful, the contents * |
| ;* of FDD_DataBuffer will be written to the sector * |
| ;******************************************************* |
| WriteSector: |
| ; dbgstr 'WriteSector' |
| pushad |
| call save_timer_fdd_motor |
| ; Clear the interrupt flag |
| mov [FDD_IntFlag], 0 |
| ; Set transmit speed to 500 Kb / s |
| mov AX, 0 |
| mov DX, 03F7h |
| out DX, AL |
| ; Initialize the DMA channel |
| mov [dmamode], 0x4A |
| call Init_FDC_DMA |
| ; Send "Write data" command |
| mov AL, 0xC5 ;0x45 ; write in multi-track mode |
| call FDCDataOutput |
| mov AL, [FDD_Head] |
| shl AL, 2 |
| or AL, [flp_number] |
| dec AL |
| call FDCDataOutput |
| mov AL, [FDD_Track] |
| call FDCDataOutput |
| mov AL, [FDD_Head] |
| call FDCDataOutput |
| mov AL, [FDD_Sector] |
| call FDCDataOutput |
| mov AL, 2 ; sector size code (512 bytes) |
| call FDCDataOutput |
| mov AL, 18; 3Fh ; sectors per track |
| call FDCDataOutput |
| mov AL, 1Bh ; GPL value |
| call FDCDataOutput |
| mov AL, 0FFh; DTL value |
| call FDCDataOutput |
| ; Waiting for an interrupt at the end of the operation |
| call WaitFDCInterrupt |
| cmp [FDC_Status], FDC_Normal |
| jne @@Exit_3 |
| ; Reading the completion status of the operation |
| call GetStatusInfo |
| test [FDC_ST0], 11000000b ;11011000b |
| jnz @@Err_2 |
| mov [FDC_Status], FDC_Normal |
| jmp @@Exit_3 |
| @@Err_2: |
| mov [FDC_Status], FDC_SectorNotFound |
| @@Exit_3: |
| call save_timer_fdd_motor |
| popad |
| ret |
| |
| ;******************************************************* |
| ;* WRITE SECTOR (WITH REPEAT ON FAILURE) * |
| ;* Parameters are passed through global variables: * |
| ;* FDD_Track - track number (0-79); * |
| ;* FDD_Head - head number (0-1); * |
| ;* FDD_Sector - sector number (1-18). * |
| ;* Result of operation is written to FDC_Status. * |
| ;* If the write operation is successful, the contents * |
| ;* of FDD_DataBuffer will be written to the sector * |
| ;******************************************************* |
| WriteSectWithRetr: |
| pusha |
| ; Reset the recalibration repetition counter |
| mov [RecalRepCounter], 0 |
| @@TryAgain_1: |
| ; Reset the read operation retry counter |
| mov [ReadRepCounter], 0 |
| @@WriteSector_1: |
| call WriteSector |
| cmp [FDC_Status], 0 |
| je @@Exit_4 |
| cmp [FDC_Status], 1 |
| je @@Err_4 |
| ; Three times repeat writing |
| inc [ReadRepCounter] |
| cmp [ReadRepCounter], 3 |
| jb @@WriteSector_1 |
| ; Three times repeat recalibration |
| call RecalibrateFDD |
| call SeekTrack |
| inc [RecalRepCounter] |
| cmp [RecalRepCounter], 3 |
| jb @@TryAgain_1 |
| @@Exit_4: |
| popa |
| ret |
| @@Err_4: |
| popa |
| ret |
| |
| ;********************************************* |
| ;* GET INFORMATION ABOUT THE RESULT OF THE OPERATION |
| ;********************************************* |
| GetStatusInfo: |
| push AX |
| call FDCDataInput |
| mov [FDC_ST0], AL |
| call FDCDataInput |
| mov [FDC_ST1], AL |
| call FDCDataInput |
| mov [FDC_ST2], AL |
| call FDCDataInput |
| mov [FDC_C], AL |
| call FDCDataInput |
| mov [FDC_H], AL |
| call FDCDataInput |
| mov [FDC_R], AL |
| call FDCDataInput |
| mov [FDC_N], AL |
| pop AX |
| ret |
| |
| ; Interface for disk subsystem. |
| ; Assume fixed capacity for 1.44M. |
| FLOPPY_CAPACITY = 2880 ; in sectors |
| |
| iglobal |
| align 4 |
| floppy_functions: |
| dd .size |
| dd 0 ; no close() function |
| dd 0 ; no closemedia() function |
| dd floppy_querymedia |
| dd floppy_read |
| dd floppy_write |
| dd 0 ; no flush() function |
| dd 0 ; no adjust_cache_size() function |
| .size = $ - floppy_functions |
| endg |
| |
| uglobal |
| floppy_media_flags rb 2 |
| n_sector dd 0 ; temporary save for sector value |
| flp_number db 0 ; 1- Floppy A, 2-Floppy B |
| old_track db 0 ; old value track |
| flp_label rb 15*2 ; Label and ID of inserted floppy disk |
| align 4 |
| ; Hardware does not allow to work with two floppies in parallel, |
| ; so there is one mutex guarding access to any floppy. |
| floppy_mutex MUTEX |
| endg |
| ; Meaning of bits in floppy_media_flags |
| FLOPPY_MEDIA_PRESENT = 1 ; media was present when last asked |
| FLOPPY_MEDIA_NEED_RESCAN = 2 ; media was possibly changed, need to rescan |
| FLOPPY_MEDIA_LABEL_CHANGED = 4 ; temporary state |
| |
| iglobal |
| floppy1_name db 'fd',0 |
| floppy2_name db 'fd2',0 |
| endg |
| |
| ; This function is called in boot process. |
| ; It creates filesystems /fd and/or /fd2, if the system has one/two floppy drives. |
| proc floppy_init |
| mov ecx, floppy_mutex |
| call mutex_init |
| ; First floppy is present if [DRIVE_DATA] and 0xF0 is nonzero. |
| test byte [DRIVE_DATA], 0xF0 |
| jz .no1 |
| stdcall disk_add, floppy_functions, floppy1_name, 1, DISK_NO_INSERT_NOTIFICATION |
| .no1: |
| ; Second floppy is present if [DRIVE_DATA] and 0x0F is nonzero. |
| test byte [DRIVE_DATA], 0x0F |
| jz .no2 |
| stdcall disk_add, floppy_functions, floppy2_name, 2, DISK_NO_INSERT_NOTIFICATION |
| .no2: |
| ret |
| endp |
| |
| ; Returns information about disk media. |
| ; Floppy drives do not support insert notifications, |
| ; DISK_NO_INSERT_NOTIFICATION is set, |
| ; the disk subsystem calls this function before each filesystem operation. |
| ; If the media has changed, return error for the first call as signal |
| ; to finalize work with old media and the true geometry for the second call. |
| ; Assume that media is (possibly) changed anytime when motor is off. |
| proc floppy_querymedia |
| virtual at esp+4 |
| .userdata dd ? |
| .info dd ? |
| end virtual |
| ; 1. Acquire the global lock. |
| mov ecx, floppy_mutex |
| call mutex_lock |
| mov edx, [.userdata] ; 1 for /fd, 2 for /fd2 |
| ; 2. If the media was reported and has been changed, forget it and report an error. |
| mov al, [floppy_media_flags+edx-1] |
| and al, FLOPPY_MEDIA_PRESENT + FLOPPY_MEDIA_NEED_RESCAN |
| cmp al, FLOPPY_MEDIA_PRESENT + FLOPPY_MEDIA_NEED_RESCAN |
| jnz .not_reported |
| .no_media: |
| mov [floppy_media_flags+edx-1], 0 |
| .return_no_media: |
| mov ecx, floppy_mutex |
| call mutex_unlock |
| mov eax, DISK_STATUS_NO_MEDIA |
| retn 8 |
| .not_reported: |
| ; 3. If we are in the temporary state LABEL_CHANGED, this is the second call |
| ; after intermediate DISK_STATUS_NO_MEDIA due to media change; |
| ; clear the flag and return the current geometry without rereading the bootsector. |
| cmp [floppy_media_flags+edx-1], FLOPPY_MEDIA_LABEL_CHANGED |
| jz .report_geometry |
| ; 4. Try to read the bootsector. |
| mov [flp_number], dl |
| mov [FDC_Status], 0 |
| call floppy_read_bootsector |
| ; 5. If reading bootsector failed, assume that media is not present. |
| mov edx, [.userdata] |
| cmp [FDC_Status], 0 |
| jnz .no_media |
| ; 6. Check whether the previous status is "present". If not, go to 10. |
| push esi edi |
| imul edi, edx, 15 |
| add edi, flp_label-15 |
| mov esi, FDD_BUFF+39 |
| mov ecx, 15 |
| test [floppy_media_flags+edx-1], FLOPPY_MEDIA_PRESENT |
| jz .set_label |
| ; 7. Compare the old label with the current one. |
| rep cmpsb |
| ; 8. If the label has not changed, go to 11. |
| jz .ok |
| ; 9. If the label has changed, store it, enter temporary state LABEL_CHANGED |
| ; and report DISK_STATUS_NO_MEDIA. |
| ; dbgstr 'floppy label changed' |
| add esi, ecx |
| add edi, ecx |
| mov ecx, 15 |
| sub esi, ecx |
| sub edi, ecx |
| rep movsb |
| mov [floppy_media_flags+edx-1], FLOPPY_MEDIA_LABEL_CHANGED |
| pop edi esi |
| jmp .return_no_media |
| .set_label: |
| ; 10. The previous state was "not present". Copy the label. |
| rep movsb |
| .ok: |
| pop edi esi |
| .report_geometry: |
| ; 11. Fill DISKMEDIAINFO structure. |
| mov ecx, [.info] |
| and [ecx+DISKMEDIAINFO.Flags], 0 |
| mov [ecx+DISKMEDIAINFO.SectorSize], 512 |
| mov dword [ecx+DISKMEDIAINFO.Capacity], FLOPPY_CAPACITY |
| and dword [ecx+DISKMEDIAINFO.Capacity+4], 0 |
| ; 12. Update state: media is present, data are actual. |
| mov [floppy_media_flags+edx-1], FLOPPY_MEDIA_PRESENT |
| ; 13. Release the global lock and return successful status. |
| mov ecx, floppy_mutex |
| call mutex_unlock |
| xor eax, eax |
| retn 8 |
| endp |
| |
| proc floppy_read_bootsector |
| pushad |
| mov [FDD_Track], 0 ; Cylinder |
| mov [FDD_Head], 0 ; Head |
| mov [FDD_Sector], 1 ; Sector |
| call FDDMotorON |
| call RecalibrateFDD |
| cmp [FDC_Status], 0 |
| jne .nothing |
| call SeekTrack |
| cmp [FDC_Status], 0 |
| jne .nothing |
| call ReadSectWithRetr |
| .nothing: |
| popad |
| ret |
| endp |
| |
| read_chs_sector: |
| call calculate_chs |
| call ReadSectWithRetr |
| ret |
| |
| save_chs_sector: |
| call calculate_chs |
| call WriteSectWithRetr |
| ret |
| |
| calculate_chs: |
| mov bl, [FDD_Track] |
| mov [old_track], bl |
| mov ebx, 18 |
| xor edx, edx |
| div ebx |
| inc edx |
| mov [FDD_Sector], dl |
| mov edx, eax |
| shr eax, 1 |
| and edx, 1 |
| mov [FDD_Track], al |
| mov [FDD_Head], dl |
| mov dl, [old_track] |
| cmp dl, [FDD_Track] |
| je no_seek_track_1 |
| call SeekTrack |
| no_seek_track_1: |
| ret |
| |
| ; Writes one or more sectors to the device. |
| proc floppy_write |
| mov dl, 1 |
| jmp floppy_read_write |
| endp |
| |
| ; Reads one or more sectors from the device. |
| proc floppy_read |
| mov dl, 0 |
| endp |
| |
| ; Common part of floppy_read and floppy_write. |
| proc floppy_read_write userdata:dword, buffer:dword, start_sector:qword, numsectors_ptr:dword |
| virtual at ebp-8 |
| .sectors_todo dd ? |
| .operation db ? |
| end virtual |
| push edx ; save operation code to [.operation] |
| ; 1. Get number of sectors to read/write |
| ; and zero number of sectors that were actually read/written. |
| mov eax, [numsectors_ptr] |
| push dword [eax] ; initialize [.sectors_todo] |
| and dword [eax], 0 |
| push ebx esi edi ; save used registers to be stdcall |
| ; 2. Acquire the global lock. |
| mov ecx, floppy_mutex |
| call mutex_lock |
| ; 3. Set floppy number for this operation. |
| mov edx, [userdata] |
| mov [flp_number], dl |
| ; 4. Read/write sector-by-sector. |
| .operation_loop: |
| ; 4a. Check that the sector is inside the media. |
| cmp dword [start_sector+4], 0 |
| jnz .end_of_media |
| mov eax, dword [start_sector] |
| cmp eax, FLOPPY_CAPACITY |
| jae .end_of_media |
| ; 4b. For read operation, call read_chs_sector and then move data from FDD_BUFF to [buffer]. |
| ; For write operation, move data from [buffer] to FDD_BUFF and then call save_chs_sector. |
| cmp [.operation], 0 |
| jz .read |
| mov esi, [buffer] |
| mov edi, FDD_BUFF |
| mov ecx, 512/4 |
| rep movsd |
| mov [buffer], esi |
| call save_chs_sector |
| jmp @f |
| .read: |
| call read_chs_sector |
| mov esi, FDD_BUFF |
| mov edi, [buffer] |
| mov ecx, 512/4 |
| rep movsd |
| mov [buffer], edi |
| @@: |
| ; 4c. If there was an error, propagate it to the caller. |
| cmp [FDC_Status], 0 |
| jnz .fail |
| ; 4d. Otherwise, increment number of sectors processed and continue the loop. |
| mov eax, [numsectors_ptr] |
| inc dword [eax] |
| inc dword [start_sector] |
| dec [.sectors_todo] |
| jnz .operation_loop |
| ; 5. Release the global lock and return with the correct status. |
| push 0 |
| .return: |
| mov ecx, floppy_mutex |
| call mutex_unlock |
| pop eax |
| pop edi esi ebx ; restore used registers to be stdcall |
| ret ; this translates to leave/retn N and purges local variables |
| .fail: |
| push -1 |
| jmp .return |
| .end_of_media: |
| push DISK_STATUS_END_OF_MEDIA |
| jmp .return |
| endp |
| Property changes: |
|---|
| Added: svn:eol-style |
|---|
| +native |
|---|
| \ No newline at end of property |
|---|
| Added: svn:keywords |
|---|
| +Rev |
|---|
| \ No newline at end of property |
|---|