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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2643 $
 
 
; 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
; hd_read_{dma,pio} use old ATA with 28 bit for sector number
        cmp     eax, 0x10000000
        jb      @f
        inc     [hd_error]
        jmp     return_01
@@:
; 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:
        cmp     dword[esi], 0x10000000
        jae     .bad
;    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
.bad:
        inc     [hd_error]
        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
        mov     eax, [cache_chain_ptr]
        cmp     dword[eax], 0x10000000
        jae     .bad
        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
.bad:
        inc     [hd_error]
        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+0x9A000)
        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 + 0x9A000
        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      sizeof.v86_regs
int13_regs_out  rb      sizeof.v86_regs
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 [OS_BASE + 510h], 10h             ; packet length
        mov     word [OS_BASE + 512h], cx              ; number of sectors
        mov     dword [OS_BASE + 514h], 9A000000h      ; buffer 9A00:0000
        mov     dword [OS_BASE + 518h], eax
        and     dword [OS_BASE + 51Ch], 0
        push    ebx ecx esi edi
        mov     ebx, int13_regs_in
        mov     edi, ebx
        mov     ecx, sizeof.v86_regs/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], 0A000h
        mov     word [ebx+v86_regs.eip], 500h
        mov     [ebx+v86_regs.eflags], 20200h
        mov     esi, [sys_v86_machine]
        mov     ecx, 0x502
        push    fs
        call    v86_start
        pop     fs
        and     [bios_hdpos], 0
        pop     edi esi ecx ebx
        movzx   edx, byte [OS_BASE + 512h]
        test    byte [int13_regs_out+v86_regs.eflags], 1
        jnz     @f
        mov     edx, ecx
@@:
        ret
; \end{diamond}
 
reserve_hd1:
 
        cli
        cmp     [hd1_status], 0
        je      reserve_ok1
 
        sti
        call    change_task
        jmp     reserve_hd1
 
  reserve_ok1:
 
        push    eax
        mov     eax, [CURRENT_TASK]
        shl     eax, 5
        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
        mov     [hd1_status], eax
        pop     eax
        sti
        ret
;********************************************
 
uglobal
hd_in_cache db ?
endg
 
reserve_hd_channel:
; BIOS disk accesses are protected with common mutex hd1_status
; This must be modified when hd1_status will not be valid!
        cmp     [hdpos], 0x80
        jae     .ret
        cmp     [hdbase], 0x1F0
        jne     .IDE_Channel_2
.IDE_Channel_1:
        cli
        cmp     [IDE_Channel_1], 0
        je      .reserve_ok_1
        sti
        call    change_task
        jmp     .IDE_Channel_1
.IDE_Channel_2:
        cli
        cmp     [IDE_Channel_2], 0
        je      .reserve_ok_2
        sti
        call    change_task
        jmp     .IDE_Channel_2
.reserve_ok_1:
        mov     [IDE_Channel_1], 1
        push    eax
        mov     al, 1
        jmp     @f
.reserve_ok_2:
        mov     [IDE_Channel_2], 1
        push    eax
        mov     al, 3
@@:
        cmp     [hdid], 1
        sbb     al, -1
        mov     [hd_in_cache], al
        pop     eax
        sti
.ret:
        ret
 
free_hd_channel:
; see comment at reserve_hd_channel
        cmp     [hdpos], 0x80
        jae     .ret
        cmp     [hdbase], 0x1F0
        jne     .IDE_Channel_2
.IDE_Channel_1:
        mov     [IDE_Channel_1], 0
.ret:
        ret
.IDE_Channel_2:
        mov     [IDE_Channel_2], 0
        ret
;********************************************

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/hd_drv.inc – Rev 2455 → 2643