WebSVN – Kolibri OS – Diff – /kernel/trunk/fs/fat12.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;; FAT12.INC                                                    ;;
;; (C) 2005 Mario79, License: GPL                               ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3539 $
 
 
n_sector    dd 0  ; temporary save for sector value
flp_status  dd 0
clust_tmp_flp dd 0  ; used by analyze_directory and analyze_directory_to_write
path_pointer_flp dd 0
pointer_file_name_flp dd 0
save_root_flag db 0
save_flag   db 0
root_read   db 0  ; 0-necessary to load root, 1-not to load root
flp_fat     db 0  ; 0-necessary to load fat, 1-not to load fat
flp_number  db 0  ; 1- Floppy A, 2-Floppy B
old_track   db 0  ; old value track
flp_label   rb 15 ; Label and ID of inserted floppy disk
 
reserve_flp:
 
        cli
        cmp     [flp_status], 0
        je      reserve_flp_ok
 
        sti
        call    change_task
        jmp     reserve_flp
 
  reserve_flp_ok:
 
        push    eax
        mov     eax, [CURRENT_TASK]
        shl     eax, 5
        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
        mov     [flp_status], eax
        pop     eax
        sti
        ret
 
 
floppy_fileread:
;----------------------------------------------------------------
;
;  fileread - sys floppy
;
;  eax  points to filename 11 chars  - for root directory
;  ebx  first wanted block       ; 1+ ; if 0 then set to 1
;  ecx  number of blocks to read ; 1+ ; if 0 then set to 1
;  edx  mem location to return data
;  esi  length of filename 12*X
;  edi  pointer to path   /fd/1/......  - for all files in nested directories
;
;  ret ebx = size or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;            10 = access denied
;--------------------------------------------------------------
 
        mov     [save_flag], 0
        mov     [path_pointer_flp], edi
        test    esi, esi     ; return ramdisk root
        jnz     fr_noroot_1
        cmp     ebx, 224/16
        jbe     fr_do_1
        mov     eax, 5
        xor     ebx, ebx
        mov     [flp_status], ebx
        ret
 
fr_do_1:
        push    ebx ecx edx
        call    read_flp_root
        pop     edx ecx ebx
        cmp     [FDC_Status], 0
        jne     fdc_status_error_1
        mov     edi, edx
        dec     ebx
        shl     ebx, 9
        mov     esi, FLOPPY_BUFF
        add     esi, ebx
        shl     ecx, 9
        cld
        rep movsb
        xor     eax, eax
        xor     ebx, ebx
;    mov    eax,0 ; ok read
;    mov    ebx,0
        mov     [flp_status], eax
        ret
fdc_status_error_1:
        xor     eax, eax
        mov     [flp_status], eax
        mov     eax, 10
        or      ebx, -1
        ret
 
fr_noroot_1:
        sub     esp, 32
        call    expand_filename
frfloppy_1:
        test    ebx, ebx
        jnz     frfl5_1
        mov     ebx, 1
frfl5_1:
        test    ecx, ecx
        jnz     frfl6_1
        mov     ecx, 1
frfl6_1:
        dec     ebx
        push    eax
        push    eax ebx ecx edx esi edi
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jne     fdc_status_error_3_1
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 1; Сторона
        mov     [FDD_Sector], 2; Сектор
        call    SeekTrack
        mov     dh, 14
l.20_1:
        call    ReadSectWithRetr
        cmp     [FDC_Status], 0
        jne     fdc_status_error_3_1
        mov     dl, 16
        mov     edi, FDD_BUFF
        inc     [FDD_Sector]
l.21_1:
        mov     esi, eax      ;Name of file we want
        mov     ecx, 11
        cld
        rep cmpsb           ;Found the file?
        je      fifound_1     ;Yes
        add     ecx, 21
        add     edi, ecx    ;Advance to next entry
        dec     dl
        test    dl, dl
        jnz     l.21_1
        dec     dh
        test    dh, dh
        jnz     l.20_1
fdc_status_error_3:
        mov     eax, 5      ; file not found ?
        or      ebx, -1
        add     esp, 32+28
        mov     [flp_status], 0
        ret
fdc_status_error_3_2:
        cmp     [FDC_Status], 0
        je      fdc_status_error_3
fdc_status_error_3_1:
        add     esp, 32+28
        jmp     fdc_status_error_1
 
fifound_1:
        mov     eax, [path_pointer_flp]
        cmp     [eax+36], byte 0
        je      fifound_2
        add     edi, 0xf
        mov     eax, [edi]
        and     eax, 65535
        mov     ebx, [path_pointer_flp]
        add     ebx, 36
        call    get_cluster_of_a_path_flp
        jc      fdc_status_error_3_2
        mov     ebx, [ebx-11+28]  ;file size
        mov     [esp+20], ebx
        mov     [esp+24], ebx
        jmp     fifound_3
fifound_2:
        mov     ebx, [edi-11+28]  ;file size
        mov     [esp+20], ebx
        mov     [esp+24], ebx
        add     edi, 0xf
        mov     eax, [edi]
fifound_3:
        and     eax, 65535
        mov     [n_sector], eax      ;eax=cluster
frnew_1:
        add     eax, 31      ;bootsector+2*fat+filenames
        cmp     [esp+16], dword 0; wanted cluster ?
        jne     frfl7_1
        call    read_chs_sector
        cmp     [FDC_Status], 0
        jne     fdc_status_error_5
        mov     edi, [esp+8]
        call    give_back_application_data_1
        add     [esp+8], dword 512
        dec     dword [esp+12]   ; last wanted cluster ?
        cmp     [esp+12], dword 0
        je      frnoread_1
        jmp     frfl8_1
frfl7_1:
        dec     dword [esp+16]
frfl8_1:
        mov     edi, [n_sector]
        shl     edi, 1      ;find next cluster from FAT
        add     edi, FLOPPY_FAT
        mov     eax, [edi]
        and     eax, 4095
        mov     edi, eax
        mov     [n_sector], edi
        cmp     edi, 4095   ;eof  - cluster
        jz      frnoread2_1
        cmp     [esp+24], dword 512;eof  - size
        jb      frnoread_1
        sub     [esp+24], dword 512
        jmp     frnew_1
 
read_chs_sector:
        call    calculate_chs
        call    ReadSectWithRetr
        ret
 
frnoread2_1:
        cmp     [esp+16], dword 0; eof without read ?
        je      frnoread_1
        mov     [fdc_irq_func], fdc_null
        pop     edi esi edx ecx
        add     esp, 4
        pop     ebx; ebx <- eax : size of file
        add     esp, 36
        mov     eax, 6; end of file
        mov     [flp_status], 0
        ret
 
frnoread_1:
        pop     edi esi edx ecx
        add     esp, 4
        pop     ebx; ebx <- eax : size of file
        add     esp, 36
        xor     eax, eax
        mov     [flp_status], eax
        ret
 
fdc_status_error_5:
        pop     edi esi edx ecx
        add     esp, 4
        pop     ebx; ebx <- eax : size of file
        add     esp, 36
        jmp     fdc_status_error_1
 
read_flp_root:
        pusha
        call    check_label
        cmp     [FDC_Status], 0
        jne     unnecessary_root_read
        cmp     [root_read], 1
        je      unnecessary_root_read
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 1; Сторона
        mov     [FDD_Sector], 2; Сектор
        mov     edi, FLOPPY_BUFF
        call    SeekTrack
read_flp_root_1:
        call    ReadSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_root_read
        push    edi
        call    give_back_application_data_1
        pop     edi
        add     edi, 512
        inc     [FDD_Sector]
        cmp     [FDD_Sector], 16
        jne     read_flp_root_1
        mov     [root_read], 1
unnecessary_root_read:
        popa
        ret
 
 
read_flp_fat:
        pusha
        call    check_label
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat
        cmp     [flp_fat], 1
        je      unnecessary_flp_fat
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 0; Сторона
        mov     [FDD_Sector], 2; Сектор
        mov     edi, FLOPPY_BUFF
        call    SeekTrack
read_flp_fat_1:
        call    ReadSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat
        push    edi
        call    give_back_application_data_1
        pop     edi
        add     edi, 512
        inc     [FDD_Sector]
        cmp     [FDD_Sector], 19
        jne     read_flp_fat_1
        mov     [FDD_Sector], 1
        mov     [FDD_Head], 1
        call    ReadSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat
        call    give_back_application_data_1
        call    calculatefatchain_flp
        mov     [root_read], 0
        mov     [flp_fat], 1
unnecessary_flp_fat:
        popa
        ret
 
calculatefatchain_flp:
        pushad
 
        mov     esi, FLOPPY_BUFF
        mov     edi, FLOPPY_FAT
 
 fcnew_1:
        mov     eax, dword [esi]
        mov     ebx, dword [esi+4]
        mov     ecx, dword [esi+8]
        mov     edx, ecx
        shr     edx, 4;8 ok
        shr     dx, 4;7 ok
        xor     ch, ch
        shld    ecx, ebx, 20;6 ok
        shr     cx, 4;5 ok
        shld    ebx, eax, 12
        and     ebx, 0x0fffffff;4 ok
        shr     bx, 4;3 ok
        shl     eax, 4
        and     eax, 0x0fffffff;2 ok
        shr     ax, 4;1 ok
        mov     dword [edi], eax
        add     edi, 4
        mov     dword [edi], ebx
        add     edi, 4
        mov     dword [edi], ecx
        add     edi, 4
        mov     dword [edi], edx
        add     edi, 4
        add     esi, 12
 
        cmp     edi, FLOPPY_FAT+2856*2;2849 clusters
        jnz     fcnew_1
 
        popad
        ret
 
check_label:
        pushad
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 0; Сторона
        mov     [FDD_Sector], 1; Сектор
        call    SetUserInterrupts
        call    FDDMotorON
        call    RecalibrateFDD
        cmp     [FDC_Status], 0
        jne     fdc_status_error
        call    SeekTrack
        cmp     [FDC_Status], 0
        jne     fdc_status_error
        call    ReadSectWithRetr
        cmp     [FDC_Status], 0
        jne     fdc_status_error
        mov     esi, flp_label
        mov     edi, FDD_BUFF+39
        mov     ecx, 15
        cld
        rep cmpsb
        je      same_label
        mov     [root_read], 0
        mov     [flp_fat], 0
same_label:
        mov     esi, FDD_BUFF+39
        mov     edi, flp_label
        mov     ecx, 15
        cld
        rep movsb
        popad
        ret
fdc_status_error:
        popad
        ret
 
save_flp_root:
        pusha
        call    check_label
        cmp     [FDC_Status], 0
        jne     unnecessary_root_save
        cmp     [root_read], 0
        je      unnecessary_root_save
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 1; Сторона
        mov     [FDD_Sector], 2; Сектор
        mov     esi, FLOPPY_BUFF
        call    SeekTrack
save_flp_root_1:
        push    esi
        call    take_data_from_application_1
        pop     esi
        add     esi, 512
        call    WriteSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_root_save
        inc     [FDD_Sector]
        cmp     [FDD_Sector], 16
        jne     save_flp_root_1
unnecessary_root_save:
        mov     [fdc_irq_func], fdc_null
        popa
        ret
 
save_flp_fat:
        pusha
        call    check_label
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat_save
        cmp     [flp_fat], 0
        je      unnecessary_flp_fat_save
        call    restorefatchain_flp
        mov     [FDD_Track], 0; Цилиндр
        mov     [FDD_Head], 0; Сторона
        mov     [FDD_Sector], 2; Сектор
        mov     esi, FLOPPY_BUFF
        call    SeekTrack
save_flp_fat_1:
        push    esi
        call    take_data_from_application_1
        pop     esi
        add     esi, 512
        call    WriteSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat_save
        inc     [FDD_Sector]
        cmp     [FDD_Sector], 19
        jne     save_flp_fat_1
        mov     [FDD_Sector], 1
        mov     [FDD_Head], 1
        call    take_data_from_application_1
        call    WriteSectWithRetr
        cmp     [FDC_Status], 0
        jne     unnecessary_flp_fat_save
        mov     [root_read], 0
unnecessary_flp_fat_save:
        mov     [fdc_irq_func], fdc_null
        popa
        ret
 
 
restorefatchain_flp:   ; restore fat chain
        pushad
 
        mov     esi, FLOPPY_FAT
        mov     edi, FLOPPY_BUFF
 
  fcnew2_1:
        mov     eax, dword [esi]
        mov     ebx, dword [esi+4]
        shl     ax, 4
        shl     eax, 4
        shl     bx, 4
        shr     ebx, 4
        shrd    eax, ebx, 8
        shr     ebx, 8
        mov     dword [edi], eax
        add     edi, 4
        mov     word [edi], bx
        add     edi, 2
        add     esi, 8
 
        cmp     edi, FLOPPY_BUFF+0x1200;4274 bytes - all used FAT
        jb      fcnew2_1
 
        mov     esi, FLOPPY_BUFF  ; duplicate fat chain
        mov     edi, FLOPPY_BUFF+0x1200
        mov     ecx, 0x1200/4
        cld
        rep movsd
 
        popad
        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
        xor     edx, edx
        mov     ebx, 2
        div     ebx
        mov     [FDD_Track], al
        mov     [FDD_Head], 0
        test    edx, edx
        jz      no_head_2
        inc     [FDD_Head]
no_head_2:
        mov     dl, [old_track]
        cmp     dl, [FDD_Track]
        je      no_seek_track_1
        call    SeekTrack
no_seek_track_1:
        ret
 
 
get_cluster_of_a_path_flp:
;---------------------------------------------------------
; input  : EBX = pointer to a path string
;          (example: the path "/files/data/document" become
;                             "files......data.......document...0"
;          '.' = space char
;          '0' = char(0) (ASCII=0) !!! )
; output : if (CARRY=1) -> ERROR in the PATH
;          if (CARRY=0) -> EAX=cluster
;---------------------------------------------------------
 
        push    edx
        mov     edx, ebx
 
search_end_of_path_flp:
        cmp     [save_flag], 0
        jne     search_end_of_path_flp_1
        cmp     byte [edx], 0
        je      found_end_of_path_flp
        jmp     search_end_of_path_flp_2
search_end_of_path_flp_1:
        cmp     byte [edx+12], 0
        je      found_end_of_path_flp
search_end_of_path_flp_2:
        inc     edx; '/'
        call    analyze_directory_flp
        jc      directory_not_found_flp
 
        mov     eax, [ebx+20-2] ; read the HIGH 16bit cluster field
        mov     ax, [ebx+26]    ; read the LOW 16bit cluster field
        and     eax, 0xfff    ;[fatMASK]
        add     edx, 11         ; 8+3 (name+extension)
        jmp     search_end_of_path_flp
 
found_end_of_path_flp:
        inc     edx
        mov     [pointer_file_name_flp], edx
        pop     edx
        clc                     ; no errors
        ret
 
directory_not_found_flp:
        pop     edx
        stc                     ; errors occour
        ret
 
analyze_directory_flp:
;--------------------------------
; input  : EAX = first cluster of the directory
;          EBX = pointer to filename
; output : IF CARRY=0 EAX = sector where th file is found
;                     EBX = pointer in buffer
;                     [buffer .. buffer+511]
;                     ECX,EDX,EDI,EDI not changed
;          IF CARRY=1
;--------------------------------
        push    ebx;[esp+16]
        push    ecx
        push    edx
        push    esi
        push    edi
 
 
adr56_flp:
        mov     [clust_tmp_flp], eax
        add     eax, 31
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jne     not_found_file_analyze_flp
 
        mov     ecx, 512/32
        mov     ebx, FDD_BUFF
 
adr1_analyze_flp:
        mov     esi, edx;[esp+16]
        mov     edi, ebx
        cld
        push    ecx
        mov     ecx, 11
        rep cmpsb
        pop     ecx
        je      found_file_analyze_flp
 
        add     ebx, 32
        loop    adr1_analyze_flp
 
        mov     eax, [clust_tmp_flp]
        shl     eax, 1      ;find next cluster from FAT
        add     eax, FLOPPY_FAT
        mov     eax, [eax]
        and     eax, 4095
        cmp     eax, 0x0ff8
        jb      adr56_flp
not_found_file_analyze_flp:
        pop     edi
        pop     esi
        pop     edx
        pop     ecx
        add     esp, 4
        stc     ;file not found
        ret
 
found_file_analyze_flp:
        pop     edi
        pop     esi
        pop     edx
        pop     ecx
        add     esp, 4
        clc     ;file found
        ret
 
 
; \begin{diamond}
fat_find_lfn:
; in: esi->name
;     [esp+4] = next
;     [esp+8] = first
;     [esp+C]... - possibly parameters for first and next
; out: CF=1 - file not found, eax=error code
;      else CF=0, esi->next name component, edi->direntry
        pusha
        lea     eax, [esp+0Ch+20h]
        call    dword [eax-4]
        jc      .reterr
        sub     esp, 262*2      ; reserve place for LFN
        push    0               ; for fat_get_name: read ASCII name
.l1:
        lea     ebp, [esp+4]
        call    fat_get_name
        jc      .l2
        call    fat_compare_name
        jz      .found
.l2:
        mov     ebp, [esp+8+262*2+4]
        lea     eax, [esp+0Ch+20h+262*2+4]
        call    dword [eax-8]
        jnc     .l1
        add     esp, 262*2+4
.reterr:
        mov     [esp+28], eax
        stc
        popa
        ret
.found:
        add     esp, 262*2+4
        mov     ebp, [esp+8]
; if this is LFN entry, advance to true entry
        cmp     byte [edi+11], 0xF
        jnz     @f
        lea     eax, [esp+0Ch+20h]
        call    dword [eax-8]
        jc      .reterr
@@:
        add     esp, 8          ; CF=0
        push    esi
        push    edi
        popa
        ret
 
uglobal
; this is for delete support
fd_prev_sector          dd      ?
fd_prev_prev_sector     dd      ?
endg
 
flp_root_next:
        cmp     edi, OS_BASE+0xD200-0x20
        jae     @f
        add     edi, 0x20
        ret     ; CF=0
@@:
; read next sector
        inc     dword [eax]
        cmp     dword [eax], 14
        jae     flp_root_first.readerr
        push    [fd_prev_sector]
        pop     [fd_prev_prev_sector]
        push    eax
        mov     eax, [eax]
        add     eax, 19-1
        mov     [fd_prev_sector], eax
        pop     eax
flp_root_first:
        mov     eax, [eax]
        pusha
        add     eax, 19
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .readerr
        mov     edi, FDD_BUFF
        ret     ; CF=0
.readerr:
        stc
        ret
 
flp_rootmem_first:
        mov     edi, FLOPPY_BUFF
        clc
        ret
flp_rootmem_next:
        add     edi, 0x20
        cmp     edi, FLOPPY_BUFF+14*0x200
        cmc
flp_rootmem_next_write:
flp_rootmem_begin_write:
flp_rootmem_end_write:
        ret
flp_rootmem_extend_dir:
        stc
        ret
 
flp_notroot_next:
        cmp     edi, OS_BASE+0xD200-0x20
        jae     flp_notroot_next_sector
        add     edi, 0x20
        ret     ; CF=0
flp_notroot_next_sector:
        push    ecx
        mov     ecx, [eax]
        push    [fd_prev_sector]
        pop     [fd_prev_prev_sector]
        add     ecx, 31
        mov     [fd_prev_sector], ecx
        mov     ecx, [(ecx-31)*2+FLOPPY_FAT]
        and     ecx, 0xFFF
        cmp     ecx, 2849
        jae     flp_notroot_first.err2
        mov     [eax], ecx
        pop     ecx
flp_notroot_first:
        mov     eax, [eax]
        cmp     eax, 2
        jb      .err
        cmp     eax, 2849
        jae     .err
        pusha
        add     eax, 31
        call    read_chs_sector
        popa
        mov     edi, FDD_BUFF
        cmp     [FDC_Status], 0
        jnz     .err
        ret     ; CF=0
.err2:
        pop     ecx
.err:
        stc
        ret
flp_notroot_begin_write:
        pusha
        mov     eax, [eax]
        add     eax, 31
        call    read_chs_sector
        popa
        ret
flp_notroot_end_write:
        pusha
        mov     eax, [eax]
        add     eax, 31
        call    save_chs_sector
        popa
        ret
flp_notroot_next_write:
        cmp     edi, OS_BASE+0xD200
        jae     @f
        ret
@@:
        call    flp_notroot_end_write
        jmp     flp_notroot_next_sector
flp_notroot_extend_dir:
; find free cluster in FAT
        pusha
        xor     eax, eax
        mov     edi, FLOPPY_FAT
        mov     ecx, 2849
        repnz scasw
        jnz     .notfound
        mov     word [edi-2], 0xFFF     ; mark as last cluster
        sub     edi, FLOPPY_FAT
        shr     edi, 1
        dec     edi
        mov     eax, [esp+28]
        mov     ecx, [eax]
        mov     [FLOPPY_FAT+ecx*2], di
        mov     [eax], edi
        xor     eax, eax
        mov     edi, FDD_BUFF
        mov     ecx, 128
        rep stosd
        popa
        call    flp_notroot_end_write
        mov     edi, FDD_BUFF
        clc
        ret
.notfound:
        popa
        stc
        ret
 
fd_find_lfn:
; in: esi+ebp -> name
; out: CF=1 - file not found
;      else CF=0 and edi->direntry, eax=directory cluster (0 for root)
        push    esi edi
        push    0
        push    flp_root_first
        push    flp_root_next
.loop:
        call    fat_find_lfn
        jc      .notfound
        cmp     byte [esi], 0
        jz      .found
.continue:
        test    byte [edi+11], 10h
        jz      .notfound
        movzx   eax, word [edi+26]      ; cluster
        mov     [esp+8], eax
        mov     dword [esp+4], flp_notroot_first
        mov     dword [esp], flp_notroot_next
        jmp     .loop
.notfound:
        add     esp, 12
        pop     edi esi
        stc
        ret
.found:
        test    ebp, ebp
        jz      @f
        mov     esi, ebp
        xor     ebp, ebp
        jmp     .continue
@@:
        mov     eax, [esp+8]
        add     eax, 31
        cmp     dword [esp], flp_root_next
        jnz     @f
        add     eax, -31+19
@@:
        add     esp, 16         ; CF=0
        pop     esi
        ret
 
;----------------------------------------------------------------
;
;  fs_FloppyRead - LFN variant for reading floppy
;
;  esi  points to filename
;  ebx  pointer to 64-bit number = first wanted byte, 0+
;       may be ebx=0 - start from first byte
;  ecx  number of bytes to read, 0+
;  edx  mem location to return data
;
;  ret ebx = bytes read or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_FloppyRead:
        call    read_flp_fat
        cmp     byte [esi], 0
        jnz     @f
        or      ebx, -1
        mov     eax, 10         ; access denied
        ret
@@:
        push    edi
        call    fd_find_lfn
        jnc     .found
        pop     edi
        or      ebx, -1
        mov     eax, 5          ; file not found
        ret
.found:
        test    ebx, ebx
        jz      .l1
        cmp     dword [ebx+4], 0
        jz      @f
        xor     ebx, ebx
.reteof:
        mov     eax, 6          ; EOF
        pop     edi
        ret
@@:
        mov     ebx, [ebx]
.l1:
        push    ecx edx
        push    0
        mov     eax, [edi+28]
        sub     eax, ebx
        jb      .eof
        cmp     eax, ecx
        jae     @f
        mov     ecx, eax
        mov     byte [esp], 6           ; EOF
@@:
        movzx   edi, word [edi+26]
.new:
        jecxz   .done
        test    edi, edi
        jz      .eof
        cmp     edi, 0xFF8
        jae     .eof
        sub     ebx, 512
        jae     .skip
        lea     eax, [edi+31]
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .err
        lea     eax, [FDD_BUFF+ebx+512]
        neg     ebx
        push    ecx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        mov     ebx, edx
        call    memmove
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        xor     ebx, ebx
.skip:
        movzx   edi, word [edi*2+FLOPPY_FAT]
        jmp     .new
.done:
        mov     ebx, edx
        pop     eax edx ecx edi
        sub     ebx, edx
        ret
.eof:
        mov     ebx, edx
        pop     eax edx ecx
        jmp     .reteof
.err:
        mov     ebx, edx
        pop     eax edx ecx edi
        sub     ebx, edx
        mov     al, 11
        ret
 
;----------------------------------------------------------------
;
;  fs_FloppyReadFolder - LFN variant for reading floppy folders
;
;  esi  points to filename
;  ebx  pointer to structure: 32-bit number = first wanted block, 0+
;                           & flags (bitfields)
; flags: bit 0: 0=ANSI names, 1=UNICODE names
;  ecx  number of blocks to read, 0+
;  edx  mem location to return data
;
;  ret ebx = blocks read or 0xffffffff folder not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_FloppyReadFolder:
        call    read_flp_fat
        push    edi
        cmp     byte [esi], 0
        jz      .root
        call    fd_find_lfn
        jnc     .found
        pop     edi
        or      ebx, -1
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
.found:
        test    byte [edi+11], 0x10     ; do not allow read files
        jnz     .found_dir
        pop     edi
        or      ebx, -1
        mov     eax, ERROR_ACCESS_DENIED
        ret
.found_dir:
        movzx   eax, word [edi+26]
        add     eax, 31
        push    0
        jmp     .doit
.root:
        mov     eax, 19
        push    14
.doit:
        push    ecx ebp
        sub     esp, 262*2      ; reserve space for LFN
        mov     ebp, esp
        push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE names
        mov     ebx, [ebx]
; init header
        push    eax ecx
        mov     edi, edx
        mov     ecx, 32/4
        xor     eax, eax
        rep stosd
        pop     ecx eax
        mov     byte [edx], 1   ; version
        mov     esi, edi        ; esi points to BDFE
.main_loop:
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .error
        mov     edi, FDD_BUFF
        push    eax
.l1:
        call    fat_get_name
        jc      .l2
        cmp     byte [edi+11], 0xF
        jnz     .do_bdfe
        add     edi, 0x20
        cmp     edi, OS_BASE+0xD200
        jb      .do_bdfe
        pop     eax
        inc     eax
        dec     byte [esp+262*2+12]
        jz      .done
        jns     @f
; read next sector from FAT
        mov     eax, [(eax-31-1)*2+FLOPPY_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        jae     .done
        add     eax, 31
        mov     byte [esp+262*2+12], 0
@@:
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .error
        mov     edi, FDD_BUFF
        push    eax
.do_bdfe:
        inc     dword [edx+8]   ; new file found
        dec     ebx
        jns     .l2
        dec     ecx
        js      .l2
        inc     dword [edx+4]   ; new file block copied
        call    fat_entry_to_bdfe
.l2:
        add     edi, 0x20
        cmp     edi, OS_BASE+0xD200
        jb      .l1
        pop     eax
        inc     eax
        dec     byte [esp+262*2+12]
        jz      .done
        jns     @f
; read next sector from FAT
        mov     eax, [(eax-31-1)*2+FLOPPY_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        jae     .done
        add     eax, 31
        mov     byte [esp+262*2+12], 0
@@:
        jmp     .main_loop
.error:
        add     esp, 262*2+4
        pop     ebp ecx edi edi
        or      ebx, -1
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
.done:
        add     esp, 262*2+4
        pop     ebp
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ecx
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        pop     ecx edi edi
        ret
 
;----------------------------------------------------------------
;
;  fs_FloppyRewrite - LFN variant for writing sys floppy
;
;  esi  points to filename
;  ebx  ignored (reserved)
;  ecx  number of bytes to write, 0+
;  edx  mem location to data
;
;  ret ebx = number of written bytes
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
@@:
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
fsfrfe2:
        popad
fsfrfe:
        mov     eax, 11
        xor     ebx, ebx
        ret
 
fs_FloppyCreateFolder:
        mov     al, 1
        jmp     fs_FloppyRewrite.common
 
fs_FloppyRewrite:
        xor     eax, eax
.common:
        cmp     byte [esi], 0
        jz      @b
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jnz     fsfrfe
        pushad
        xor     edi, edi
        push    esi
        test    ebp, ebp
        jz      @f
        mov     esi, ebp
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
        lea     edi, [esi-1]
        jmp     @b
@@:
        pop     esi
        test    edi, edi
        jnz     .noroot
        test    ebp, ebp
        jnz     .hasebp
        call    read_flp_root
        cmp     [FDC_Status], 0
        jnz     fsfrfe2
        push    flp_rootmem_extend_dir
        push    flp_rootmem_end_write
        push    flp_rootmem_next_write
        push    flp_rootmem_begin_write
        xor     ebp, ebp
        push    ebp
        push    flp_rootmem_first
        push    flp_rootmem_next
        jmp     .common1
.hasebp:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [ebp], 0
        jz      .ret1
        push    ebp
        xor     ebp, ebp
        call    fd_find_lfn
        pop     esi
        jc      .notfound0
        jmp     .common0
.noroot:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [edi+1], 0
        jz      .ret1
; check existence
        mov     byte [edi], 0
        push    edi
        call    fd_find_lfn
        pop     esi
        mov     byte [esi], '/'
        jnc     @f
.notfound0:
        mov     eax, ERROR_FILE_NOT_FOUND
.ret1:
        mov     [esp+28], eax
        popad
        xor     ebx, ebx
        ret
@@:
        inc     esi
.common0:
        test    byte [edi+11], 0x10     ; must be directory
        mov     eax, ERROR_ACCESS_DENIED
        jz      .ret1
        movzx   ebp, word [edi+26]      ; ebp=cluster
        mov     eax, ERROR_FAT_TABLE
        cmp     ebp, 2
        jb      .ret1
        cmp     ebp, 2849
        jae     .ret1
        push    flp_notroot_extend_dir
        push    flp_notroot_end_write
        push    flp_notroot_next_write
        push    flp_notroot_begin_write
        push    ebp
        push    flp_notroot_first
        push    flp_notroot_next
.common1:
        call    fat_find_lfn
        jc      .notfound
; found
        test    byte [edi+11], 10h
        jz      .exists_file
; found directory; if we are creating directory, return OK,
;                  if we are creating file, say "access denied"
        add     esp, 28
        popad
        test    al, al
        mov     eax, ERROR_ACCESS_DENIED
        jz      @f
        mov     al, 0
@@:
        xor     ebx, ebx
        ret
.exists_file:
; found file; if we are creating directory, return "access denied",
;             if we are creating file, delete existing file and continue
        cmp     byte [esp+28+28], 0
        jz      @f
        add     esp, 28
        popad
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
@@:
; delete FAT chain
        push    edi
        xor     eax, eax
        mov     dword [edi+28], eax     ; zero size
        xchg    ax, word [edi+26]       ; start cluster
        test    eax, eax
        jz      .done1
@@:
        cmp     eax, 0xFF8
        jae     .done1
        lea     edi, [FLOPPY_FAT + eax*2] ; position in FAT
        xor     eax, eax
        xchg    ax, [edi]
        jmp     @b
.done1:
        pop     edi
        call    get_time_for_file
        mov     [edi+22], ax
        call    get_date_for_file
        mov     [edi+24], ax
        mov     [edi+18], ax
        or      byte [edi+11], 20h      ; set 'archive' attribute
        jmp     .doit
.notfound:
; file is not found; generate short name
        call    fat_name_is_legal
        jc      @f
        add     esp, 28
        popad
        mov     eax, ERROR_FILE_NOT_FOUND
        xor     ebx, ebx
        ret
@@:
        sub     esp, 12
        mov     edi, esp
        call    fat_gen_short_name
.test_short_name_loop:
        push    esi edi ecx
        mov     esi, edi
        lea     eax, [esp+12+12+8]
        mov     [eax], ebp
        call    dword [eax-4]
        jc      .found
.test_short_name_entry:
        cmp     byte [edi+11], 0xF
        jz      .test_short_name_cont
        mov     ecx, 11
        push    esi edi
        repz cmpsb
        pop     edi esi
        jz      .short_name_found
.test_short_name_cont:
        lea     eax, [esp+12+12+8]
        call    dword [eax-8]
        jnc     .test_short_name_entry
        jmp     .found
.short_name_found:
        pop     ecx edi esi
        call    fat_next_short_name
        jnc     .test_short_name_loop
.disk_full:
        add     esp, 12+28
        popa
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.found:
        pop     ecx edi esi
; now find space in directory
; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
        mov     al, '~'
        push    ecx edi
        mov     ecx, 8
        repnz scasb
        push    1
        pop     eax     ; 1 entry
        jnz     .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
        xor     eax, eax
@@:
        cmp     byte [esi], 0
        jz      @f
        inc     esi
        inc     eax
        jmp     @b
@@:
        sub     esi, eax
        add     eax, 12+13
        mov     ecx, 13
        push    edx
        cdq
        div     ecx
        pop     edx
.notilde:
        push    -1
        push    -1
; find  successive entries in directory
        xor     ecx, ecx
        push    eax
        lea     eax, [esp+12+8+12+8]
        mov     [eax], ebp
        call    dword [eax-4]
        pop     eax
        jnc     .scan_dir
.fsfrfe3:
        add     esp, 8+8+12+28
        popad
        mov     eax, 11
        xor     ebx, ebx
        ret
.scan_dir:
        cmp     byte [edi], 0
        jz      .free
        cmp     byte [edi], 0xE5
        jz      .free
        xor     ecx, ecx
.scan_cont:
        push    eax
        lea     eax, [esp+12+8+12+8]
        call    dword [eax-8]
        pop     eax
        jnc     .scan_dir
        cmp     [FDC_Status], 0
        jnz     .fsfrfe3
        push    eax
        lea     eax, [esp+12+8+12+8]
        call    dword [eax+16]          ; extend directory
        pop     eax
        jnc     .scan_dir
        add     esp, 8+8+12+28
        popad
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.free:
        test    ecx, ecx
        jnz     @f
        mov     [esp], edi
        mov     ecx, [esp+8+8+12+8]
        mov     [esp+4], ecx
        xor     ecx, ecx
@@:
        inc     ecx
        cmp     ecx, eax
        jb      .scan_cont
; found!
; calculate name checksum
        push    esi ecx
        mov     esi, [esp+8+8]
        mov     ecx, 11
        xor     eax, eax
@@:
        ror     al, 1
        add     al, [esi]
        inc     esi
        loop    @b
        pop     ecx esi
        pop     edi
        pop     dword [esp+8+12+8]
; edi points to first entry in free chunk
        dec     ecx
        jz      .nolfn
        push    esi
        push    eax
        lea     eax, [esp+8+8+12+8]
        call    dword [eax+4]         ; begin write
        mov     al, 40h
.writelfn:
        or      al, cl
        mov     esi, [esp+4]
        push    ecx
        dec     ecx
        imul    ecx, 13
        add     esi, ecx
        stosb
        mov     cl, 5
        call    fs_RamdiskRewrite.read_symbols
        mov     ax, 0xF
        stosw
        mov     al, [esp+4]
        stosb
        mov     cl, 6
        call    fs_RamdiskRewrite.read_symbols
        xor     eax, eax
        stosw
        mov     cl, 2
        call    fs_RamdiskRewrite.read_symbols
        pop     ecx
        lea     eax, [esp+8+8+12+8]
        call    dword [eax+8]         ; next write
        xor     eax, eax
        loop    .writelfn
        pop     eax
        pop     esi
;        lea     eax, [esp+8+12+8]
;        call    dword [eax+12]          ; end write
.nolfn:
        xchg    esi, [esp]
        mov     ecx, 11
        rep movsb
        mov     word [edi], 20h         ; attributes
        sub     edi, 11
        pop     esi ecx
        add     esp, 12
        mov     byte [edi+13], 0        ; tenths of a second at file creation time
        call    get_time_for_file
        mov     [edi+14], ax            ; creation time
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+16], ax            ; creation date
        mov     [edi+24], ax            ; last write date
        mov     [edi+18], ax            ; last access date
        and     word [edi+20], 0        ; high word of cluster
        and     word [edi+26], 0        ; low word of cluster - to be filled
        and     dword [edi+28], 0       ; file size - to be filled
        cmp     byte [esp+28+28], 0
        jz      .doit
; create directory
        mov     byte [edi+11], 10h      ; attributes: folder
        mov     ecx, 32*2
        mov     edx, edi
.doit:
        lea     eax, [esp+8]
        call    dword [eax+12]  ; flush directory
        push    ecx
        push    edi
        push    0
        mov     esi, edx
        test    ecx, ecx
        jz      .done
        mov     ecx, 2849
        mov     edi, FLOPPY_FAT
        push    0       ; first cluster
.write_loop:
; allocate new cluster
        xor     eax, eax
        repnz scasw
        mov     al, ERROR_DISK_FULL
        jnz     .ret
        dec     edi
        dec     edi
 
        mov     eax, edi
        sub     eax, FLOPPY_FAT
 
        shr     eax, 1                  ; eax = cluster
        mov     word [edi], 0xFFF       ; mark as last cluster
        xchg    edi, [esp+4]
        cmp     dword [esp], 0
        jz      .first
        stosw
        jmp     @f
.first:
        mov     [esp], eax
@@:
        mov     edi, [esp+4]
        inc     ecx
; write data
        push    ecx edi
        mov     ecx, 512
        cmp     dword [esp+20], ecx
        jae     @f
        mov     ecx, [esp+20]
@@:
        mov     edi, FDD_BUFF
        cmp     byte [esp+24+28+28], 0
        jnz     .writedir
        push    ecx
        rep movsb
        pop     ecx
.writedircont:
        push    ecx
        sub     ecx, 512
        neg     ecx
        push    eax
        xor     eax, eax
        rep stosb
        pop     eax
        add     eax, 31
        pusha
        call    save_chs_sector
        popa
        pop     ecx
        cmp     [FDC_Status], 0
        jnz     .diskerr
        sub     [esp+20], ecx
        pop     edi ecx
        jnz     .write_loop
.done:
        xor     eax, eax
.ret:
        pop     ebx edi edi ecx
        mov     [esp+28+28], eax
        lea     eax, [esp+8]
        call    dword [eax+4]
        mov     [edi+26], bx
        mov     ebx, esi
        sub     ebx, edx
        mov     [edi+28], ebx
        call    dword [eax+12]
        mov     [esp+28+16], ebx
        test    ebp, ebp
        jnz     @f
        call    save_flp_root
@@:
        add     esp, 28
        cmp     [FDC_Status], 0
        jnz     .err3
        call    save_flp_fat
        cmp     [FDC_Status], 0
        jnz     .err3
        popa
        ret
.err3:
        popa
        mov     al, 11
        xor     ebx, ebx
        ret
.diskerr:
        sub     esi, ecx
        mov     eax, 11
        pop     edi ecx
        jmp     .ret
.writedir:
        push    ecx
        mov     ecx, 32/4
        push    ecx esi
        rep movsd
        pop     esi ecx
        mov     dword [edi-32], '.   '
        mov     dword [edi-32+4], '    '
        mov     dword [edi-32+8], '    '
        mov     byte [edi-32+11], 10h
        mov     word [edi-32+26], ax
        push    esi
        rep movsd
        pop     esi
        mov     dword [edi-32], '..  '
        mov     dword [edi-32+4], '    '
        mov     dword [edi-32+8], '    '
        mov     byte [edi-32+11], 10h
        mov     ecx, [esp+28+8]
        mov     word [edi-32+26], cx
        pop     ecx
        jmp     .writedircont
 
;----------------------------------------------------------------
;
;  fs_FloppyWrite - LFN variant for writing to floppy
;
;  esi  points to filename
;  ebx  pointer to 64-bit number = first wanted byte, 0+
;       may be ebx=0 - start from first byte
;  ecx  number of bytes to write, 0+
;  edx  mem location to data
;
;  ret ebx = bytes written (maybe 0)
;      eax = 0 ok write or other = errormsg
;
;--------------------------------------------------------------
 
@@:
        push    ERROR_ACCESS_DENIED
fs_FloppyWrite.ret0:
        pop     eax
        xor     ebx, ebx
        ret
 
fs_FloppyWrite.ret11:
        push    11
        jmp     fs_FloppyWrite.ret0
 
fs_FloppyWrite:
        cmp     byte [esi], 0
        jz      @b
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jnz     .ret11
        pushad
        call    fd_find_lfn
        jnc     .found
        popad
        push    ERROR_FILE_NOT_FOUND
        jmp     .ret0
.found:
; FAT does not support files larger than 4GB
        test    ebx, ebx
        jz      .l1
        cmp     dword [ebx+4], 0
        jz      @f
.eof:
        popad
        push    ERROR_END_OF_FILE
        jmp     .ret0
@@:
        mov     ebx, [ebx]
.l1:
; now edi points to direntry, ebx=start byte to write,
; ecx=number of bytes to write, edx=data pointer
 
; extend file if needed
        add     ecx, ebx
        jc      .eof    ; FAT does not support files larger than 4GB
        push    eax     ; save directory cluster
        push    0       ; return value=0
 
        call    get_time_for_file
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+24], ax            ; last write date
        mov     [edi+18], ax            ; last access date
 
        push    dword [edi+28]          ; save current file size
        cmp     ecx, [edi+28]
        jbe     .length_ok
        cmp     ecx, ebx
        jz      .length_ok
        call    floppy_extend_file
        jnc     .length_ok
        mov     [esp+4], eax
; floppy_extend_file can return two error codes: FAT table error or disk full.
; First case is fatal error, in second case we may write some data
        cmp     al, ERROR_DISK_FULL
        jz      .disk_full
        pop     eax
        pop     eax
        mov     [esp+4+28], eax
        pop     eax
        popad
        xor     ebx, ebx
        ret
.disk_full:
; correct number of bytes to write
        mov     ecx, [edi+28]
        cmp     ecx, ebx
        ja      .length_ok
.ret:
        pop     eax
        pop     eax
        mov     [esp+4+28], eax ; eax=return value
        pop     eax
        sub     edx, [esp+20]
        mov     [esp+16], edx   ; ebx=number of written bytes
        popad
        ret
.length_ok:
; save FAT & directory
; note that directory must be saved first because save_flp_fat uses buffer at 0xD000
        mov     esi, [edi+28]
        movzx   edi, word [edi+26]      ; starting cluster
        mov     eax, [esp+8]
        pusha
        call    save_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .device_err
        call    save_flp_fat
        cmp     [FDC_Status], 0
        jz      @f
.device_err:
        mov     byte [esp+4], 11
        jmp     .ret
@@:
 
; now ebx=start pos, ecx=end pos, both lie inside file
        sub     ecx, ebx
        jz      .ret
        call    SetUserInterrupts
.write_loop:
; skip unmodified sectors
        cmp     dword [esp], 0x200
        jb      .modify
        sub     ebx, 0x200
        jae     .skip
        add     ebx, 0x200
.modify:
        lea     eax, [edi+31]   ; current sector
; get length of data in current sector
        push    ecx
        sub     ebx, 0x200
        jb      .hasdata
        neg     ebx
        xor     ecx, ecx
        jmp     @f
.hasdata:
        neg     ebx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
; load sector if needed
        cmp     dword [esp+4], 0        ; we don't need to read uninitialized data
        jz      .noread
        cmp     ecx, 0x200      ; we don't need to read sector if it is fully rewritten
        jz      .noread
        cmp     ecx, esi        ; (same for the last sector)
        jz      .noread
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jz      @f
.device_err2:
        pop     ecx
        jmp     .device_err
@@:
.noread:
; zero uninitialized data if file was extended (because floppy_extend_file does not this)
        push    eax ecx edi
        xor     eax, eax
        mov     ecx, 0x200
        sub     ecx, [esp+4+12]
        jbe     @f
        mov     edi, FDD_BUFF
        add     edi, [esp+4+12]
        rep stosb
@@:
; zero uninitialized data in the last sector
        mov     ecx, 0x200
        sub     ecx, esi
        jbe     @f
        mov     edi, FDD_BUFF
        add     edi, esi
        rep stosb
@@:
        pop     edi ecx eax
; copy new data
        push    eax
        mov     eax, edx
        neg     ebx
        jecxz   @f
        add     ebx, FDD_BUFF+0x200
        call    memmove
        xor     ebx, ebx
@@:
        pop     eax
; save sector
        pusha
        call    save_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .device_err2
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        jz      .done
.skip:
.next_cluster:
        movzx   edi, word [edi*2+FLOPPY_FAT]
        sub     esi, 0x200
        jae     @f
        xor     esi, esi
@@:
        sub     dword [esp], 0x200
        jae     .write_loop
        and     dword [esp], 0
        jmp     .write_loop
.done:
        mov     [fdc_irq_func], fdc_null
        jmp     .ret
 
floppy_extend_file.zero_size:
        xor     eax, eax
        jmp     floppy_extend_file.start_extend
 
; extends file on floppy to given size (new data area is undefined)
; in: edi->direntry, ecx=new size
; out: CF=0 => OK, eax=0
;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL)
floppy_extend_file:
        push    ecx
; find the last cluster of file
        movzx   eax, word [edi+26]      ; first cluster
        mov     ecx, [edi+28]
        jecxz   .zero_size
@@:
        sub     ecx, 0x200
        jbe     @f
        mov     eax, [eax*2+FLOPPY_FAT]
        and     eax, 0xFFF
        jz      .fat_err
        cmp     eax, 0xFF8
        jb      @b
.fat_err:
        pop     ecx
        push    ERROR_FAT_TABLE
        pop     eax
        stc
        ret
@@:
        push    eax
        mov     eax, [eax*2+FLOPPY_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        pop     eax
        jb      .fat_err
; set length to full number of sectors
        sub     [edi+28], ecx
.start_extend:
        pop     ecx
; now do extend
        push    edx esi
        mov     esi, FLOPPY_FAT+2*2       ; start scan from cluster 2
        mov     edx, 2847               ; number of clusters to scan
.extend_loop:
        cmp     [edi+28], ecx
        jae     .extend_done
; add new sector
        push    ecx
        push    edi
.scan:
        mov     ecx, edx
        mov     edi, esi
        jecxz   .disk_full
        push    eax
        xor     eax, eax
        repnz scasw
        pop     eax
        jnz     .disk_full
        mov     word [edi-2], 0xFFF
        mov     esi, edi
        mov     edx, ecx
        sub     edi, FLOPPY_FAT
        shr     edi, 1
        dec     edi     ; now edi=new cluster
        test    eax, eax
        jz      .first_cluster
        mov     [FLOPPY_FAT+eax*2], di
        jmp     @f
.first_cluster:
        pop     eax             ; eax->direntry
        push    eax
        mov     [eax+26], di
@@:
        mov     eax, edi        ; eax=new cluster
        pop     edi             ; edi->direntry
        pop     ecx             ; ecx=required size
        add     dword [edi+28], 0x200
        jmp     .extend_loop
.extend_done:
        mov     [edi+28], ecx
        pop     esi edx
        xor     eax, eax        ; CF=0
        ret
.disk_full:
        pop     edi ecx
        pop     esi edx
        stc
        push    ERROR_DISK_FULL
        pop     eax
        ret
 
;----------------------------------------------------------------
;
;  fs_FloppySetFileEnd - set end of file on floppy
;
;  esi  points to filename
;  ebx  points to 64-bit number = new file size
;  ecx  ignored (reserved)
;  edx  ignored (reserved)
;
;  ret eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_FloppySetFileEnd:
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jnz     ret11
        cmp     byte [esi], 0
        jnz     @f
.access_denied:
        push    ERROR_ACCESS_DENIED
        jmp     .ret
@@:
        push    edi
        call    fd_find_lfn
        jnc     @f
        pop     edi
        push    ERROR_FILE_NOT_FOUND
.ret:
        pop     eax
        jmp     .doret
@@:
; must not be directory
        test    byte [edi+11], 10h
        jz      @f
        pop     edi
        jmp     .access_denied
@@:
; file size must not exceed 4 Gb
        cmp     dword [ebx+4], 0
        jz      @f
        pop     edi
        push    ERROR_END_OF_FILE
        jmp     .ret
@@:
        push    eax
; set file modification date/time to current
        call    fat_update_datetime
        mov     eax, [ebx]
        cmp     eax, [edi+28]
        jb      .truncate
        ja      .expand
        pop     eax
        pushad
        call    save_chs_sector
        popad
        pop     edi
        xor     eax, eax
        cmp     [FDC_Status], 0
        jz      @f
        mov     al, 11
@@:
.doret:
        mov     [fdc_irq_func], fdc_null
        ret
.expand:
        push    ecx
        push    dword [edi+28]  ; save old size
        mov     ecx, eax
        call    floppy_extend_file
        push    eax     ; return code
        jnc     .expand_ok
        cmp     al, ERROR_DISK_FULL
        jz      .disk_full
        pop     eax ecx ecx edi edi
        jmp     .doret
.device_err:
        pop     eax
.device_err2:
        pop     ecx ecx eax edi
        push    11
        jmp     .ret
.disk_full:
.expand_ok:
; save directory & FAT
        mov     eax, [edi+28]
        xchg    eax, [esp+12]
        movzx   edi, word [edi+26]
        pusha
        call    save_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .device_err
        call    save_flp_fat
        cmp     [FDC_Status], 0
        jnz     .device_err
        call    SetUserInterrupts
; now zero new data
; edi = current cluster, [esp+12]=new size, [esp+4]=old size, [esp]=return code
.zero_loop:
        sub     dword [esp+4], 0x200
        jae     .next_cluster
        cmp     dword [esp+4], -0x200
        jz      .noread
        lea     eax, [edi+31]
        pusha
        call    read_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .err_next
.noread:
        mov     ecx, [esp+4]
        neg     ecx
        push    edi
        mov     edi, FDD_BUFF+0x200
        add     edi, [esp+8]
        xor     eax, eax
        mov     [esp+8], eax
        rep stosb
        pop     edi
        lea     eax, [edi+31]
        pusha
        call    save_chs_sector
        popa
        cmp     [FDC_Status], 0
        jz      .next_cluster
.err_next:
        mov     byte [esp], 11
.next_cluster:
        sub     dword [esp+12], 0x200
        jbe     .expand_done
        movzx   edi, word [FLOPPY_FAT+edi*2]
        jmp     .zero_loop
.expand_done:
        pop     eax ecx ecx edi edi
        jmp     .doret
.truncate:
        mov     [edi+28], eax
        push    ecx
        movzx   ecx, word [edi+26]
        test    eax, eax
        jz      .zero_size
; find new last sector
@@:
        sub     eax, 0x200
        jbe     @f
        movzx   ecx, word [FLOPPY_FAT+ecx*2]
        jmp     @b
@@:
; we will zero data at the end of last sector - remember it
        push    ecx
; terminate FAT chain
        lea     ecx, [FLOPPY_FAT+ecx+ecx]
        push    dword [ecx]
        mov     word [ecx], 0xFFF
        pop     ecx
        and     ecx, 0xFFF
        jmp     .delete
.zero_size:
        and     word [edi+26], 0
        push    0
.delete:
; delete FAT chain starting with ecx
; mark all clusters as free
        cmp     ecx, 0xFF8
        jae     .deleted
        lea     ecx, [FLOPPY_FAT+ecx+ecx]
        push    dword [ecx]
        and     word [ecx], 0
        pop     ecx
        and     ecx, 0xFFF
        jmp     .delete
.deleted:
        mov     edi, [edi+28]
; save directory & FAT
        mov     eax, [esp+8]
        pusha
        call    save_chs_sector
        popa
        cmp     [FDC_Status], 0
        jnz     .device_err2
        call    save_flp_fat
        cmp     [FDC_Status], 0
        jnz     .device_err2
; zero last sector, ignore errors
        pop     eax
        add     eax, 31
        and     edi, 0x1FF
        jz      .truncate_done
        call    SetUserInterrupts
        pusha
        call    read_chs_sector
        popa
        add     edi, FDD_BUFF
        mov     ecx, FDD_BUFF+0x200
        sub     ecx, edi
        push    eax
        xor     eax, eax
        rep stosb
        pop     eax
        pusha
        call    save_chs_sector
        popa
.truncate_done:
        pop     ecx eax edi
        xor     eax, eax
        jmp     .doret
 
fs_FloppyGetFileInfo:
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jnz     ret11
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2  ; unsupported
        ret
@@:
        push    edi
        call    fd_find_lfn
        jmp     fs_GetFileInfo_finish
 
ret11:
        mov     eax, 11
        ret
 
fs_FloppySetFileInfo:
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jnz     ret11
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2  ; unsupported
        ret
@@:
        push    edi
        call    fd_find_lfn
        jnc     @f
        pop     edi
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
@@:
        push    eax
        call    bdfe_to_fat_entry
        pop     eax
        pusha
        call    save_chs_sector
        popa
        pop     edi
        xor     eax, eax
        cmp     [FDC_Status], al
        jz      @f
        mov     al, 11
@@:
        ret
 
;----------------------------------------------------------------
;
;  fs_FloppyDelete - delete file or empty folder from floppy
;
;  esi  points to filename
;
;  ret  eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_FloppyDelete:
        call    read_flp_fat
        cmp     [FDC_Status], 0
        jz      @f
        push    11
        jmp     .pop_ret
@@:
        cmp     byte [esi], 0
        jnz     @f
; cannot delete root!
.access_denied:
        push    ERROR_ACCESS_DENIED
.pop_ret:
        pop     eax
        ret
@@:
        and     [fd_prev_sector], 0
        and     [fd_prev_prev_sector], 0
        push    edi
        call    fd_find_lfn
        jnc     .found
        pop     edi
        push    ERROR_FILE_NOT_FOUND
        jmp     .pop_ret
.found:
        cmp     dword [edi], '.   '
        jz      .access_denied2
        cmp     dword [edi], '..  '
        jz      .access_denied2
        test    byte [edi+11], 10h
        jz      .dodel
; we can delete only empty folders!
        push    eax
        movzx   eax, word [edi+26]
        push    ebx
        pusha
        add     eax, 31
        call    read_chs_sector
        popa
        mov     ebx, FDD_BUFF + 2*0x20
.checkempty:
        cmp     byte [ebx], 0
        jz      .empty
        cmp     byte [ebx], 0xE5
        jnz     .notempty
        add     ebx, 0x20
        cmp     ebx, FDD_BUFF + 0x200
        jb      .checkempty
        movzx   eax, word [FLOPPY_FAT + eax*2]
        pusha
        add     eax, 31
        call    read_chs_sector
        popa
        mov     ebx, FDD_BUFF
        jmp     .checkempty
.notempty:
        pop     ebx
        pop     eax
.access_denied2:
        pop     edi
        jmp     .access_denied
.empty:
        pop     ebx
        pop     eax
        pusha
        call    read_chs_sector
        popa
.dodel:
        push    eax
        movzx   eax, word [edi+26]
        xchg    eax, [esp]
; delete folder entry
        mov     byte [edi], 0xE5
; delete LFN (if present)
.lfndel:
        cmp     edi, FDD_BUFF
        ja      @f
        cmp     [fd_prev_sector], 0
        jz      .lfndone
        push    [fd_prev_sector]
        push    [fd_prev_prev_sector]
        pop     [fd_prev_sector]
        and     [fd_prev_prev_sector], 0
        pusha
        call    save_chs_sector
        popa
        pop     eax
        pusha
        call    read_chs_sector
        popa
        mov     edi, FDD_BUFF+0x200
@@:
        sub     edi, 0x20
        cmp     byte [edi], 0xE5
        jz      .lfndone
        cmp     byte [edi+11], 0xF
        jnz     .lfndone
        mov     byte [edi], 0xE5
        jmp     .lfndel
.lfndone:
        pusha
        call    save_chs_sector
        popa
; delete FAT chain
        pop     eax
@@:
        cmp     eax, 2
        jb      .done
        cmp     eax, 0xFF8
        jae     .done
        lea     eax, [FLOPPY_FAT + eax*2]
        push    dword [eax]
        and     word [eax], 0
        pop     eax
        and     eax, 0xFFF
        jmp     @b
.done:
        call    save_flp_fat
        pop     edi
        xor     eax, eax
        ret
 
; \end{diamond}

Rev 3442	Rev 3539
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; FAT12.INC ;;	6	;; FAT12.INC ;;
7	;; (C) 2005 Mario79, License: GPL ;;	7	;; (C) 2005 Mario79, License: GPL ;;
8	;; ;;	8	;; ;;
9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10		10
11	$Revision: 3442 $	11	$Revision: 3539 $
12		12
13		13
14	n_sector dd 0 ; temporary save for sector value	14	n_sector dd 0 ; temporary save for sector value
15	flp_status dd 0	15	flp_status dd 0
16	clust_tmp_flp dd 0 ; used by analyze_directory and analyze_directory_to_write	16	clust_tmp_flp dd 0 ; used by analyze_directory and analyze_directory_to_write
17	path_pointer_flp dd 0	17	path_pointer_flp dd 0
18	pointer_file_name_flp dd 0	18	pointer_file_name_flp dd 0
19	save_root_flag db 0	19	save_root_flag db 0
20	save_flag db 0	20	save_flag db 0
21	root_read db 0 ; 0-necessary to load root, 1-not to load root	21	root_read db 0 ; 0-necessary to load root, 1-not to load root
22	flp_fat db 0 ; 0-necessary to load fat, 1-not to load fat	22	flp_fat db 0 ; 0-necessary to load fat, 1-not to load fat
23	flp_number db 0 ; 1- Floppy A, 2-Floppy B	23	flp_number db 0 ; 1- Floppy A, 2-Floppy B
24	old_track db 0 ; old value track	24	old_track db 0 ; old value track
25	flp_label rb 15 ; Label and ID of inserted floppy disk	25	flp_label rb 15 ; Label and ID of inserted floppy disk
26		26
27	reserve_flp:	27	reserve_flp:
28		28
29	cli	29	cli
30	cmp [flp_status], 0	30	cmp [flp_status], 0
31	je reserve_flp_ok	31	je reserve_flp_ok
32		32
33	sti	33	sti
34	call change_task	34	call change_task
35	jmp reserve_flp	35	jmp reserve_flp
36		36
37	reserve_flp_ok:	37	reserve_flp_ok:
38		38
39	push eax	39	push eax
40	mov eax, [CURRENT_TASK]	40	mov eax, [CURRENT_TASK]
41	shl eax, 5	41	shl eax, 5
42	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]	42	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]
43	mov [flp_status], eax	43	mov [flp_status], eax
44	pop eax	44	pop eax
45	sti	45	sti
46	ret	46	ret
47		47
48		48
49	floppy_fileread:	49	floppy_fileread:
50	;----------------------------------------------------------------	50	;----------------------------------------------------------------
51	;	51	;
52	; fileread - sys floppy	52	; fileread - sys floppy
53	;	53	;
54	; eax points to filename 11 chars - for root directory	54	; eax points to filename 11 chars - for root directory
55	; ebx first wanted block ; 1+ ; if 0 then set to 1	55	; ebx first wanted block ; 1+ ; if 0 then set to 1
56	; ecx number of blocks to read ; 1+ ; if 0 then set to 1	56	; ecx number of blocks to read ; 1+ ; if 0 then set to 1
57	; edx mem location to return data	57	; edx mem location to return data
58	; esi length of filename 12*X	58	; esi length of filename 12*X
59	; edi pointer to path /fd/1/...... - for all files in nested directories	59	; edi pointer to path /fd/1/...... - for all files in nested directories
60	;	60	;
61	; ret ebx = size or 0xffffffff file not found	61	; ret ebx = size or 0xffffffff file not found
62	; eax = 0 ok read or other = errormsg	62	; eax = 0 ok read or other = errormsg
63	; 10 = access denied	63	; 10 = access denied
64	;--------------------------------------------------------------	64	;--------------------------------------------------------------
65		65
66	mov [save_flag], 0	66	mov [save_flag], 0
67	mov [path_pointer_flp], edi	67	mov [path_pointer_flp], edi
68	test esi, esi ; return ramdisk root	68	test esi, esi ; return ramdisk root
69	jnz fr_noroot_1	69	jnz fr_noroot_1
70	cmp ebx, 224/16	70	cmp ebx, 224/16
71	jbe fr_do_1	71	jbe fr_do_1
72	mov eax, 5	72	mov eax, 5
73	xor ebx, ebx	73	xor ebx, ebx
74	mov [flp_status], ebx	74	mov [flp_status], ebx
75	ret	75	ret
76		76
77	fr_do_1:	77	fr_do_1:
78	push ebx ecx edx	78	push ebx ecx edx
79	call read_flp_root	79	call read_flp_root
80	pop edx ecx ebx	80	pop edx ecx ebx
81	cmp [FDC_Status], 0	81	cmp [FDC_Status], 0
82	jne fdc_status_error_1	82	jne fdc_status_error_1
83	mov edi, edx	83	mov edi, edx
84	dec ebx	84	dec ebx
85	shl ebx, 9	85	shl ebx, 9
86	mov esi, FLOPPY_BUFF	86	mov esi, FLOPPY_BUFF
87	add esi, ebx	87	add esi, ebx
88	shl ecx, 9	88	shl ecx, 9
89	cld	89	cld
90	rep movsb	90	rep movsb
91	xor eax, eax	91	xor eax, eax
92	xor ebx, ebx	92	xor ebx, ebx
93	; mov eax,0 ; ok read	93	; mov eax,0 ; ok read
94	; mov ebx,0	94	; mov ebx,0
95	mov [flp_status], eax	95	mov [flp_status], eax
96	ret	96	ret
97	fdc_status_error_1:	97	fdc_status_error_1:
98	xor eax, eax	98	xor eax, eax
99	mov [flp_status], eax	99	mov [flp_status], eax
100	mov eax, 10	100	mov eax, 10
101	or ebx, -1	101	or ebx, -1
102	ret	102	ret
103		103
104	fr_noroot_1:	104	fr_noroot_1:
105	sub esp, 32	105	sub esp, 32
106	call expand_filename	106	call expand_filename
107	frfloppy_1:	107	frfloppy_1:
108	test ebx, ebx	108	test ebx, ebx
109	jnz frfl5_1	109	jnz frfl5_1
110	mov ebx, 1	110	mov ebx, 1
111	frfl5_1:	111	frfl5_1:
112	test ecx, ecx	112	test ecx, ecx
113	jnz frfl6_1	113	jnz frfl6_1
114	mov ecx, 1	114	mov ecx, 1
115	frfl6_1:	115	frfl6_1:
116	dec ebx	116	dec ebx
117	push eax	117	push eax
118	push eax ebx ecx edx esi edi	118	push eax ebx ecx edx esi edi
119	call read_flp_fat	119	call read_flp_fat
120	cmp [FDC_Status], 0	120	cmp [FDC_Status], 0
121	jne fdc_status_error_3_1	121	jne fdc_status_error_3_1
122	mov [FDD_Track], 0; Öèëèíäð	122	mov [FDD_Track], 0; Цилиндр
123	mov [FDD_Head], 1; Ñòîðîíà	123	mov [FDD_Head], 1; Сторона
124	mov [FDD_Sector], 2; Ñåêòîð	124	mov [FDD_Sector], 2; Сектор
125	call SeekTrack	125	call SeekTrack
126	mov dh, 14	126	mov dh, 14
127	l.20_1:	127	l.20_1:
128	call ReadSectWithRetr	128	call ReadSectWithRetr
129	cmp [FDC_Status], 0	129	cmp [FDC_Status], 0
130	jne fdc_status_error_3_1	130	jne fdc_status_error_3_1
131	mov dl, 16	131	mov dl, 16
132	mov edi, FDD_BUFF	132	mov edi, FDD_BUFF
133	inc [FDD_Sector]	133	inc [FDD_Sector]
134	l.21_1:	134	l.21_1:
135	mov esi, eax ;Name of file we want	135	mov esi, eax ;Name of file we want
136	mov ecx, 11	136	mov ecx, 11
137	cld	137	cld
138	rep cmpsb ;Found the file?	138	rep cmpsb ;Found the file?
139	je fifound_1 ;Yes	139	je fifound_1 ;Yes
140	add ecx, 21	140	add ecx, 21
141	add edi, ecx ;Advance to next entry	141	add edi, ecx ;Advance to next entry
142	dec dl	142	dec dl
143	test dl, dl	143	test dl, dl
144	jnz l.21_1	144	jnz l.21_1
145	dec dh	145	dec dh
146	test dh, dh	146	test dh, dh
147	jnz l.20_1	147	jnz l.20_1
148	fdc_status_error_3:	148	fdc_status_error_3:
149	mov eax, 5 ; file not found ?	149	mov eax, 5 ; file not found ?
150	or ebx, -1	150	or ebx, -1
151	add esp, 32+28	151	add esp, 32+28
152	mov [flp_status], 0	152	mov [flp_status], 0
153	ret	153	ret
154	fdc_status_error_3_2:	154	fdc_status_error_3_2:
155	cmp [FDC_Status], 0	155	cmp [FDC_Status], 0
156	je fdc_status_error_3	156	je fdc_status_error_3
157	fdc_status_error_3_1:	157	fdc_status_error_3_1:
158	add esp, 32+28	158	add esp, 32+28
159	jmp fdc_status_error_1	159	jmp fdc_status_error_1
160		160
161	fifound_1:	161	fifound_1:
162	mov eax, [path_pointer_flp]	162	mov eax, [path_pointer_flp]
163	cmp [eax+36], byte 0	163	cmp [eax+36], byte 0
164	je fifound_2	164	je fifound_2
165	add edi, 0xf	165	add edi, 0xf
166	mov eax, [edi]	166	mov eax, [edi]
167	and eax, 65535	167	and eax, 65535
168	mov ebx, [path_pointer_flp]	168	mov ebx, [path_pointer_flp]
169	add ebx, 36	169	add ebx, 36
170	call get_cluster_of_a_path_flp	170	call get_cluster_of_a_path_flp
171	jc fdc_status_error_3_2	171	jc fdc_status_error_3_2
172	mov ebx, [ebx-11+28] ;file size	172	mov ebx, [ebx-11+28] ;file size
173	mov [esp+20], ebx	173	mov [esp+20], ebx
174	mov [esp+24], ebx	174	mov [esp+24], ebx
175	jmp fifound_3	175	jmp fifound_3
176	fifound_2:	176	fifound_2:
177	mov ebx, [edi-11+28] ;file size	177	mov ebx, [edi-11+28] ;file size
178	mov [esp+20], ebx	178	mov [esp+20], ebx
179	mov [esp+24], ebx	179	mov [esp+24], ebx
180	add edi, 0xf	180	add edi, 0xf
181	mov eax, [edi]	181	mov eax, [edi]
182	fifound_3:	182	fifound_3:
183	and eax, 65535	183	and eax, 65535
184	mov [n_sector], eax ;eax=cluster	184	mov [n_sector], eax ;eax=cluster
185	frnew_1:	185	frnew_1:
186	add eax, 31 ;bootsector+2*fat+filenames	186	add eax, 31 ;bootsector+2*fat+filenames
187	cmp [esp+16], dword 0; wanted cluster ?	187	cmp [esp+16], dword 0; wanted cluster ?
188	jne frfl7_1	188	jne frfl7_1
189	call read_chs_sector	189	call read_chs_sector
190	cmp [FDC_Status], 0	190	cmp [FDC_Status], 0
191	jne fdc_status_error_5	191	jne fdc_status_error_5
192	mov edi, [esp+8]	192	mov edi, [esp+8]
193	call give_back_application_data_1	193	call give_back_application_data_1
194	add [esp+8], dword 512	194	add [esp+8], dword 512
195	dec dword [esp+12] ; last wanted cluster ?	195	dec dword [esp+12] ; last wanted cluster ?
196	cmp [esp+12], dword 0	196	cmp [esp+12], dword 0
197	je frnoread_1	197	je frnoread_1
198	jmp frfl8_1	198	jmp frfl8_1
199	frfl7_1:	199	frfl7_1:
200	dec dword [esp+16]	200	dec dword [esp+16]
201	frfl8_1:	201	frfl8_1:
202	mov edi, [n_sector]	202	mov edi, [n_sector]
203	shl edi, 1 ;find next cluster from FAT	203	shl edi, 1 ;find next cluster from FAT
204	add edi, FLOPPY_FAT	204	add edi, FLOPPY_FAT
205	mov eax, [edi]	205	mov eax, [edi]
206	and eax, 4095	206	and eax, 4095
207	mov edi, eax	207	mov edi, eax
208	mov [n_sector], edi	208	mov [n_sector], edi
209	cmp edi, 4095 ;eof - cluster	209	cmp edi, 4095 ;eof - cluster
210	jz frnoread2_1	210	jz frnoread2_1
211	cmp [esp+24], dword 512;eof - size	211	cmp [esp+24], dword 512;eof - size
212	jb frnoread_1	212	jb frnoread_1
213	sub [esp+24], dword 512	213	sub [esp+24], dword 512
214	jmp frnew_1	214	jmp frnew_1
215		215
216	read_chs_sector:	216	read_chs_sector:
217	call calculate_chs	217	call calculate_chs
218	call ReadSectWithRetr	218	call ReadSectWithRetr
219	ret	219	ret
220		220
221	frnoread2_1:	221	frnoread2_1:
222	cmp [esp+16], dword 0; eof without read ?	222	cmp [esp+16], dword 0; eof without read ?
223	je frnoread_1	223	je frnoread_1
224	mov [fdc_irq_func], fdc_null	224	mov [fdc_irq_func], fdc_null
225	pop edi esi edx ecx	225	pop edi esi edx ecx
226	add esp, 4	226	add esp, 4
227	pop ebx; ebx <- eax : size of file	227	pop ebx; ebx <- eax : size of file
228	add esp, 36	228	add esp, 36
229	mov eax, 6; end of file	229	mov eax, 6; end of file
230	mov [flp_status], 0	230	mov [flp_status], 0
231	ret	231	ret
232		232
233	frnoread_1:	233	frnoread_1:
234	pop edi esi edx ecx	234	pop edi esi edx ecx
235	add esp, 4	235	add esp, 4
236	pop ebx; ebx <- eax : size of file	236	pop ebx; ebx <- eax : size of file
237	add esp, 36	237	add esp, 36
238	xor eax, eax	238	xor eax, eax
239	mov [flp_status], eax	239	mov [flp_status], eax
240	ret	240	ret
241		241
242	fdc_status_error_5:	242	fdc_status_error_5:
243	pop edi esi edx ecx	243	pop edi esi edx ecx
244	add esp, 4	244	add esp, 4
245	pop ebx; ebx <- eax : size of file	245	pop ebx; ebx <- eax : size of file
246	add esp, 36	246	add esp, 36
247	jmp fdc_status_error_1	247	jmp fdc_status_error_1
248		248
249	read_flp_root:	249	read_flp_root:
250	pusha	250	pusha
251	call check_label	251	call check_label
252	cmp [FDC_Status], 0	252	cmp [FDC_Status], 0
253	jne unnecessary_root_read	253	jne unnecessary_root_read
254	cmp [root_read], 1	254	cmp [root_read], 1
255	je unnecessary_root_read	255	je unnecessary_root_read
256	mov [FDD_Track], 0; Öèëèíäð	256	mov [FDD_Track], 0; Цилиндр
257	mov [FDD_Head], 1; Ñòîðîíà	257	mov [FDD_Head], 1; Сторона
258	mov [FDD_Sector], 2; Ñåêòîð	258	mov [FDD_Sector], 2; Сектор
259	mov edi, FLOPPY_BUFF	259	mov edi, FLOPPY_BUFF
260	call SeekTrack	260	call SeekTrack
261	read_flp_root_1:	261	read_flp_root_1:
262	call ReadSectWithRetr	262	call ReadSectWithRetr
263	cmp [FDC_Status], 0	263	cmp [FDC_Status], 0
264	jne unnecessary_root_read	264	jne unnecessary_root_read
265	push edi	265	push edi
266	call give_back_application_data_1	266	call give_back_application_data_1
267	pop edi	267	pop edi
268	add edi, 512	268	add edi, 512
269	inc [FDD_Sector]	269	inc [FDD_Sector]
270	cmp [FDD_Sector], 16	270	cmp [FDD_Sector], 16
271	jne read_flp_root_1	271	jne read_flp_root_1
272	mov [root_read], 1	272	mov [root_read], 1
273	unnecessary_root_read:	273	unnecessary_root_read:
274	popa	274	popa
275	ret	275	ret
276		276
277		277
278	read_flp_fat:	278	read_flp_fat:
279	pusha	279	pusha
280	call check_label	280	call check_label
281	cmp [FDC_Status], 0	281	cmp [FDC_Status], 0
282	jne unnecessary_flp_fat	282	jne unnecessary_flp_fat
283	cmp [flp_fat], 1	283	cmp [flp_fat], 1
284	je unnecessary_flp_fat	284	je unnecessary_flp_fat
285	mov [FDD_Track], 0; Öèëèíäð	285	mov [FDD_Track], 0; Цилиндр
286	mov [FDD_Head], 0; Ñòîðîíà	286	mov [FDD_Head], 0; Сторона
287	mov [FDD_Sector], 2; Ñåêòîð	287	mov [FDD_Sector], 2; Сектор
288	mov edi, FLOPPY_BUFF	288	mov edi, FLOPPY_BUFF
289	call SeekTrack	289	call SeekTrack
290	read_flp_fat_1:	290	read_flp_fat_1:
291	call ReadSectWithRetr	291	call ReadSectWithRetr
292	cmp [FDC_Status], 0	292	cmp [FDC_Status], 0
293	jne unnecessary_flp_fat	293	jne unnecessary_flp_fat
294	push edi	294	push edi
295	call give_back_application_data_1	295	call give_back_application_data_1
296	pop edi	296	pop edi
297	add edi, 512	297	add edi, 512
298	inc [FDD_Sector]	298	inc [FDD_Sector]
299	cmp [FDD_Sector], 19	299	cmp [FDD_Sector], 19
300	jne read_flp_fat_1	300	jne read_flp_fat_1
301	mov [FDD_Sector], 1	301	mov [FDD_Sector], 1
302	mov [FDD_Head], 1	302	mov [FDD_Head], 1
303	call ReadSectWithRetr	303	call ReadSectWithRetr
304	cmp [FDC_Status], 0	304	cmp [FDC_Status], 0
305	jne unnecessary_flp_fat	305	jne unnecessary_flp_fat
306	call give_back_application_data_1	306	call give_back_application_data_1
307	call calculatefatchain_flp	307	call calculatefatchain_flp
308	mov [root_read], 0	308	mov [root_read], 0
309	mov [flp_fat], 1	309	mov [flp_fat], 1
310	unnecessary_flp_fat:	310	unnecessary_flp_fat:
311	popa	311	popa
312	ret	312	ret
313		313
314	calculatefatchain_flp:	314	calculatefatchain_flp:
315	pushad	315	pushad
316		316
317	mov esi, FLOPPY_BUFF	317	mov esi, FLOPPY_BUFF
318	mov edi, FLOPPY_FAT	318	mov edi, FLOPPY_FAT
319		319
320	fcnew_1:	320	fcnew_1:
321	mov eax, dword [esi]	321	mov eax, dword [esi]
322	mov ebx, dword [esi+4]	322	mov ebx, dword [esi+4]
323	mov ecx, dword [esi+8]	323	mov ecx, dword [esi+8]
324	mov edx, ecx	324	mov edx, ecx
325	shr edx, 4;8 ok	325	shr edx, 4;8 ok
326	shr dx, 4;7 ok	326	shr dx, 4;7 ok
327	xor ch, ch	327	xor ch, ch
328	shld ecx, ebx, 20;6 ok	328	shld ecx, ebx, 20;6 ok
329	shr cx, 4;5 ok	329	shr cx, 4;5 ok
330	shld ebx, eax, 12	330	shld ebx, eax, 12
331	and ebx, 0x0fffffff;4 ok	331	and ebx, 0x0fffffff;4 ok
332	shr bx, 4;3 ok	332	shr bx, 4;3 ok
333	shl eax, 4	333	shl eax, 4
334	and eax, 0x0fffffff;2 ok	334	and eax, 0x0fffffff;2 ok
335	shr ax, 4;1 ok	335	shr ax, 4;1 ok
336	mov dword [edi], eax	336	mov dword [edi], eax
337	add edi, 4	337	add edi, 4
338	mov dword [edi], ebx	338	mov dword [edi], ebx
339	add edi, 4	339	add edi, 4
340	mov dword [edi], ecx	340	mov dword [edi], ecx
341	add edi, 4	341	add edi, 4
342	mov dword [edi], edx	342	mov dword [edi], edx
343	add edi, 4	343	add edi, 4
344	add esi, 12	344	add esi, 12
345		345
346	cmp edi, FLOPPY_FAT+2856*2;2849 clusters	346	cmp edi, FLOPPY_FAT+2856*2;2849 clusters
347	jnz fcnew_1	347	jnz fcnew_1
348		348
349	popad	349	popad
350	ret	350	ret
351		351
352	check_label:	352	check_label:
353	pushad	353	pushad
354	mov [FDD_Track], 0; Öèëèíäð	354	mov [FDD_Track], 0; Цилиндр
355	mov [FDD_Head], 0; Ñòîðîíà	355	mov [FDD_Head], 0; Сторона
356	mov [FDD_Sector], 1; Ñåêòîð	356	mov [FDD_Sector], 1; Сектор
357	call SetUserInterrupts	357	call SetUserInterrupts
358	call FDDMotorON	358	call FDDMotorON
359	call RecalibrateFDD	359	call RecalibrateFDD
360	cmp [FDC_Status], 0	360	cmp [FDC_Status], 0
361	jne fdc_status_error	361	jne fdc_status_error
362	call SeekTrack	362	call SeekTrack
363	cmp [FDC_Status], 0	363	cmp [FDC_Status], 0
364	jne fdc_status_error	364	jne fdc_status_error
365	call ReadSectWithRetr	365	call ReadSectWithRetr
366	cmp [FDC_Status], 0	366	cmp [FDC_Status], 0
367	jne fdc_status_error	367	jne fdc_status_error
368	mov esi, flp_label	368	mov esi, flp_label
369	mov edi, FDD_BUFF+39	369	mov edi, FDD_BUFF+39
370	mov ecx, 15	370	mov ecx, 15
371	cld	371	cld
372	rep cmpsb	372	rep cmpsb
373	je same_label	373	je same_label
374	mov [root_read], 0	374	mov [root_read], 0
375	mov [flp_fat], 0	375	mov [flp_fat], 0
376	same_label:	376	same_label:
377	mov esi, FDD_BUFF+39	377	mov esi, FDD_BUFF+39
378	mov edi, flp_label	378	mov edi, flp_label
379	mov ecx, 15	379	mov ecx, 15
380	cld	380	cld
381	rep movsb	381	rep movsb
382	popad	382	popad
383	ret	383	ret
384	fdc_status_error:	384	fdc_status_error:
385	popad	385	popad
386	ret	386	ret
387		387
388	save_flp_root:	388	save_flp_root:
389	pusha	389	pusha
390	call check_label	390	call check_label
391	cmp [FDC_Status], 0	391	cmp [FDC_Status], 0
392	jne unnecessary_root_save	392	jne unnecessary_root_save
393	cmp [root_read], 0	393	cmp [root_read], 0
394	je unnecessary_root_save	394	je unnecessary_root_save
395	mov [FDD_Track], 0; Öèëèíäð	395	mov [FDD_Track], 0; Цилиндр
396	mov [FDD_Head], 1; Ñòîðîíà	396	mov [FDD_Head], 1; Сторона
397	mov [FDD_Sector], 2; Ñåêòîð	397	mov [FDD_Sector], 2; Сектор
398	mov esi, FLOPPY_BUFF	398	mov esi, FLOPPY_BUFF
399	call SeekTrack	399	call SeekTrack
400	save_flp_root_1:	400	save_flp_root_1:
401	push esi	401	push esi
402	call take_data_from_application_1	402	call take_data_from_application_1
403	pop esi	403	pop esi
404	add esi, 512	404	add esi, 512
405	call WriteSectWithRetr	405	call WriteSectWithRetr
406	cmp [FDC_Status], 0	406	cmp [FDC_Status], 0
407	jne unnecessary_root_save	407	jne unnecessary_root_save
408	inc [FDD_Sector]	408	inc [FDD_Sector]
409	cmp [FDD_Sector], 16	409	cmp [FDD_Sector], 16
410	jne save_flp_root_1	410	jne save_flp_root_1
411	unnecessary_root_save:	411	unnecessary_root_save:
412	mov [fdc_irq_func], fdc_null	412	mov [fdc_irq_func], fdc_null
413	popa	413	popa
414	ret	414	ret
415		415
416	save_flp_fat:	416	save_flp_fat:
417	pusha	417	pusha
418	call check_label	418	call check_label
419	cmp [FDC_Status], 0	419	cmp [FDC_Status], 0
420	jne unnecessary_flp_fat_save	420	jne unnecessary_flp_fat_save
421	cmp [flp_fat], 0	421	cmp [flp_fat], 0
422	je unnecessary_flp_fat_save	422	je unnecessary_flp_fat_save
423	call restorefatchain_flp	423	call restorefatchain_flp
424	mov [FDD_Track], 0; Öèëèíäð	424	mov [FDD_Track], 0; Цилиндр
425	mov [FDD_Head], 0; Ñòîðîíà	425	mov [FDD_Head], 0; Сторона
426	mov [FDD_Sector], 2; Ñåêòîð	426	mov [FDD_Sector], 2; Сектор
427	mov esi, FLOPPY_BUFF	427	mov esi, FLOPPY_BUFF
428	call SeekTrack	428	call SeekTrack
429	save_flp_fat_1:	429	save_flp_fat_1:
430	push esi	430	push esi
431	call take_data_from_application_1	431	call take_data_from_application_1
432	pop esi	432	pop esi
433	add esi, 512	433	add esi, 512
434	call WriteSectWithRetr	434	call WriteSectWithRetr
435	cmp [FDC_Status], 0	435	cmp [FDC_Status], 0
436	jne unnecessary_flp_fat_save	436	jne unnecessary_flp_fat_save
437	inc [FDD_Sector]	437	inc [FDD_Sector]
438	cmp [FDD_Sector], 19	438	cmp [FDD_Sector], 19
439	jne save_flp_fat_1	439	jne save_flp_fat_1
440	mov [FDD_Sector], 1	440	mov [FDD_Sector], 1
441	mov [FDD_Head], 1	441	mov [FDD_Head], 1
442	call take_data_from_application_1	442	call take_data_from_application_1
443	call WriteSectWithRetr	443	call WriteSectWithRetr
444	cmp [FDC_Status], 0	444	cmp [FDC_Status], 0
445	jne unnecessary_flp_fat_save	445	jne unnecessary_flp_fat_save
446	mov [root_read], 0	446	mov [root_read], 0
447	unnecessary_flp_fat_save:	447	unnecessary_flp_fat_save:
448	mov [fdc_irq_func], fdc_null	448	mov [fdc_irq_func], fdc_null
449	popa	449	popa
450	ret	450	ret
451		451
452		452
453	restorefatchain_flp: ; restore fat chain	453	restorefatchain_flp: ; restore fat chain
454	pushad	454	pushad
455		455
456	mov esi, FLOPPY_FAT	456	mov esi, FLOPPY_FAT
457	mov edi, FLOPPY_BUFF	457	mov edi, FLOPPY_BUFF
458		458
459	fcnew2_1:	459	fcnew2_1:
460	mov eax, dword [esi]	460	mov eax, dword [esi]
461	mov ebx, dword [esi+4]	461	mov ebx, dword [esi+4]
462	shl ax, 4	462	shl ax, 4
463	shl eax, 4	463	shl eax, 4
464	shl bx, 4	464	shl bx, 4
465	shr ebx, 4	465	shr ebx, 4
466	shrd eax, ebx, 8	466	shrd eax, ebx, 8
467	shr ebx, 8	467	shr ebx, 8
468	mov dword [edi], eax	468	mov dword [edi], eax
469	add edi, 4	469	add edi, 4
470	mov word [edi], bx	470	mov word [edi], bx
471	add edi, 2	471	add edi, 2
472	add esi, 8	472	add esi, 8
473		473
474	cmp edi, FLOPPY_BUFF+0x1200;4274 bytes - all used FAT	474	cmp edi, FLOPPY_BUFF+0x1200;4274 bytes - all used FAT
475	jb fcnew2_1	475	jb fcnew2_1
476		476
477	mov esi, FLOPPY_BUFF ; duplicate fat chain	477	mov esi, FLOPPY_BUFF ; duplicate fat chain
478	mov edi, FLOPPY_BUFF+0x1200	478	mov edi, FLOPPY_BUFF+0x1200
479	mov ecx, 0x1200/4	479	mov ecx, 0x1200/4
480	cld	480	cld
481	rep movsd	481	rep movsd
482		482
483	popad	483	popad
484	ret	484	ret
485		485
486		486
487	save_chs_sector:	487	save_chs_sector:
488	call calculate_chs	488	call calculate_chs
489	call WriteSectWithRetr	489	call WriteSectWithRetr
490	ret	490	ret
491		491
492	calculate_chs:	492	calculate_chs:
493	mov bl, [FDD_Track]	493	mov bl, [FDD_Track]
494	mov [old_track], bl	494	mov [old_track], bl
495	mov ebx, 18	495	mov ebx, 18
496	xor edx, edx	496	xor edx, edx
497	div ebx	497	div ebx
498	inc edx	498	inc edx
499	mov [FDD_Sector], dl	499	mov [FDD_Sector], dl
500	xor edx, edx	500	xor edx, edx

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fat12.inc – Rev 3442 → 3539