WebSVN – Kolibri OS – Diff – /kernel/trunk/blkdev/hd_drv.inc


$Revision: 431 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; Low-level driver for HDD access
; DMA support by Mario79
 
;**************************************************************************
;
;   0x600008  - first entry in cache list
;
;            +0   - lba sector
;            +4   - state of cache sector
;                   0 = empty
;                   1 = used for read  ( same as in hd )
;                   2 = used for write ( differs from hd )
;
;      +65536 - cache entries
;
;**************************************************************************
 
align 4
hd_read:
;-----------------------------------------------------------
; input  : eax = block to read
;          ebx = destination
;-----------------------------------------------------------
        and     [hd_error], 0
    push  ecx esi edi           ; scan cache
 
    mov   ecx,cache_max         ; entries in cache
    mov   esi,OS_BASE+0x600000+8
    mov   edi,1
 
  hdreadcache:
 
    cmp   dword [esi+4],0       ; empty
    je    nohdcache
 
    cmp   [esi],eax             ; correct sector
    je    yeshdcache
 
  nohdcache:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   hdreadcache
 
    call  find_empty_slot       ; ret in edi
    cmp   [hd_error],0
    jne   return_01
        cmp     [dma_hdd], 1
        jnz     .nodma
        call    hd_read_dma
        jmp     @f
.nodma:
        call    hd_read_pio
@@:
 
    lea   esi,[edi*8+OS_BASE+0x600000]
    mov   [esi],eax             ; sector number
    mov   dword [esi+4],1       ; hd read - mark as same as in hd
 
  yeshdcache:
 
    mov   esi,edi
    shl   esi,9
    add   esi,OS_BASE+0x600000+65536
    mov   edi,ebx
    mov   ecx,512/4
    cld
    rep   movsd                 ; move data
 return_01:
    pop   edi esi ecx
    ret
 
align 4
hd_read_pio:
    push  eax edx
 
    call  wait_for_hd_idle
    cmp   [hd_error],0
    jne   hd_read_error
 
    cli
    xor   eax,eax
    mov   edx,[hdbase]
    inc   edx
    out   dx,al   ; ATAFeatures à¥£¨áâà "®á®¡¥­­®áâ¥©"
    inc   edx
    inc   eax
    out   dx,al   ; ATASectorCount áçñâç¨ª á¥ªâ®à®¢
    inc   edx
    mov   eax,[esp+4]
    out   dx,al   ; ATASectorNumber à¥£¨áâà ­®¬¥à  á¥ªâ®à 
    shr   eax,8
    inc   edx
    out   dx,al   ; ATACylinder ­®¬¥à æ¨«¨­¤à  (¬« ¤è¨© ¡ ©â)
    shr   eax,8
    inc   edx
    out   dx,al   ; ­®¬¥à æ¨«¨­¤à  (áâ àè¨© ¡ ©â)
    shr   eax,8
    inc   edx
    and   al,1+2+4+8
    add   al,byte [hdid]
    add   al,128+64+32
    out   dx,al   ; ­®¬¥à £®«®¢ª¨/­®¬¥à ¤¨áª 
    inc   edx
    mov   al,20h
    out   dx,al   ; ATACommand à¥£¨áâà ª®¬ ­¤
    sti
 
    call  wait_for_sector_buffer
 
    cmp   [hd_error],0
    jne   hd_read_error
 
    cli
    push  edi
    shl   edi,9
    add   edi,OS_BASE+0x600000+65536
    mov   ecx,256
    mov   edx,[hdbase]
    cld
    rep   insw
    pop   edi
    sti
 
    pop   edx eax
    ret
 
disable_ide_int:
;        mov edx,[hdbase]
;        add edx,0x206
;        mov al,2
;        out dx,al
        cli
        ret
 
enable_ide_int:
;        mov edx,[hdbase]
;        add edx,0x206
;        mov al,0
;        out dx,al
        sti
        ret
 
align 4
hd_write:
;-----------------------------------------------------------
; input  : eax = block
;          ebx = pointer to memory
;-----------------------------------------------------------
    push  ecx esi edi
 
    ; check if the cache already has the sector and overwrite it
 
    mov   ecx,cache_max
    mov   esi,OS_BASE+0x600000+8
    mov   edi,1
 
  hdwritecache:
 
    cmp   dword [esi+4],0       ; if cache slot is empty
    je    not_in_cache_write
 
    cmp   [esi],eax             ; if the slot has the sector
    je    yes_in_cache_write
 
  not_in_cache_write:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   hdwritecache
 
    ; sector not found in cache
    ; write the block to a new location
 
    call  find_empty_slot       ; ret in edi
    cmp   [hd_error],0
    jne   hd_write_access_denied
 
    lea   esi,[edi*8+OS_BASE+0x600000]
    mov   [esi],eax             ; sector number
 
  yes_in_cache_write:
 
    mov   dword [esi+4],2       ; write - differs from hd
 
    shl   edi,9
    add   edi,OS_BASE+0x600000+65536
    mov   esi,ebx
    mov   ecx,512/4
    cld
    rep   movsd                 ; move data
 hd_write_access_denied:
    pop   edi esi ecx
    ret
 
 
write_cache:
;-----------------------------------------------------------
; write all changed sectors to disk
;-----------------------------------------------------------
    push  eax ecx edx esi edi
 
    ; write difference ( 2 ) from cache to hd
 
    mov   ecx,cache_max
    mov   esi,OS_BASE+0x600000+8
    mov   edi,1
 
  write_cache_more:
 
    cmp   dword [esi+4],2       ; if cache slot is not different
    jne   .write_chain
 
    mov   dword [esi+4],1       ; same as in hd
    mov   eax,[esi]             ; eax = sector to write
 
    cmp   eax,[PARTITION_START]
    jb    danger
    cmp   eax,[PARTITION_END]
    ja    danger
 
        cmp     [allow_dma_write], 1
        jnz     .nodma
        cmp     [dma_hdd], 1
        jnz     .nodma
; ¡ê¥¤¨­ï¥¬ § ¯¨áì æ¥¯®çª¨ ¯®á«¥¤®¢ â¥«ì­ëå á¥ªâ®à®¢ ¢ ®¤­® ®¡à é¥­¨¥ ª ¤¨áªã
        cmp     ecx, 1
        jz      .nonext
        cmp     dword [esi+8+4], 2
        jnz     .nonext
        push    eax
        inc     eax
        cmp     eax, [esi+8]
        pop     eax
        jnz     .nonext
        cmp     [cache_chain_started], 1
        jz      @f
        mov     [cache_chain_started], 1
        mov     [cache_chain_size], 0
        mov     [cache_chain_pos], edi
        mov     [cache_chain_ptr], esi
@@:
        inc     [cache_chain_size]
        cmp     [cache_chain_size], 64
        jnz     .continue
        jmp     .write_chain
.nonext:
        call    flush_cache_chain
        mov     [cache_chain_size], 1
        mov     [cache_chain_ptr], esi
        call    write_cache_sector
        jmp     .continue
.nodma:
        call    cache_write_pio
.write_chain:
        call    flush_cache_chain
 
.continue:
  danger:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   write_cache_more
        call    flush_cache_chain
 return_02:
    pop   edi esi edx ecx eax
    ret
 
flush_cache_chain:
        cmp     [cache_chain_started], 0
        jz      @f
        call    write_cache_chain
        mov     [cache_chain_started], 0
@@:
        ret
 
align 4
cache_write_pio:
    call  disable_ide_int
 
    call  wait_for_hd_idle
    cmp   [hd_error],0
    jne   hd_write_error
 
;    cli
    xor   eax,eax
    mov   edx,[hdbase]
    inc   edx
    out   dx,al
    inc   edx
    inc   eax
    out   dx,al
    inc   edx
    mov   eax,[esi]             ; eax = sector to write
    out   dx,al
    shr   eax,8
    inc   edx
    out   dx,al
    shr   eax,8
    inc   edx
    out   dx,al
    shr   eax,8
    inc   edx
    and   al,1+2+4+8
    add   al,byte [hdid]
    add   al,128+64+32
    out   dx,al
    inc   edx
    mov   al,30h
    out   dx,al
;    sti
 
    call  wait_for_sector_buffer
 
    cmp   [hd_error],0
    jne   hd_write_error
 
    push  ecx esi
 
;    cli
    mov   esi,edi
    shl   esi,9
    add   esi,OS_BASE+0x600000+65536    ; esi = from memory position
    mov   ecx,256
    mov   edx,[hdbase]
    cld
    rep   outsw
;    sti
 
    call  enable_ide_int
    pop   esi ecx
 
    ret
 
align 4
find_empty_slot:
;-----------------------------------------------------------
; find empty or read slot, flush cache if next 10% is used by write
; output : edi = cache slot
;-----------------------------------------------------------
;    push  ecx esi
 
  search_again:
 
    mov   ecx,cache_max*10/100
    mov   edi,[cache_search_start]
 
  search_for_empty:
 
    inc   edi
    cmp   edi,cache_max
    jbe   inside_cache
    mov   edi,1
 
  inside_cache:
 
    cmp   dword [edi*8+OS_BASE+0x600000+4],2    ; get cache slot info
    jb    found_slot                    ; it's empty or read
    dec   ecx
    jnz   search_for_empty
 
    call  write_cache                   ; no empty slots found, write all
    cmp   [hd_error],0
    jne   found_slot_access_denied
 
    jmp   search_again                  ; and start again
 
  found_slot:
 
    mov   [cache_search_start],edi
  found_slot_access_denied:
    ret
 
align 4
clear_hd_cache:
 
    push  eax ecx edi
    mov   edi,OS_BASE+0x600000
    mov   ecx,16384
    xor   eax,eax
    cld
    rep   stosd                 ; clear hd cache with 0
    mov   [cache_search_start],eax
    mov   [fat_in_cache],-1
    mov   [fat_change],0
    pop   edi ecx eax
    ret
 
save_hd_wait_timeout:
 
    push  eax
    mov   eax,[timer_ticks];[0xfdf0]
    add   eax,300               ; 3 sec timeout
    mov   [hd_wait_timeout],eax
    pop   eax
    ret
 
align 4
check_hd_wait_timeout:
 
    push  eax
    mov   eax,[hd_wait_timeout]
    cmp   [timer_ticks], eax ;[0xfdf0],eax
    jg    hd_timeout_error
    pop   eax
    mov   [hd_error],0
    ret
 
;iglobal
;  hd_timeout_str   db 'K : FS - HD timeout',0
;  hd_read_str      db 'K : FS - HD read error',0
;  hd_write_str     db 'K : FS - HD write error',0
;  hd_lba_str       db 'K : FS - HD LBA error',0
;endg
 
hd_timeout_error:
 
;    call  clear_hd_cache
;    call  clear_application_table_status
;    mov   esi,hd_timeout_str
;    call  sys_msg_board_str
    DEBUGF 1,"K : FS - HD timeout\n"
;    jmp   $
    mov   [hd_error],1
    pop   eax
    ret
 
hd_read_error:
 
;    call  clear_hd_cache
;    call  clear_application_table_status
;    mov   esi,hd_read_str
;    call  sys_msg_board_str
    DEBUGF 1,"K : FS - HD read error\n"
    pop   edx eax
    ret
 
hd_write_error:
 
;    call  clear_hd_cache
;    call  clear_application_table_status
;    mov   esi,hd_write_str
;    call  sys_msg_board_str
    DEBUGF 1,"K : FS - HD write error\n"
    ret
 
hd_write_error_dma:
;        call    clear_hd_cache
;        call    clear_application_table_status
;        mov     esi, hd_write_str
;        call    sys_msg_board_str
	DEBUGF 1,"K : FS - HD read error\n"
        pop     esi
        ret
 
hd_lba_error:
;    call  clear_hd_cache
;    call  clear_application_table_status
;    mov   esi,hd_lba_str
;    call  sys_msg_board_str
    DEBUGF 1,"K : FS - HD LBA error\n"
    jmp   LBA_read_ret
 
 
align 4
wait_for_hd_idle:
 
    push  eax edx
 
    call  save_hd_wait_timeout
 
    mov   edx,[hdbase]
    add   edx,0x7
 
  wfhil1:
 
    call  check_hd_wait_timeout
    cmp   [hd_error],0
    jne   @f
 
    in    al,dx
    test  al,128
    jnz   wfhil1
 
 @@:
 
    pop   edx eax
    ret
 
 
align 4
wait_for_sector_buffer:
 
    push  eax edx
 
    mov   edx,[hdbase]
    add   edx,0x7
 
    call  save_hd_wait_timeout
 
  hdwait_sbuf:                  ; wait for sector buffer to be ready
 
    call  check_hd_wait_timeout
    cmp   [hd_error],0
    jne   @f
 
    in    al,dx
    test  al,8
    jz    hdwait_sbuf
 
    mov   [hd_error],0
 
    cmp   [hd_setup],1          ; do not mark error for setup request
    je    buf_wait_ok
 
    test  al,1                  ; previous command ended up with an error
    jz    buf_wait_ok
 @@:
    mov   [hd_error],1
 
  buf_wait_ok:
 
    pop   edx eax
    ret
 
; \begin{Mario79}
align 4
wait_for_sector_dma_ide0:
        push    eax
        push    edx
        call    save_hd_wait_timeout
.wait:
        call    change_task
        cmp     [irq14_func], hdd_irq14
        jnz     .done
        call    check_hd_wait_timeout
        cmp     [hd_error], 0
        jz      .wait
        mov     [irq14_func], hdd_irq_null
        mov     dx, [IDEContrRegsBaseAddr]
        mov     al, 0
        out     dx, al
.done:
        pop     edx
        pop     eax
        ret
 
align 4
wait_for_sector_dma_ide1:
        push    eax
        push    edx
        call    save_hd_wait_timeout
.wait:
        call    change_task
        cmp     [irq15_func], hdd_irq15
        jnz     .done
        call    check_hd_wait_timeout
        cmp     [hd_error], 0
        jz      .wait
        mov     [irq15_func], hdd_irq_null
        mov     dx, [IDEContrRegsBaseAddr]
        add     dx, 8
        mov     al, 0
        out     dx, al
.done:
        pop     edx
        pop     eax
        ret
 
iglobal
align 4
; note that IDE descriptor table must be 4-byte aligned and do not cross 4K boundary
IDE_descriptor_table:
        dd      OS_BASE+284000h
        dw      2000h
        dw      8000h
 
dma_cur_sector  dd      not 40h
irq14_func      dd      hdd_irq_null
irq15_func      dd      hdd_irq_null
endg
 
uglobal
; all uglobals are zeroed at boot
dma_process     dd      0
dma_slot_ptr    dd      0
cache_chain_pos dd      0
cache_chain_ptr dd      0
cache_chain_size        db      0
cache_chain_started     db      0
dma_task_switched       db      0
dma_hdd         db      0
allow_dma_write db      0
endg
 
align 4
hdd_irq14:
        pushfd
        cli
        pushad
        mov     [irq14_func], hdd_irq_null
        mov     dx, [IDEContrRegsBaseAddr]
        mov     al, 0
        out     dx, al
        call    update_counters
        mov     ebx, [dma_process]
        cmp     [CURRENT_TASK], ebx
        jz      .noswitch
        mov     [dma_task_switched], 1
        mov     edi, [dma_slot_ptr]
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
        mov     [CURRENT_TASK], ebx
        mov     [TASK_BASE], edi
        mov     byte [0xFFFF], 1
        call    do_change_task
.noswitch:
        popad
        popfd
align 4
hdd_irq_null:
        ret
 
align 4
hdd_irq15:
        pushfd
        cli
        pushad
        mov     [irq15_func], hdd_irq_null
        mov     dx, [IDEContrRegsBaseAddr]
        add     dx, 8
        mov     al, 0
        out     dx, al
        call    update_counters
        mov     ebx, [dma_process]
        cmp     [CURRENT_TASK], ebx
        jz      .noswitch
        mov     [dma_task_switched], 1
        mov     edi, [dma_slot_ptr]
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
        mov     [CURRENT_TASK], ebx
        mov     [TASK_BASE], edi
        mov     byte [0xFFFF], 1
        call    do_change_task
.noswitch:
        popad
        popfd
        ret
 
align 4
hd_read_dma:
        push    eax
        push    edx
        mov     edx, [dma_cur_sector]
        cmp     eax, edx
        jb      .notread
        add     edx, 15
        cmp     [esp+4], edx
        ja      .notread
        mov     eax, [esp+4]
        sub     eax, [dma_cur_sector]
        shl     eax, 9
        add     eax, OS_BASE+0x284000
        push    ecx esi edi
        mov     esi, eax
        shl     edi, 9
        add     edi, OS_BASE+0x610000
        mov     ecx, 512/4
        cld
        rep     movsd
        pop     edi esi ecx
        pop     edx
        pop     eax
        ret
.notread:
        mov     eax, IDE_descriptor_table-OS_BASE
        mov     dword [eax+OS_BASE],  0x284000
        mov     word [eax+4+OS_BASE], 0x2000
        mov     dx, [IDEContrRegsBaseAddr]
        cmp     [hdbase], 0x1F0
        jz      @f
        add     edx, 8
@@:
        push    edx
        add     edx, 4
        out     dx, eax
        pop     edx
        mov     al, 0
        out     dx, al
        add     edx, 2
        mov     al, 6
        out     dx, al
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jnz     hd_read_error
        call    disable_ide_int
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al
        inc     edx
        mov     eax, 10h
        out     dx, al
        inc     edx
        mov     eax, [esp+4]
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        and     al, 0xF
        add     al, byte [hdid]
        add     al, 11100000b
        out     dx, al
        inc     edx
        mov     al, 0xC8
        out     dx, al
        mov     dx, [IDEContrRegsBaseAddr]
        cmp     [hdbase], 0x1F0
        jz      @f
        add     dx, 8
@@:
        mov     al, 9
        out     dx, al
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
        cmp     [hdbase], 0x1F0
        jnz     .ide1
        mov     [irq14_func], hdd_irq14
        jmp     @f
.ide1:
        mov     [irq15_func], hdd_irq15
@@:
        call    enable_ide_int
        cmp     [hdbase], 0x1F0
        jnz     .wait_ide1
        call    wait_for_sector_dma_ide0
        jmp     @f
.wait_ide1:
        call    wait_for_sector_dma_ide1
@@:
        cmp     [hd_error], 0
        jnz     hd_read_error
        pop     edx
        pop     eax
        mov     [dma_cur_sector], eax
        jmp     hd_read_dma
 
align 4
write_cache_chain:
        push    esi
        mov     eax, IDE_descriptor_table
        mov     edx, [cache_chain_pos]
        shl     edx, 9
        add     edx, OS_BASE+0x610000
        mov     [eax], edx
        movzx   edx, [cache_chain_size]
        shl     edx, 9
        mov     [eax+4], dx
        jmp     do_write_dma
write_cache_sector:
        push    esi
        mov     eax, IDE_descriptor_table
        mov     edx, edi
        shl     edx, 9
        add     edx, OS_BASE+0x610000
        mov     [eax], edx
        mov     word [eax+4], 0x200
do_write_dma:
        mov     dx, [IDEContrRegsBaseAddr]
        cmp     [hdbase], 0x1F0
        jz      @f
        add     edx, 8
@@:
        push    edx
        add     edx, 4
        out     dx, eax
        pop     edx
        mov     al, 0
        out     dx, al
        add     edx, 2
        mov     al, 6
        out     dx, al
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jnz     hd_write_error_dma
        call    disable_ide_int
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al
        inc     edx
        mov     al, [cache_chain_size]
        out     dx, al
        inc     edx
        mov     esi, [cache_chain_ptr]
        mov     eax, [esi]
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        and     al, 0xF
        add     al, byte [hdid]
        add     al, 11100000b
        out     dx, al
        inc     edx
        mov     al, 0xCA
        out     dx, al
        mov     dx, [IDEContrRegsBaseAddr]
        cmp     [hdbase], 0x1F0
        jz      @f
        add     dx, 8
@@:
        mov     al, 1
        out     dx, al
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
        cmp     [hdbase], 0x1F0
        jnz     .ide1
        mov     [irq14_func], hdd_irq14
        jmp     @f
.ide1:
        mov     [irq15_func], hdd_irq15
@@:
        call    enable_ide_int
        mov     [dma_cur_sector], not 0x40
        cmp     [hdbase], 0x1F0
        jnz     .wait_ide1
        call    wait_for_sector_dma_ide0
        jmp     @f
.wait_ide1:
        call    wait_for_sector_dma_ide1
@@:
        cmp     [hd_error], 0
        jnz     hd_write_error_dma
        pop     esi
        ret
 
uglobal
IDEContrRegsBaseAddr    dw      ?
endg
; \end{Mario79}

Rev 425	Rev 431
1	$Revision: 425 $	1	$Revision: 431 $
-		2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		3	;; ;;
-		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
-		5	;; Distributed under terms of the GNU General Public License ;;
-		6	;; ;;
-		7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		8
2	; Low-level driver for HDD access	9	; Low-level driver for HDD access
3	; DMA support by Mario79	10	; DMA support by Mario79
4		11
5	;**************************************************************************	12	;**************************************************************************
6	;	13	;
7	; 0x600008 - first entry in cache list	14	; 0x600008 - first entry in cache list
8	;	15	;
9	; +0 - lba sector	16	; +0 - lba sector
10	; +4 - state of cache sector	17	; +4 - state of cache sector
11	; 0 = empty	18	; 0 = empty
12	; 1 = used for read ( same as in hd )	19	; 1 = used for read ( same as in hd )
13	; 2 = used for write ( differs from hd )	20	; 2 = used for write ( differs from hd )
14	;	21	;
15	; +65536 - cache entries	22	; +65536 - cache entries
16	;	23	;
17	;**************************************************************************	24	;**************************************************************************
18		25
19	align 4	26	align 4
20	hd_read:	27	hd_read:
21	;-----------------------------------------------------------	28	;-----------------------------------------------------------
22	; input : eax = block to read	29	; input : eax = block to read
23	; ebx = destination	30	; ebx = destination
24	;-----------------------------------------------------------	31	;-----------------------------------------------------------
25	and [hd_error], 0	32	and [hd_error], 0
26	push ecx esi edi ; scan cache	33	push ecx esi edi ; scan cache
27		34
28	mov ecx,cache_max ; entries in cache	35	mov ecx,cache_max ; entries in cache
29	mov esi,OS_BASE+0x600000+8	36	mov esi,OS_BASE+0x600000+8
30	mov edi,1	37	mov edi,1
31		38
32	hdreadcache:	39	hdreadcache:
33		40
34	cmp dword [esi+4],0 ; empty	41	cmp dword [esi+4],0 ; empty
35	je nohdcache	42	je nohdcache
36		43
37	cmp [esi],eax ; correct sector	44	cmp [esi],eax ; correct sector
38	je yeshdcache	45	je yeshdcache
39		46
40	nohdcache:	47	nohdcache:
41		48
42	add esi,8	49	add esi,8
43	inc edi	50	inc edi
44	dec ecx	51	dec ecx
45	jnz hdreadcache	52	jnz hdreadcache
46		53
47	call find_empty_slot ; ret in edi	54	call find_empty_slot ; ret in edi
48	cmp [hd_error],0	55	cmp [hd_error],0
49	jne return_01	56	jne return_01
50	cmp [dma_hdd], 1	57	cmp [dma_hdd], 1
51	jnz .nodma	58	jnz .nodma
52	call hd_read_dma	59	call hd_read_dma
53	jmp @f	60	jmp @f
54	.nodma:	61	.nodma:
55	call hd_read_pio	62	call hd_read_pio
56	@@:	63	@@:
57		64
58	lea esi,[edi*8+OS_BASE+0x600000]	65	lea esi,[edi*8+OS_BASE+0x600000]
59	mov [esi],eax ; sector number	66	mov [esi],eax ; sector number
60	mov dword [esi+4],1 ; hd read - mark as same as in hd	67	mov dword [esi+4],1 ; hd read - mark as same as in hd
61		68
62	yeshdcache:	69	yeshdcache:
63		70
64	mov esi,edi	71	mov esi,edi
65	shl esi,9	72	shl esi,9
66	add esi,OS_BASE+0x600000+65536	73	add esi,OS_BASE+0x600000+65536
67	mov edi,ebx	74	mov edi,ebx
68	mov ecx,512/4	75	mov ecx,512/4
69	cld	76	cld
70	rep movsd ; move data	77	rep movsd ; move data
71	return_01:	78	return_01:
72	pop edi esi ecx	79	pop edi esi ecx
73	ret	80	ret
74		81
75	align 4	82	align 4
76	hd_read_pio:	83	hd_read_pio:
77	push eax edx	84	push eax edx
78		85
79	call wait_for_hd_idle	86	call wait_for_hd_idle
80	cmp [hd_error],0	87	cmp [hd_error],0
81	jne hd_read_error	88	jne hd_read_error
82		89
83	cli	90	cli
84	xor eax,eax	91	xor eax,eax
85	mov edx,[hdbase]	92	mov edx,[hdbase]
86	inc edx	93	inc edx
87	out dx,al ; ATAFeatures à¥£¨áâà "®á®¡¥®áâ¥©"	94	out dx,al ; ATAFeatures à¥£¨áâà "®á®¡¥®áâ¥©"
88	inc edx	95	inc edx
89	inc eax	96	inc eax
90	out dx,al ; ATASectorCount áçñâç¨ª á¥ªâ®à®¢	97	out dx,al ; ATASectorCount áçñâç¨ª á¥ªâ®à®¢
91	inc edx	98	inc edx
92	mov eax,[esp+4]	99	mov eax,[esp+4]
93	out dx,al ; ATASectorNumber à¥£¨áâà ®¬¥à á¥ªâ®à	100	out dx,al ; ATASectorNumber à¥£¨áâà ®¬¥à á¥ªâ®à
94	shr eax,8	101	shr eax,8
95	inc edx	102	inc edx
96	out dx,al ; ATACylinder ®¬¥à æ¨«¨¤à (¬« ¤è¨© ¡ ©â)	103	out dx,al ; ATACylinder ®¬¥à æ¨«¨¤à (¬« ¤è¨© ¡ ©â)
97	shr eax,8	104	shr eax,8
98	inc edx	105	inc edx
99	out dx,al ; ®¬¥à æ¨«¨¤à (áâ àè¨© ¡ ©â)	106	out dx,al ; ®¬¥à æ¨«¨¤à (áâ àè¨© ¡ ©â)
100	shr eax,8	107	shr eax,8
101	inc edx	108	inc edx
102	and al,1+2+4+8	109	and al,1+2+4+8
103	add al,byte [hdid]	110	add al,byte [hdid]
104	add al,128+64+32	111	add al,128+64+32
105	out dx,al ; ®¬¥à £®«®¢ª¨/®¬¥à ¤¨áª	112	out dx,al ; ®¬¥à £®«®¢ª¨/®¬¥à ¤¨áª
106	inc edx	113	inc edx
107	mov al,20h	114	mov al,20h
108	out dx,al ; ATACommand à¥£¨áâà ª®¬ ¤	115	out dx,al ; ATACommand à¥£¨áâà ª®¬ ¤
109	sti	116	sti
110		117
111	call wait_for_sector_buffer	118	call wait_for_sector_buffer
112		119
113	cmp [hd_error],0	120	cmp [hd_error],0
114	jne hd_read_error	121	jne hd_read_error
115		122
116	cli	123	cli
117	push edi	124	push edi
118	shl edi,9	125	shl edi,9
119	add edi,OS_BASE+0x600000+65536	126	add edi,OS_BASE+0x600000+65536
120	mov ecx,256	127	mov ecx,256
121	mov edx,[hdbase]	128	mov edx,[hdbase]
122	cld	129	cld
123	rep insw	130	rep insw
124	pop edi	131	pop edi
125	sti	132	sti
126		133
127	pop edx eax	134	pop edx eax
128	ret	135	ret
129		136
130	disable_ide_int:	137	disable_ide_int:
131	; mov edx,[hdbase]	138	; mov edx,[hdbase]
132	; add edx,0x206	139	; add edx,0x206
133	; mov al,2	140	; mov al,2
134	; out dx,al	141	; out dx,al
135	cli	142	cli
136	ret	143	ret
137		144
138	enable_ide_int:	145	enable_ide_int:
139	; mov edx,[hdbase]	146	; mov edx,[hdbase]
140	; add edx,0x206	147	; add edx,0x206
141	; mov al,0	148	; mov al,0
142	; out dx,al	149	; out dx,al
143	sti	150	sti
144	ret	151	ret
145		152
146	align 4	153	align 4
147	hd_write:	154	hd_write:
148	;-----------------------------------------------------------	155	;-----------------------------------------------------------
149	; input : eax = block	156	; input : eax = block
150	; ebx = pointer to memory	157	; ebx = pointer to memory
151	;-----------------------------------------------------------	158	;-----------------------------------------------------------
152	push ecx esi edi	159	push ecx esi edi
153		160
154	; check if the cache already has the sector and overwrite it	161	; check if the cache already has the sector and overwrite it
155		162
156	mov ecx,cache_max	163	mov ecx,cache_max
157	mov esi,OS_BASE+0x600000+8	164	mov esi,OS_BASE+0x600000+8
158	mov edi,1	165	mov edi,1
159		166
160	hdwritecache:	167	hdwritecache:
161		168
162	cmp dword [esi+4],0 ; if cache slot is empty	169	cmp dword [esi+4],0 ; if cache slot is empty
163	je not_in_cache_write	170	je not_in_cache_write
164		171
165	cmp [esi],eax ; if the slot has the sector	172	cmp [esi],eax ; if the slot has the sector
166	je yes_in_cache_write	173	je yes_in_cache_write
167		174
168	not_in_cache_write:	175	not_in_cache_write:
169		176
170	add esi,8	177	add esi,8
171	inc edi	178	inc edi
172	dec ecx	179	dec ecx
173	jnz hdwritecache	180	jnz hdwritecache
174		181
175	; sector not found in cache	182	; sector not found in cache
176	; write the block to a new location	183	; write the block to a new location
177		184
178	call find_empty_slot ; ret in edi	185	call find_empty_slot ; ret in edi
179	cmp [hd_error],0	186	cmp [hd_error],0
180	jne hd_write_access_denied	187	jne hd_write_access_denied
181		188
182	lea esi,[edi*8+OS_BASE+0x600000]	189	lea esi,[edi*8+OS_BASE+0x600000]
183	mov [esi],eax ; sector number	190	mov [esi],eax ; sector number
184		191
185	yes_in_cache_write:	192	yes_in_cache_write:
186		193
187	mov dword [esi+4],2 ; write - differs from hd	194	mov dword [esi+4],2 ; write - differs from hd
188		195
189	shl edi,9	196	shl edi,9
190	add edi,OS_BASE+0x600000+65536	197	add edi,OS_BASE+0x600000+65536
191	mov esi,ebx	198	mov esi,ebx
192	mov ecx,512/4	199	mov ecx,512/4
193	cld	200	cld
194	rep movsd ; move data	201	rep movsd ; move data
195	hd_write_access_denied:	202	hd_write_access_denied:
196	pop edi esi ecx	203	pop edi esi ecx
197	ret	204	ret
198		205
199		206
200	write_cache:	207	write_cache:
201	;-----------------------------------------------------------	208	;-----------------------------------------------------------
202	; write all changed sectors to disk	209	; write all changed sectors to disk
203	;-----------------------------------------------------------	210	;-----------------------------------------------------------
204	push eax ecx edx esi edi	211	push eax ecx edx esi edi
205		212
206	; write difference ( 2 ) from cache to hd	213	; write difference ( 2 ) from cache to hd
207		214
208	mov ecx,cache_max	215	mov ecx,cache_max
209	mov esi,OS_BASE+0x600000+8	216	mov esi,OS_BASE+0x600000+8
210	mov edi,1	217	mov edi,1
211		218
212	write_cache_more:	219	write_cache_more:
213		220
214	cmp dword [esi+4],2 ; if cache slot is not different	221	cmp dword [esi+4],2 ; if cache slot is not different
215	jne .write_chain	222	jne .write_chain
216		223
217	mov dword [esi+4],1 ; same as in hd	224	mov dword [esi+4],1 ; same as in hd
218	mov eax,[esi] ; eax = sector to write	225	mov eax,[esi] ; eax = sector to write
219		226
220	cmp eax,[PARTITION_START]	227	cmp eax,[PARTITION_START]
221	jb danger	228	jb danger
222	cmp eax,[PARTITION_END]	229	cmp eax,[PARTITION_END]
223	ja danger	230	ja danger
224		231
225	cmp [allow_dma_write], 1	232	cmp [allow_dma_write], 1
226	jnz .nodma	233	jnz .nodma
227	cmp [dma_hdd], 1	234	cmp [dma_hdd], 1
228	jnz .nodma	235	jnz .nodma
229	; ¡ê¥¤¨ï¥¬ § ¯¨áì æ¥¯®çª¨ ¯®á«¥¤®¢ â¥«ìëå á¥ªâ®à®¢ ¢ ®¤® ®¡à é¥¨¥ ª ¤¨áªã	236	; ¡ê¥¤¨ï¥¬ § ¯¨áì æ¥¯®çª¨ ¯®á«¥¤®¢ â¥«ìëå á¥ªâ®à®¢ ¢ ®¤® ®¡à é¥¨¥ ª ¤¨áªã
230	cmp ecx, 1	237	cmp ecx, 1
231	jz .nonext	238	jz .nonext
232	cmp dword [esi+8+4], 2	239	cmp dword [esi+8+4], 2
233	jnz .nonext	240	jnz .nonext
234	push eax	241	push eax
235	inc eax	242	inc eax
236	cmp eax, [esi+8]	243	cmp eax, [esi+8]
237	pop eax	244	pop eax
238	jnz .nonext	245	jnz .nonext
239	cmp [cache_chain_started], 1	246	cmp [cache_chain_started], 1
240	jz @f	247	jz @f
241	mov [cache_chain_started], 1	248	mov [cache_chain_started], 1
242	mov [cache_chain_size], 0	249	mov [cache_chain_size], 0
243	mov [cache_chain_pos], edi	250	mov [cache_chain_pos], edi
244	mov [cache_chain_ptr], esi	251	mov [cache_chain_ptr], esi
245	@@:	252	@@:
246	inc [cache_chain_size]	253	inc [cache_chain_size]
247	cmp [cache_chain_size], 64	254	cmp [cache_chain_size], 64
248	jnz .continue	255	jnz .continue
249	jmp .write_chain	256	jmp .write_chain
250	.nonext:	257	.nonext:
251	call flush_cache_chain	258	call flush_cache_chain
252	mov [cache_chain_size], 1	259	mov [cache_chain_size], 1
253	mov [cache_chain_ptr], esi	260	mov [cache_chain_ptr], esi
254	call write_cache_sector	261	call write_cache_sector
255	jmp .continue	262	jmp .continue
256	.nodma:	263	.nodma:
257	call cache_write_pio	264	call cache_write_pio
258	.write_chain:	265	.write_chain:
259	call flush_cache_chain	266	call flush_cache_chain
260		267
261	.continue:	268	.continue:
262	danger:	269	danger:
263		270
264	add esi,8	271	add esi,8
265	inc edi	272	inc edi
266	dec ecx	273	dec ecx
267	jnz write_cache_more	274	jnz write_cache_more
268	call flush_cache_chain	275	call flush_cache_chain
269	return_02:	276	return_02:
270	pop edi esi edx ecx eax	277	pop edi esi edx ecx eax
271	ret	278	ret
272		279
273	flush_cache_chain:	280	flush_cache_chain:
274	cmp [cache_chain_started], 0	281	cmp [cache_chain_started], 0
275	jz @f	282	jz @f
276	call write_cache_chain	283	call write_cache_chain
277	mov [cache_chain_started], 0	284	mov [cache_chain_started], 0
278	@@:	285	@@:
279	ret	286	ret
280		287
281	align 4	288	align 4
282	cache_write_pio:	289	cache_write_pio:
283	call disable_ide_int	290	call disable_ide_int
284		291
285	call wait_for_hd_idle	292	call wait_for_hd_idle
286	cmp [hd_error],0	293	cmp [hd_error],0
287	jne hd_write_error	294	jne hd_write_error
288		295
289	; cli	296	; cli
290	xor eax,eax	297	xor eax,eax
291	mov edx,[hdbase]	298	mov edx,[hdbase]
292	inc edx	299	inc edx
293	out dx,al	300	out dx,al
294	inc edx	301	inc edx
295	inc eax	302	inc eax
296	out dx,al	303	out dx,al
297	inc edx	304	inc edx
298	mov eax,[esi] ; eax = sector to write	305	mov eax,[esi] ; eax = sector to write
299	out dx,al	306	out dx,al
300	shr eax,8	307	shr eax,8
301	inc edx	308	inc edx
302	out dx,al	309	out dx,al
303	shr eax,8	310	shr eax,8
304	inc edx	311	inc edx
305	out dx,al	312	out dx,al
306	shr eax,8	313	shr eax,8
307	inc edx	314	inc edx
308	and al,1+2+4+8	315	and al,1+2+4+8
309	add al,byte [hdid]	316	add al,byte [hdid]
310	add al,128+64+32	317	add al,128+64+32
311	out dx,al	318	out dx,al
312	inc edx	319	inc edx
313	mov al,30h	320	mov al,30h
314	out dx,al	321	out dx,al
315	; sti	322	; sti
316		323
317	call wait_for_sector_buffer	324	call wait_for_sector_buffer
318		325
319	cmp [hd_error],0	326	cmp [hd_error],0
320	jne hd_write_error	327	jne hd_write_error
321		328
322	push ecx esi	329	push ecx esi
323		330
324	; cli	331	; cli
325	mov esi,edi	332	mov esi,edi
326	shl esi,9	333	shl esi,9
327	add esi,OS_BASE+0x600000+65536 ; esi = from memory position	334	add esi,OS_BASE+0x600000+65536 ; esi = from memory position
328	mov ecx,256	335	mov ecx,256
329	mov edx,[hdbase]	336	mov edx,[hdbase]
330	cld	337	cld
331	rep outsw	338	rep outsw
332	; sti	339	; sti
333		340
334	call enable_ide_int	341	call enable_ide_int
335	pop esi ecx	342	pop esi ecx
336		343
337	ret	344	ret
338		345
339	align 4	346	align 4
340	find_empty_slot:	347	find_empty_slot:
341	;-----------------------------------------------------------	348	;-----------------------------------------------------------
342	; find empty or read slot, flush cache if next 10% is used by write	349	; find empty or read slot, flush cache if next 10% is used by write
343	; output : edi = cache slot	350	; output : edi = cache slot
344	;-----------------------------------------------------------	351	;-----------------------------------------------------------
345	; push ecx esi	352	; push ecx esi
346		353
347	search_again:	354	search_again:
348		355
349	mov ecx,cache_max*10/100	356	mov ecx,cache_max*10/100
350	mov edi,[cache_search_start]	357	mov edi,[cache_search_start]
351		358
352	search_for_empty:	359	search_for_empty:
353		360
354	inc edi	361	inc edi
355	cmp edi,cache_max	362	cmp edi,cache_max
356	jbe inside_cache	363	jbe inside_cache
357	mov edi,1	364	mov edi,1
358		365
359	inside_cache:	366	inside_cache:
360		367
361	cmp dword [edi*8+OS_BASE+0x600000+4],2 ; get cache slot info	368	cmp dword [edi*8+OS_BASE+0x600000+4],2 ; get cache slot info
362	jb found_slot ; it's empty or read	369	jb found_slot ; it's empty or read
363	dec ecx	370	dec ecx
364	jnz search_for_empty	371	jnz search_for_empty
365		372
366	call write_cache ; no empty slots found, write all	373	call write_cache ; no empty slots found, write all
367	cmp [hd_error],0	374	cmp [hd_error],0
368	jne found_slot_access_denied	375	jne found_slot_access_denied
369		376
370	jmp search_again ; and start again	377	jmp search_again ; and start again
371		378
372	found_slot:	379	found_slot:
373		380
374	mov [cache_search_start],edi	381	mov [cache_search_start],edi
375	found_slot_access_denied:	382	found_slot_access_denied:
376	ret	383	ret
377		384
378	align 4	385	align 4
379	clear_hd_cache:	386	clear_hd_cache:
380		387
381	push eax ecx edi	388	push eax ecx edi
382	mov edi,OS_BASE+0x600000	389	mov edi,OS_BASE+0x600000
383	mov ecx,16384	390	mov ecx,16384
384	xor eax,eax	391	xor eax,eax
385	cld	392	cld
386	rep stosd ; clear hd cache with 0	393	rep stosd ; clear hd cache with 0
387	mov [cache_search_start],eax	394	mov [cache_search_start],eax
388	mov [fat_in_cache],-1	395	mov [fat_in_cache],-1
389	mov [fat_change],0	396	mov [fat_change],0
390	pop edi ecx eax	397	pop edi ecx eax
391	ret	398	ret
392		399
393	save_hd_wait_timeout:	400	save_hd_wait_timeout:
394		401
395	push eax	402	push eax
396	mov eax,[timer_ticks];[0xfdf0]	403	mov eax,[timer_ticks];[0xfdf0]
397	add eax,300 ; 3 sec timeout	404	add eax,300 ; 3 sec timeout
398	mov [hd_wait_timeout],eax	405	mov [hd_wait_timeout],eax
399	pop eax	406	pop eax
400	ret	407	ret
401		408
402	align 4	409	align 4
403	check_hd_wait_timeout:	410	check_hd_wait_timeout:
404		411
405	push eax	412	push eax
406	mov eax,[hd_wait_timeout]	413	mov eax,[hd_wait_timeout]
407	cmp [timer_ticks], eax ;[0xfdf0],eax	414	cmp [timer_ticks], eax ;[0xfdf0],eax
408	jg hd_timeout_error	415	jg hd_timeout_error
409	pop eax	416	pop eax
410	mov [hd_error],0	417	mov [hd_error],0
411	ret	418	ret
412		419
413	;iglobal	420	;iglobal
414	; hd_timeout_str db 'K : FS - HD timeout',0	421	; hd_timeout_str db 'K : FS - HD timeout',0
415	; hd_read_str db 'K : FS - HD read error',0	422	; hd_read_str db 'K : FS - HD read error',0
416	; hd_write_str db 'K : FS - HD write error',0	423	; hd_write_str db 'K : FS - HD write error',0
417	; hd_lba_str db 'K : FS - HD LBA error',0	424	; hd_lba_str db 'K : FS - HD LBA error',0
418	;endg	425	;endg
419		426
420	hd_timeout_error:	427	hd_timeout_error:
421		428
422	; call clear_hd_cache	429	; call clear_hd_cache
423	; call clear_application_table_status	430	; call clear_application_table_status
424	; mov esi,hd_timeout_str	431	; mov esi,hd_timeout_str
425	; call sys_msg_board_str	432	; call sys_msg_board_str
426	DEBUGF 1,"K : FS - HD timeout\n"	433	DEBUGF 1,"K : FS - HD timeout\n"
427	; jmp $	434	; jmp $
428	mov [hd_error],1	435	mov [hd_error],1
429	pop eax	436	pop eax
430	ret	437	ret
431		438
432	hd_read_error:	439	hd_read_error:
433		440
434	; call clear_hd_cache	441	; call clear_hd_cache
435	; call clear_application_table_status	442	; call clear_application_table_status
436	; mov esi,hd_read_str	443	; mov esi,hd_read_str
437	; call sys_msg_board_str	444	; call sys_msg_board_str
438	DEBUGF 1,"K : FS - HD read error\n"	445	DEBUGF 1,"K : FS - HD read error\n"
439	pop edx eax	446	pop edx eax
440	ret	447	ret
441		448
442	hd_write_error:	449	hd_write_error:
443		450
444	; call clear_hd_cache	451	; call clear_hd_cache
445	; call clear_application_table_status	452	; call clear_application_table_status
446	; mov esi,hd_write_str	453	; mov esi,hd_write_str
447	; call sys_msg_board_str	454	; call sys_msg_board_str
448	DEBUGF 1,"K : FS - HD write error\n"	455	DEBUGF 1,"K : FS - HD write error\n"
449	ret	456	ret
450		457
451	hd_write_error_dma:	458	hd_write_error_dma:
452	; call clear_hd_cache	459	; call clear_hd_cache
453	; call clear_application_table_status	460	; call clear_application_table_status
454	; mov esi, hd_write_str	461	; mov esi, hd_write_str
455	; call sys_msg_board_str	462	; call sys_msg_board_str
456	DEBUGF 1,"K : FS - HD read error\n"	463	DEBUGF 1,"K : FS - HD read error\n"
457	pop esi	464	pop esi
458	ret	465	ret
459		466
460	hd_lba_error:	467	hd_lba_error:
461	; call clear_hd_cache	468	; call clear_hd_cache
462	; call clear_application_table_status	469	; call clear_application_table_status
463	; mov esi,hd_lba_str	470	; mov esi,hd_lba_str
464	; call sys_msg_board_str	471	; call sys_msg_board_str
465	DEBUGF 1,"K : FS - HD LBA error\n"	472	DEBUGF 1,"K : FS - HD LBA error\n"
466	jmp LBA_read_ret	473	jmp LBA_read_ret
467		474
468		475
469	align 4	476	align 4
470	wait_for_hd_idle:	477	wait_for_hd_idle:
471		478
472	push eax edx	479	push eax edx
473		480
474	call save_hd_wait_timeout	481	call save_hd_wait_timeout
475		482
476	mov edx,[hdbase]	483	mov edx,[hdbase]
477	add edx,0x7	484	add edx,0x7
478		485
479	wfhil1:	486	wfhil1:
480		487
481	call check_hd_wait_timeout	488	call check_hd_wait_timeout
482	cmp [hd_error],0	489	cmp [hd_error],0
483	jne @f	490	jne @f
484		491
485	in al,dx	492	in al,dx
486	test al,128	493	test al,128
487	jnz wfhil1	494	jnz wfhil1
488		495
489	@@:	496	@@:
490		497
491	pop edx eax	498	pop edx eax
492	ret	499	ret
493		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/hd_drv.inc – Rev 425 → 431