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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 770 $
 
 
; Low-level driver for HDD access
; DMA support by Mario79
; Access through BIOS by diamond
 
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,HD_CACHE+8
    call  calculate_cache
    add   esi,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
; Read through BIOS?
        cmp     [hdpos], 0x80
        jae     .bios
; DMA read is permitted if [allow_dma_access]=1 or 2
        cmp     [allow_dma_access], 2
        ja      .nodma
        cmp     [dma_hdd], 1
        jnz     .nodma
        call    hd_read_dma
        jmp     @f
.nodma:
        call    hd_read_pio
        jmp     @f
.bios:
        call    bd_read
@@:
        cmp     [hd_error], 0
        jne     return_01
;    lea   esi,[edi*8+HD_CACHE]
;    push  eax
    call  calculate_cache_1
    lea   esi,[edi*8+esi]
;    pop   eax
 
    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,HD_CACHE+65536
    push  eax
    call  calculate_cache_2
    add   esi,eax
    pop   eax
 
    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,HD_CACHE+65536
    push  eax
    call  calculate_cache_2
    add   edi,eax
    pop   eax
 
    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,HD_CACHE+8
    call  calculate_cache
    add   esi,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+HD_CACHE]
;    push  eax
    call  calculate_cache_1
    lea   esi,[edi*8+esi]
;    pop   eax
 
    mov   [esi],eax             ; sector number
 
  yes_in_cache_write:
 
    mov   dword [esi+4],2       ; write - differs from hd
 
    shl   edi,9
;    add   edi,HD_CACHE+65536
    push  eax
    call  calculate_cache_2
    add   edi,eax
    pop   eax
 
    mov   esi,ebx
    mov   ecx,512/4
    cld
    rep   movsd                 ; move data
 hd_write_access_denied:
    pop   edi esi ecx
    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,HD_CACHE+65536    ; esi = from memory position
    push  eax
    call  calculate_cache_2
    add   esi,eax
    pop   eax
 
    mov   ecx,256
    mov   edx,[hdbase]
    cld
    rep   outsw
    sti
 
;    call  enable_ide_int
    pop   esi ecx
 
    ret
 
save_hd_wait_timeout:
 
    push  eax
    mov   eax,[timer_ticks]
    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
    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"
 
    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      IDE_DMA
        dw      0x2000
        dw      0x8000
 
dma_cur_sector  dd      not 40h
dma_hdpos       dd      0
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_access 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 [DONT_SWITCH], 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 [DONT_SWITCH], 1
;        call    do_change_task
.noswitch:
        popad
        popfd
        ret
 
align 4
hd_read_dma:
        push    eax
        push    edx
        mov     edx,[dma_hdpos]
        cmp     edx,[hdpos]
        jne     .notread
        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+IDE_DMA)
        push    ecx esi edi
        mov     esi, eax
        shl     edi, 9
;        add     edi, HD_CACHE+0x10000
        push  eax
        call  calculate_cache_2
        add   edi,eax
        pop   eax
 
        mov     ecx, 512/4
        cld
        rep     movsd
        pop     edi esi ecx
        pop     edx
        pop     eax
        ret
.notread:
        mov     eax, IDE_descriptor_table
        mov     dword [eax],  IDE_DMA
        mov     word [eax+4], 0x2000
        sub     eax, OS_BASE
        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
        mov     eax,[hdpos]
        mov     [dma_hdpos],eax
        pop     edx
        pop     eax
        mov     [dma_cur_sector], eax
        jmp     hd_read_dma
 
align 4
write_cache_sector:
        mov     [cache_chain_size],1
        mov     [cache_chain_pos],edi
write_cache_chain:
        cmp     [hdpos], 0x80
        jae     bd_write_cache_chain
        push    esi
        mov     eax, IDE_descriptor_table
        mov     edx,eax
        pusha
        mov     esi,[cache_chain_pos]
        shl     esi, 9
        call    calculate_cache_2
        add     esi,eax
        mov     edi, (OS_BASE+IDE_DMA)
        mov     dword [edx], IDE_DMA
        movzx   ecx, [cache_chain_size]
        shl     ecx, 9
        mov     word [edx+4], cx
        shr     ecx,2
        cld
        rep movsd
        popa
        sub     eax, OS_BASE
        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}
 
; \begin{diamond}
uglobal
bios_hdpos      dd      0       ; 0 is invalid value for [hdpos]
bios_cur_sector dd      ?
bios_read_len   dd      ?
endg
bd_read:
        push    eax
        push    edx
        mov     edx, [bios_hdpos]
        cmp     edx, [hdpos]
        jne     .notread
        mov     edx, [bios_cur_sector]
        cmp     eax, edx
        jb      .notread
        add     edx, [bios_read_len]
        dec     edx
        cmp     eax, edx
        ja      .notread
        sub     eax, [bios_cur_sector]
        shl     eax, 9
        add     eax, (OS_BASE+0x9C000)
        push    ecx esi edi
        mov     esi, eax
        shl     edi, 9
;        add     edi, HD_CACHE+0x10000
        push  eax
        call  calculate_cache_2
        add   edi,eax
        pop   eax
 
        mov     ecx, 512/4
        cld
        rep     movsd
        pop     edi esi ecx
        pop     edx
        pop     eax
        ret
.notread:
        push    ecx
        mov     dl, 42h
        mov     ecx, 16
        call    int13_call
        pop     ecx
        test    eax, eax
        jnz     .v86err
        test    edx, edx
        jz      .readerr
        mov     [bios_read_len], edx
        mov     edx, [hdpos]
        mov     [bios_hdpos], edx
        pop     edx
        pop     eax
        mov     [bios_cur_sector], eax
        jmp     bd_read
.readerr:
.v86err:
        mov     [hd_error], 1
        jmp     hd_read_error
 
bd_write_cache_chain:
        pusha
        mov     esi, [cache_chain_pos]
        shl     esi, 9
        call    calculate_cache_2
        add     esi, eax
        mov     edi, OS_BASE + 0x9C000
        movzx   ecx, [cache_chain_size]
        push    ecx
        shl     ecx, 9-2
        rep     movsd
        pop     ecx
        mov     dl, 43h
        mov     eax, [cache_chain_ptr]
        mov     eax, [eax]
        call    int13_call
        test    eax, eax
        jnz     .v86err
        cmp     edx, ecx
        jnz     .writeerr
        popa
        ret
.v86err:
.writeerr:
        popa
        mov     [hd_error], 1
        jmp     hd_write_error
 
uglobal
int13_regs_in   rb      v86_regs.size
int13_regs_out  rb      v86_regs.size
endg
 
int13_call:
; Because this code uses fixed addresses,
; it can not be run simultaniously by many threads.
; In current implementation it is protected by common mutex 'hd1_status'
        mov     word [BOOT_VAR + 510h], 10h             ; packet length
        mov     word [BOOT_VAR + 512h], cx              ; number of sectors
        mov     dword [BOOT_VAR + 514h], 9C000000h      ; buffer 9C00:0000
        mov     dword [BOOT_VAR + 518h], eax
        and     dword [BOOT_VAR + 51Ch], 0
        push    ebx ecx esi edi
        mov     ebx, int13_regs_in
        mov     edi, ebx
        mov     ecx, v86_regs.size/4
        xor     eax, eax
        rep     stosd
        mov     byte [ebx+v86_regs.eax+1], dl
        mov     eax, [hdpos]
        lea     eax, [BiosDisksData+(eax-80h)*4]
        mov     dl, [eax]
        mov     byte [ebx+v86_regs.edx], dl
        movzx   edx, byte [eax+1]
;        mov     dl, 5
        test    edx, edx
        jnz     .hasirq
        dec     edx
        jmp     @f
.hasirq:
        pushad
        stdcall enable_irq, edx
        popad
@@:
        mov     word [ebx+v86_regs.esi], 510h
        mov     word [ebx+v86_regs.ss], 9000h
        mov     word [ebx+v86_regs.esp], 0C000h
        mov     word [ebx+v86_regs.eip], 500h
        mov     [ebx+v86_regs.eflags], 20200h
        mov     esi, [sys_v86_machine]
        mov     ecx, 0x502
        call    v86_start
        and     [bios_hdpos], 0
        pop     edi esi ecx ebx
        movzx   edx, byte [BOOT_VAR + 512h]
        test    byte [int13_regs_out+v86_regs.eflags], 1
        jnz     @f
        mov     edx, ecx
@@:
        ret
; \end{diamond}

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/hd_drv.inc – Rev 725 → 770