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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 4624 $
 
 
; Low-level driver for HDD access
; DMA support by Mario79
; LBA48 support by Mario79
;-----------------------------------------------------------------------------
struct HD_DATA
hdbase  dd      ?
hdid    dd      ?
hdpos   dd      ?
ends
 
iglobal
align 4
ide_callbacks:
        dd      ide_callbacks.end - ide_callbacks       ; strucsize
        dd      0       ; no close function
        dd      0       ; no closemedia function
        dd      ide_querymedia
        dd      ide_read
        dd      ide_write
        dd      0       ; no flush function
        dd      0       ; use default cache size
.end:
 
hd0_data        HD_DATA         ?,    0, 1
hd1_data        HD_DATA         ?, 0x10, 2
hd2_data        HD_DATA         ?,    0, 3
hd3_data        HD_DATA         ?, 0x10, 4
 
hd_address_table:
        dd      0x1f0, 0x00, 0x1f0, 0x10
        dd      0x170, 0x00, 0x170, 0x10
endg
 
uglobal
ide_mutex               MUTEX
ide_channel1_mutex      MUTEX
ide_channel2_mutex      MUTEX
endg
 
proc ide_read stdcall uses edi, \
        hd_data, buffer, startsector:qword, numsectors
        ; hd_data = pointer to hd*_data
        ; buffer = pointer to buffer for data
        ; startsector = 64-bit start sector
        ; numsectors = pointer to number of sectors on input,
        ;  must be filled with number of sectors really read
locals
sectors_todo    dd      ?
channel_lock    dd      ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.
        mov     ecx, [numsectors]
        mov     eax, [ecx]
        mov     dword [ecx], 0
        mov     [sectors_todo], eax
; 2. Acquire the global lock.
        mov     ecx, ide_mutex
        call    mutex_lock
        mov     ecx, ide_channel2_mutex
        mov     eax, [hd_data]
        push    ecx
        mov     ecx, [hd_address_table]
        cmp     [eax+HD_DATA.hdbase], ecx ; 0x1F0
        pop     ecx
        jne     .IDE_Channel_2
        mov     ecx, ide_channel1_mutex
.IDE_Channel_2:
        mov     [channel_lock], ecx
        call    mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and edi for [buffer].
        cmp     dword [startsector+4], 0
        jnz     .fail
        and     [hd_error], 0
        mov     ecx, [hd_data]
        mov     eax, [ecx+HD_DATA.hdbase]
        mov     [hdbase], eax
        mov     eax, [ecx+HD_DATA.hdid]
        mov     [hdid], eax
        mov     eax, [ecx+HD_DATA.hdpos]
        mov     [hdpos], eax
        mov     eax, dword [startsector]
        mov     edi, [buffer]
; 4. Worker procedures take one sectors per time, so loop over all sectors to read.
.sectors_loop:
; DMA read is permitted if [allow_dma_access]=1 or 2
        cmp     [allow_dma_access], 2
        ja      .nodma
        cmp     [dma_hdd], 1
        jnz     .nodma
;--------------------------------------
        push    eax
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        pop     eax
        jnz     @f
 
        test    [DRIVE_DATA+1], byte 10100000b
        jnz     .nodma
 
        jmp     .dma
@@:
        test    [DRIVE_DATA+1], byte 1010b
        jnz     .nodma
.dma:
;--------------------------------------
        call    hd_read_dma
        jmp     @f
.nodma:
        call    hd_read_pio
@@:
        cmp     [hd_error], 0
        jnz     .fail
        mov     ecx, [numsectors]
        inc     dword [ecx]     ; one more sector is read
        dec     [sectors_todo]
        jz      .done
        inc     eax
        jnz     .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
; Release the global lock and return the corresponding status.
.fail:
        mov     ecx, [channel_lock]
        call    mutex_unlock
        mov     ecx, ide_mutex
        call    mutex_unlock
        or      eax, -1
        ret
.done:
        mov     ecx, [channel_lock]
        call    mutex_unlock
        mov     ecx, ide_mutex
        call    mutex_unlock
        xor     eax, eax
        ret
endp
 
proc ide_write stdcall uses esi edi, \
        hd_data, buffer, startsector:qword, numsectors
        ; hd_data = pointer to hd*_data
        ; buffer = pointer to buffer with data
        ; startsector = 64-bit start sector
        ; numsectors = pointer to number of sectors on input,
        ;  must be filled with number of sectors really written
locals
sectors_todo    dd      ?
channel_lock    dd      ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.      
        mov     ecx, [numsectors]
        mov     eax, [ecx]
        mov     dword [ecx], 0
        mov     [sectors_todo], eax
; 2. Acquire the global lock.
        mov     ecx, ide_mutex
        call    mutex_lock
        mov     ecx, ide_channel2_mutex
        mov     eax, [hd_data]
        push    ecx
        mov     ecx, [hd_address_table]
        cmp     [eax+HD_DATA.hdbase], ecx ; 0x1F0
        pop     ecx
        jne     .IDE_Channel_2
        mov     ecx, ide_channel1_mutex
.IDE_Channel_2:
        mov     [channel_lock], ecx
        call    mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and esi for [buffer].
        cmp     dword [startsector+4], 0
        jnz     .fail
        and     [hd_error], 0
        mov     ecx, [hd_data]
        mov     eax, [ecx+HD_DATA.hdbase]
        mov     [hdbase], eax
        mov     eax, [ecx+HD_DATA.hdid]
        mov     [hdid], eax
        mov     eax, [ecx+HD_DATA.hdpos]
        mov     [hdpos], eax
        mov     esi, [buffer]
        lea     edi, [startsector]
        mov     [cache_chain_ptr], edi
; 4. Worker procedures take max 16 sectors per time,
; loop until all sectors will be processed.
.sectors_loop:
        mov     ecx, 16
        cmp     ecx, [sectors_todo]
        jbe     @f
        mov     ecx, [sectors_todo]
@@:
        mov     [cache_chain_size], cl
; DMA write is permitted only if [allow_dma_access]=1
        cmp     [allow_dma_access], 2
        jae     .nodma
        cmp     [dma_hdd], 1
        jnz     .nodma
;--------------------------------------
        push    eax
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        pop     eax
        jnz     @f
 
        test    [DRIVE_DATA+1], byte 10100000b
        jnz     .nodma
 
        jmp     .dma
@@:
        test    [DRIVE_DATA+1], byte 1010b
        jnz     .nodma
.dma:
;--------------------------------------
        call    cache_write_dma
        jmp     .common
.nodma:
        mov     [cache_chain_size], 1
        call    cache_write_pio
.common:
        cmp     [hd_error], 0
        jnz     .fail
        movzx   ecx, [cache_chain_size]
        mov     eax, [numsectors]
        add     [eax], ecx
        sub     [sectors_todo], ecx
        jz      .done
        add     [edi], ecx
        jc      .fail
        shl     ecx, 9
        add     esi, ecx
        jmp     .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
; Release the global lock and return the corresponding status.
.fail:
        mov     ecx, [channel_lock]
        call    mutex_unlock
        mov     ecx, ide_mutex
        call    mutex_unlock
        or      eax, -1
        ret
.done:
        mov     ecx, [channel_lock]
        call    mutex_unlock
        mov     ecx, ide_mutex
        call    mutex_unlock
        xor     eax, eax
        ret
endp
 
; This is a stub.
proc ide_querymedia stdcall, hd_data, mediainfo
        mov     eax, [mediainfo]
        mov     [eax+DISKMEDIAINFO.Flags], 0
        mov     [eax+DISKMEDIAINFO.SectorSize], 512
        or      dword [eax+DISKMEDIAINFO.Capacity], 0xFFFFFFFF
        or      dword [eax+DISKMEDIAINFO.Capacity+4], 0xFFFFFFFF
        xor     eax, eax
        ret
endp
 
;-----------------------------------------------------------------------------
align 4
; input: eax = sector, edi -> buffer
; output: edi = edi + 512
hd_read_pio:
        push    eax edx
 
; Select the desired drive
        mov     edx, [hdbase]
        add     edx, 6   ;адрес регистра головок
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al; номер головки/номер диска
        
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jne     hd_read_error
        
; ATA with 28 or 48 bit for sector number?
        mov     eax, [esp+4]
        cmp     eax, 0x10000000
        jae     .lba48
;--------------------------------------
.lba28:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; ATA Features регистр "особенностей"
        inc     edx
        inc     eax
        out     dx, al ; ATA Sector Counter счётчик секторов
        inc     edx
        mov     eax, [esp+4+4]
        out     dx, al ; LBA Low LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High LBA (23:16)
        shr     eax, 8
        inc     edx
        and     al, 1+2+4+8 ; LBA (27:24)
        add     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 20h ; READ SECTOR(S)
        out     dx, al ; ATACommand регистр команд
        popfd
        jmp     .continue
;--------------------------------------
.lba48:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; Features Previous Reserved
        out     dx, al ; Features Current Reserved
        inc     edx
        out     dx, al ; Sector Count Previous Sector count (15:8)
        inc     eax
        out     dx, al ; Sector Count Current Sector count (7:0)
        inc     edx
        mov     eax, [esp+4+4]
        rol     eax, 8
        out     dx, al ; LBA Low Previous LBA (31:24)
        xor     eax, eax ; because only 32 bit cache
        inc     edx
        out     dx, al ; LBA Mid Previous LBA (39:32)
        inc     edx
        out     dx, al ; LBA High Previous LBA (47:40)
        sub     edx, 2
        mov     eax, [esp+4+4]
        out     dx, al ; LBA Low Current LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid Current LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High Current LBA (23:16)
        inc     edx
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 24h ; READ SECTOR(S) EXT
        out     dx, al ; ATACommand регистр команд
        popfd
;--------------------------------------
.continue:
        call    wait_for_sector_buffer
 
        cmp     [hd_error], 0
        jne     hd_read_error
 
        pushfd
        cli
 
        mov     ecx, 256
        mov     edx, [hdbase]
        cld
        rep insw
        popfd
 
        pop     edx eax
        ret
;-----------------------------------------------------------------------------
align 4
; edi -> sector, esi -> data
cache_write_pio:
; Select the desired drive
        mov     edx, [hdbase]
        add     edx, 6   ;адрес регистра головок
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
 
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jne     hd_write_error
 
; ATA with 28 or 48 bit for sector number?
        mov     eax, [edi]
        cmp     eax, 0x10000000
        jae     .lba48
;--------------------------------------
.lba28:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; ATA Features регистр "особенностей"
        inc     edx
        inc     eax
        out     dx, al ; ATA Sector Counter счётчик секторов
        inc     edx
        mov     eax, [edi]      ; eax = sector to write
        out     dx, al ; LBA Low LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High LBA (23:16)
        shr     eax, 8
        inc     edx
        and     al, 1+2+4+8 ; LBA (27:24)
        add     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 30h ; WRITE SECTOR(S)
        out     dx, al ; ATACommand регистр команд
        jmp     .continue
;--------------------------------------
.lba48:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; Features Previous Reserved
        out     dx, al ; Features Current Reserved
        inc     edx
        out     dx, al ; Sector Count Previous Sector count (15:8)
        inc     eax
        out     dx, al ; Sector Count Current Sector count (7:0)
        inc     edx
        mov     eax, [edi]
        rol     eax, 8
        out     dx, al ; LBA Low Previous LBA (31:24)
        xor     eax, eax ; because only 32 bit cache
        inc     edx
        out     dx, al ; LBA Mid Previous LBA (39:32)
        inc     edx
        out     dx, al ; LBA High Previous LBA (47:40)
        sub     edx, 2
        mov     eax, [edi]
        out     dx, al ; LBA Low Current LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid Current LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High Current LBA (23:16)
        inc     edx
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 34h ; WRITE SECTOR(S) EXT
        out     dx, al ; ATACommand регистр команд
;--------------------------------------
.continue:
        popfd
        call    wait_for_sector_buffer
 
        cmp     [hd_error], 0
        jne     hd_write_error
 
        push    ecx esi
 
        pushfd
        cli
        mov     ecx, 256
        mov     edx, [hdbase]
        cld
        rep outsw
        popfd
 
        pop     esi ecx
        ret
;-----------------------------------------------------------------------------
align 4
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
;-----------------------------------------------------------------------------
hd_timeout_error:
        if lang eq sp
        DEBUGF 1,"K : FS - HD tiempo de espera agotado\n"
        else
        DEBUGF 1,"K : FS - HD timeout\n"
        end if
        mov     [hd_error], 1
        pop     eax
        ret
;-----------------------------------------------------------------------------
hd_read_error:
        if lang eq sp
        DEBUGF 1,"K : FS - HD error de lectura\n"
        else
        DEBUGF 1,"K : FS - HD read error\n"
        end if
        pop     edx eax
        ret
;-----------------------------------------------------------------------------
hd_write_error_dma:
        pop     esi
hd_write_error:
        if lang eq sp
        DEBUGF 1,"K : FS - HD error de escritura\n"
        else
        DEBUGF 1,"K : FS - HD write error\n"
        end if
        ret
;-----------------------------------------------------------------------------
align 4
wait_for_hd_idle:
        push    eax edx
 
        call    save_hd_wait_timeout
 
        mov     edx, [hdbase]
        add     edx, 0x7
;--------------------------------------
align 4
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
;--------------------------------------
align 4
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
;-----------------------------------------------------------------------------
irq14_num equ byte 14
irq15_num equ byte 15
;-----------------------------------------------------------------------------
align 4
wait_for_sector_dma_ide0:
        push    eax
        push    edx
        call    save_hd_wait_timeout
;--------------------------------------
align 4
.wait:
        call    change_task
        cmp     [IDE_common_irq_param], 0
        jz      .done
 
        call    check_hd_wait_timeout
        cmp     [hd_error], 0
        jz      .wait
; clear Bus Master IDE Command register
        pushfd
        cli
        mov     [IDE_common_irq_param], 0
        mov     dx, [IDEContrRegsBaseAddr]
        mov     al, 0
        out     dx, al
        popfd
;--------------------------------------
align 4
.done:
        pop     edx
        pop     eax
        ret
;-----------------------------------------------------------------------------
align 4
wait_for_sector_dma_ide1:
        push    eax
        push    edx
        call    save_hd_wait_timeout
;--------------------------------------
align 4
.wait:
        call    change_task
        cmp     [IDE_common_irq_param], 0
        jz      .done
 
        call    check_hd_wait_timeout
        cmp     [hd_error], 0
        jz      .wait
; clear Bus Master IDE Command register
        pushfd
        cli
        mov     [IDE_common_irq_param], 0
        mov     dx, [IDEContrRegsBaseAddr]
        add     dx, 8
        mov     al, 0
        out     dx, al
        popfd
;--------------------------------------
align 4
.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
IDE_common_irq_param db 0
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
IDE_irq_14_handler:
        cmp     [IDE_common_irq_param], irq14_num
        jne     .exit
 
        pushfd
        cli
        pushad
        mov     [IDE_common_irq_param], 0
        mov     dx, [IDEContrRegsBaseAddr]
; test whether it is our interrupt?
        add     edx, 2
        in      al, dx
        test    al, 100b
        jz      @f
; clear Bus Master IDE Status register
; clear Interrupt bit
        out     dx, al
; clear Bus Master IDE Command register
        sub     edx, 2
        xor     eax, eax
        out     dx, al
; read status register and remove the interrupt request
        mov     edx, [hdbase]
        add     edx, 0x7
        in      al, dx
        popad
        popfd
        mov     al, 1
        ret
;--------------------------------------
align 4
@@:
        popad
        popfd
;--------------------------------------
align 4
.exit:
        mov     al, 0
        ret
;-----------------------------------------------------------------------------
align 4
IDE_irq_15_handler:
        cmp     [IDE_common_irq_param], irq15_num
        jne     .exit
 
        pushfd
        cli
        pushad
        mov     [IDE_common_irq_param], 0
        mov     dx, [IDEContrRegsBaseAddr]
        add     dx, 8
; test whether it is our interrupt?
        add     edx, 2
        in      al, dx
        test    al, 100b
        jz      @f
; clear Bus Master IDE Status register
; clear Interrupt bit
        out     dx, al
; clear Bus Master IDE Command register
        sub     edx, 2
        mov     al, 0
        out     dx, al
; read status register and remove the interrupt request
        mov     edx, [hdbase]
        add     edx, 0x7
        in      al, dx
        popad
        popfd
        mov     al, 1
        ret
;--------------------------------------
align 4
@@:
        popad
        popfd
;--------------------------------------
align 4
.exit:
        mov     al, 0
        ret
;-----------------------------------------------------------------------------
align 4
IDE_common_irq_handler:
        cmp     [IDE_common_irq_param], 0
        je      .exit
 
        pushfd
        cli
        pushad
        xor     ebx, ebx
        mov     dx, [IDEContrRegsBaseAddr]
        mov     eax, IDE_common_irq_param
        cmp     [eax], irq14_num
        mov     [eax], bl
        je      @f
 
        add     dx, 8
;--------------------------------------
align 4
@@:
; test whether it is our interrupt?
        add     edx, 2
        in      al, dx
        test    al, 100b
        jz      @f
; clear Bus Master IDE Status register
; clear Interrupt bit
        out     dx, al
; clear Bus Master IDE Command register
        sub     edx, 2
        xor     eax, eax
        out     dx, al
; read status register and remove the interrupt request
        mov     edx, [hdbase]
        add     edx, 0x7
        in      al, dx
        popad
        popfd
        mov     al, 1
        ret
;--------------------------------------
align 4
@@:
        popad
        popfd
;--------------------------------------
align 4
.exit:
        mov     al, 0
        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
        mov     esi, eax
 
        mov     ecx, 512/4
        cld
        rep movsd
        pop     esi ecx
        pop     edx
        pop     eax
        ret
.notread:
; set data for PRD Table
        mov     eax, IDE_descriptor_table
        mov     dword [eax], IDE_DMA
        mov     word [eax+4], 0x2000
        sub     eax, OS_BASE
; select controller Primary or Secondary
        mov     dx, [IDEContrRegsBaseAddr]
        push    eax
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        pop     eax
        jz      @f
        add     edx, 8
@@:
        push    edx
; Bus Master IDE PRD Table Address
        add     edx, 4
; save IDE_descriptor_table
        out     dx, eax
        pop     edx
; clear Bus Master IDE Command register
        mov     al, 0
        out     dx, al
; clear Bus Master IDE Status register
; clear Error bit and Interrupt bit
        add     edx, 2
        mov     al, 6 ; 110b
        out     dx, al
; Select the desired drive
        mov     edx, [hdbase]
        add     edx, 6   ; адрес регистра головок
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
 
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jnz     hd_read_error
 
; ATA with 28 or 48 bit for sector number?
        mov     eax, [esp+4]
; -10h because the PreCache hits the boundary between lba28 and lba48
; 10h = 16  - size of PreCache
        cmp     eax, 0x10000000-10h
        jae     .lba48
;--------------------------------------
.lba28:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; ATA Features регистр "особенностей"
        inc     edx
        mov     eax, 10h ; Sector Counter = 16 ; PreCache
        out     dx, al ; ATA Sector Counter счётчик секторов
        inc     edx
        mov     eax, [esp+4+4]
        out     dx, al ; LBA Low LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High LBA (23:16)
        shr     eax, 8
        inc     edx
        and     al, 0xF ; LBA (27:24)
        add     al, byte [hdid]
        add     al, 11100000b
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 0xC8 ; READ DMA
        out     dx, al ; ATACommand регистр команд
        jmp     .continue
;--------------------------------------
.lba48:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; Features Previous Reserved
        out     dx, al ; Features Current Reserved
        inc     edx
        out     dx, al ; Sector Count Previous Sector count (15:8)
        mov     eax, 10h ; Sector Counter = 16 PreCache
        out     dx, al ; Sector Count Current Sector count (7:0)
        inc     edx
        mov     eax, [esp+4+4]
        rol     eax, 8
        out     dx, al ; LBA Low Previous LBA (31:24)
        xor     eax, eax ; because only 32 bit cache
        inc     edx
        out     dx, al ; LBA Mid Previous LBA (39:32)
        inc     edx
        out     dx, al ; LBA High Previous LBA (47:40)
        sub     edx, 2
        mov     eax, [esp+4+4]
        out     dx, al ; LBA Low Current LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid Current LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High Current LBA (23:16)
        inc     edx
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 25h ; READ DMA EXT
        out     dx, al ; ATACommand регистр команд
;--------------------------------------
.continue:
; select controller Primary or Secondary
        mov     dx, [IDEContrRegsBaseAddr]
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        jz      @f
        add     dx, 8
@@:
; set write to memory and Start Bus Master
        mov     al, 9
        out     dx, al
 
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
 
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
 
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        jnz     .ide1
 
        mov     [IDE_common_irq_param], irq14_num
        jmp     @f
.ide1:
        mov     [IDE_common_irq_param], irq15_num
@@:
        popfd
; wait for interrupt
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 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
;-----------------------------------------------------------------------------
cache_write_dma:
        mov     eax, [cache_chain_ptr] ; for what?
        push    esi
; set data for PRD Table
        mov     eax, IDE_descriptor_table
        mov     edx, eax
        pusha
        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
; select controller Primary or Secondary
        mov     dx, [IDEContrRegsBaseAddr]
        push    eax
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        pop     eax
        jz      @f
        add     edx, 8
@@:
        push    edx
; Bus Master IDE PRD Table Address
        add     edx, 4
; save IDE_descriptor_table
        out     dx, eax
        pop     edx
; clear Bus Master IDE Command register
        mov     al, 0
        out     dx, al
; clear Bus Master IDE Status register
; clear Error bit and Interrupt bit
        add     edx, 2
        mov     al, 6
        out     dx, al
; Select the desired drive
        mov     edx, [hdbase]
        add     edx, 6   ; адрес регистра головок
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
 
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jnz     hd_write_error_dma
 
; ATA with 28 or 48 bit for sector number?
        mov     esi, [cache_chain_ptr]
        mov     eax, [esi]
; -40h because the PreCache hits the boundary between lba28 and lba48
; 40h = 64  - the maximum number of sectors to be written for one command
        cmp     eax, 0x10000000-40h
        jae     .lba48
;--------------------------------------
.lba28:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; ATA Features регистр "особенностей"
        inc     edx
        mov     al, [cache_chain_size] ; Sector Counter
        out     dx, al ; ATA Sector Counter счётчик секторов
        inc     edx
        mov     eax, [esi]
        out     dx, al ; LBA Low LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High LBA (23:16)
        shr     eax, 8
        inc     edx
        and     al, 0xF ; LBA (27:24)
        add     al, byte [hdid]
        add     al, 11100000b
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 0xCA ; WRITE DMA
        out     dx, al ; ATACommand регистр команд
        jmp     .continue
;--------------------------------------
.lba48:
        pushfd
        cli
        xor     eax, eax
        mov     edx, [hdbase]
        inc     edx
        out     dx, al ; Features Previous Reserved
        out     dx, al ; Features Current Reserved
        inc     edx
        out     dx, al ; Sector Count Previous Sector count (15:8)
        mov     al, [cache_chain_size] ; Sector Counter
        out     dx, al ; Sector Count Current Sector count (7:0)
        inc     edx
        mov     eax, [esi]
        rol     eax, 8
        out     dx, al ; LBA Low Previous LBA (31:24)
        xor     eax, eax ; because only 32 bit cache
        inc     edx
        out     dx, al ; LBA Mid Previous LBA (39:32)
        inc     edx
        out     dx, al ; LBA High Previous LBA (47:40)
        sub     edx, 2
        mov     eax, [esi]
        out     dx, al ; LBA Low Current LBA (7:0)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA Mid Current LBA (15:8)
        shr     eax, 8
        inc     edx
        out     dx, al ; LBA High Current LBA (23:16)
        inc     edx
        mov     al, byte [hdid]
        add     al, 128+64+32
        out     dx, al ; номер головки/номер диска
        inc     edx
        mov     al, 35h ; WRITE DMA EXT
        out     dx, al ; ATACommand регистр команд
;--------------------------------------
.continue:
; select controller Primary or Secondary
        mov     dx, [IDEContrRegsBaseAddr]
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        jz      @f
        add     dx, 8
@@:
; set write to device and Start Bus Master
        mov     al, 1
        out     dx, al
        mov     eax, [CURRENT_TASK]
        mov     [dma_process], eax
        mov     eax, [TASK_BASE]
        mov     [dma_slot_ptr], eax
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 0x1F0
        jnz     .ide1
 
        mov     [IDE_common_irq_param], irq14_num
        jmp     @f
.ide1:
        mov     [IDE_common_irq_param], irq15_num
@@:
        popfd
; wait for interrupt
        mov     [dma_cur_sector], not 0x40
        mov     eax, [hd_address_table]
        cmp     [hdbase], eax ; 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
align 4
IDEContrProgrammingInterface dd ?
IDE_Interrupt   dw ?
IDEContrRegsBaseAddr         dw ?
 
IDE_BAR0_val    dw ?
IDE_BAR1_val    dw ?
IDE_BAR2_val    dw ?
IDE_BAR3_val    dw ?
endg
;-----------------------------------------------------------------------------
 
proc clear_pci_ide_interrupts
        mov     esi, pcidev_list
.loop:
        mov     esi, [esi+PCIDEV.fd]
        cmp     esi, pcidev_list
        jz      .done
        cmp     [esi+PCIDEV.class], 0x01018F
        jnz     .loop
        mov     ah, [esi+PCIDEV.bus]
        mov     al, 2
        mov     bh, [esi+PCIDEV.devfn]
        mov     bl, 0x20
        call    pci_read_reg
        and     eax, 0FFFCh
        mov     edx, eax
        add     edx, 2
        in      al, dx
        DEBUGF 1,'K : clear_pci_ide_interrupts: port[%x] = %x ',dx,al
        out     dx, al
        in      al, dx
        DEBUGF 1,'-> %x; ',al
        add     edx, 8
        in      al, dx
        DEBUGF 1,'port[%x] = %x ',dx,al
        out     dx, al
        in      al, dx
        DEBUGF 1,'-> %x\n',al
        jmp     .loop
.done:
        ret
endp

Rev 4578	Rev 4624
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2013. 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: 4578 $	8	$Revision: 4624 $
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	; LBA48 support by Mario79	13	; LBA48 support by Mario79
14	;-----------------------------------------------------------------------------	14	;-----------------------------------------------------------------------------
15	struct HD_DATA	15	struct HD_DATA
16	hdbase dd ?	16	hdbase dd ?
17	hdid dd ?	17	hdid dd ?
18	hdpos dd ?	18	hdpos dd ?
19	ends	19	ends
20		20
21	iglobal	21	iglobal
22	align 4	22	align 4
23	ide_callbacks:	23	ide_callbacks:
24	dd ide_callbacks.end - ide_callbacks ; strucsize	24	dd ide_callbacks.end - ide_callbacks ; strucsize
25	dd 0 ; no close function	25	dd 0 ; no close function
26	dd 0 ; no closemedia function	26	dd 0 ; no closemedia function
27	dd ide_querymedia	27	dd ide_querymedia
28	dd ide_read	28	dd ide_read
29	dd ide_write	29	dd ide_write
30	dd 0 ; no flush function	30	dd 0 ; no flush function
31	dd 0 ; use default cache size	31	dd 0 ; use default cache size
32	.end:	32	.end:
33		33
34	hd0_data HD_DATA ?, 0, 1	34	hd0_data HD_DATA ?, 0, 1
35	hd1_data HD_DATA ?, 0x10, 2	35	hd1_data HD_DATA ?, 0x10, 2
36	hd2_data HD_DATA ?, 0, 3	36	hd2_data HD_DATA ?, 0, 3
37	hd3_data HD_DATA ?, 0x10, 4	37	hd3_data HD_DATA ?, 0x10, 4
38		38
39	hd_address_table:	39	hd_address_table:
40	dd 0x1f0, 0x00, 0x1f0, 0x10	40	dd 0x1f0, 0x00, 0x1f0, 0x10
41	dd 0x170, 0x00, 0x170, 0x10	41	dd 0x170, 0x00, 0x170, 0x10
42	endg	42	endg
43		43
44	uglobal	44	uglobal
45	ide_mutex MUTEX	45	ide_mutex MUTEX
46	ide_channel1_mutex MUTEX	46	ide_channel1_mutex MUTEX
47	ide_channel2_mutex MUTEX	47	ide_channel2_mutex MUTEX
48	endg	48	endg
49		49
50	proc ide_read stdcall uses edi, \	50	proc ide_read stdcall uses edi, \
51	hd_data, buffer, startsector:qword, numsectors	51	hd_data, buffer, startsector:qword, numsectors
52	; hd_data = pointer to hd*_data	52	; hd_data = pointer to hd*_data
53	; buffer = pointer to buffer for data	53	; buffer = pointer to buffer for data
54	; startsector = 64-bit start sector	54	; startsector = 64-bit start sector
55	; numsectors = pointer to number of sectors on input,	55	; numsectors = pointer to number of sectors on input,
56	; must be filled with number of sectors really read	56	; must be filled with number of sectors really read
57	locals	57	locals
58	sectors_todo dd ?	58	sectors_todo dd ?
59	channel_lock dd ?	59	channel_lock dd ?
60	endl	60	endl
61	; 1. Initialize number of sectors: get number of requested sectors	61	; 1. Initialize number of sectors: get number of requested sectors
62	; and say that no sectors were read yet.	62	; and say that no sectors were read yet.
63	mov ecx, [numsectors]	63	mov ecx, [numsectors]
64	mov eax, [ecx]	64	mov eax, [ecx]
65	mov dword [ecx], 0	65	mov dword [ecx], 0
66	mov [sectors_todo], eax	66	mov [sectors_todo], eax
67	; 2. Acquire the global lock.	67	; 2. Acquire the global lock.
68	mov ecx, ide_mutex	68	mov ecx, ide_mutex
69	call mutex_lock	69	call mutex_lock
70	mov ecx, ide_channel2_mutex	70	mov ecx, ide_channel2_mutex
71	mov eax, [hd_data]	71	mov eax, [hd_data]
72	push ecx	72	push ecx
73	mov ecx, [hd_address_table]	73	mov ecx, [hd_address_table]
74	cmp [eax+HD_DATA.hdbase], ecx ; 0x1F0	74	cmp [eax+HD_DATA.hdbase], ecx ; 0x1F0
75	pop ecx	75	pop ecx
76	jne .IDE_Channel_2	76	jne .IDE_Channel_2
77	mov ecx, ide_channel1_mutex	77	mov ecx, ide_channel1_mutex
78	.IDE_Channel_2:	78	.IDE_Channel_2:
79	mov [channel_lock], ecx	79	mov [channel_lock], ecx
80	call mutex_lock	80	call mutex_lock
81	; 3. Convert parameters to the form suitable for worker procedures.	81	; 3. Convert parameters to the form suitable for worker procedures.
82	; Underlying procedures do not know about 64-bit sectors.	82	; Underlying procedures do not know about 64-bit sectors.
83	; Worker procedures use global variables and edi for [buffer].	83	; Worker procedures use global variables and edi for [buffer].
84	cmp dword [startsector+4], 0	84	cmp dword [startsector+4], 0
85	jnz .fail	85	jnz .fail
86	and [hd_error], 0	86	and [hd_error], 0
87	mov ecx, [hd_data]	87	mov ecx, [hd_data]
88	mov eax, [ecx+HD_DATA.hdbase]	88	mov eax, [ecx+HD_DATA.hdbase]
89	mov [hdbase], eax	89	mov [hdbase], eax
90	mov eax, [ecx+HD_DATA.hdid]	90	mov eax, [ecx+HD_DATA.hdid]
91	mov [hdid], eax	91	mov [hdid], eax
92	mov eax, [ecx+HD_DATA.hdpos]	92	mov eax, [ecx+HD_DATA.hdpos]
93	mov [hdpos], eax	93	mov [hdpos], eax
94	mov eax, dword [startsector]	94	mov eax, dword [startsector]
95	mov edi, [buffer]	95	mov edi, [buffer]
96	; 4. Worker procedures take one sectors per time, so loop over all sectors to read.	96	; 4. Worker procedures take one sectors per time, so loop over all sectors to read.
97	.sectors_loop:	97	.sectors_loop:
98	; DMA read is permitted if [allow_dma_access]=1 or 2	98	; DMA read is permitted if [allow_dma_access]=1 or 2
99	cmp [allow_dma_access], 2	99	cmp [allow_dma_access], 2
100	ja .nodma	100	ja .nodma
101	cmp [dma_hdd], 1	101	cmp [dma_hdd], 1
102	jnz .nodma	102	jnz .nodma
103	;--------------------------------------	103	;--------------------------------------
104	push eax	104	push eax
105	mov eax, [hd_address_table]	105	mov eax, [hd_address_table]
106	cmp [hdbase], eax ; 0x1F0	106	cmp [hdbase], eax ; 0x1F0
107	pop eax	107	pop eax
108	jnz @f	108	jnz @f
109		109
110	test [DRIVE_DATA+1], byte 10100000b	110	test [DRIVE_DATA+1], byte 10100000b
111	jnz .nodma	111	jnz .nodma
112		112
113	jmp .dma	113	jmp .dma
114	@@:	114	@@:
115	test [DRIVE_DATA+1], byte 1010b	115	test [DRIVE_DATA+1], byte 1010b
116	jnz .nodma	116	jnz .nodma
117	.dma:	117	.dma:
118	;--------------------------------------	118	;--------------------------------------
119	call hd_read_dma	119	call hd_read_dma
120	jmp @f	120	jmp @f
121	.nodma:	121	.nodma:
122	call hd_read_pio	122	call hd_read_pio
123	@@:	123	@@:
124	cmp [hd_error], 0	124	cmp [hd_error], 0
125	jnz .fail	125	jnz .fail
126	mov ecx, [numsectors]	126	mov ecx, [numsectors]
127	inc dword [ecx] ; one more sector is read	127	inc dword [ecx] ; one more sector is read
128	dec [sectors_todo]	128	dec [sectors_todo]
129	jz .done	129	jz .done
130	inc eax	130	inc eax
131	jnz .sectors_loop	131	jnz .sectors_loop
132	; 5. Loop is done, either due to error or because everything is done.	132	; 5. Loop is done, either due to error or because everything is done.
133	; Release the global lock and return the corresponding status.	133	; Release the global lock and return the corresponding status.
134	.fail:	134	.fail:
135	mov ecx, [channel_lock]	135	mov ecx, [channel_lock]
136	call mutex_unlock	136	call mutex_unlock
137	mov ecx, ide_mutex	137	mov ecx, ide_mutex
138	call mutex_unlock	138	call mutex_unlock
139	or eax, -1	139	or eax, -1
140	ret	140	ret
141	.done:	141	.done:
142	mov ecx, [channel_lock]	142	mov ecx, [channel_lock]
143	call mutex_unlock	143	call mutex_unlock
144	mov ecx, ide_mutex	144	mov ecx, ide_mutex
145	call mutex_unlock	145	call mutex_unlock
146	xor eax, eax	146	xor eax, eax
147	ret	147	ret
148	endp	148	endp
149		149
150	proc ide_write stdcall uses esi edi, \	150	proc ide_write stdcall uses esi edi, \
151	hd_data, buffer, startsector:qword, numsectors	151	hd_data, buffer, startsector:qword, numsectors
152	; hd_data = pointer to hd*_data	152	; hd_data = pointer to hd*_data
153	; buffer = pointer to buffer with data	153	; buffer = pointer to buffer with data
154	; startsector = 64-bit start sector	154	; startsector = 64-bit start sector
155	; numsectors = pointer to number of sectors on input,	155	; numsectors = pointer to number of sectors on input,
156	; must be filled with number of sectors really written	156	; must be filled with number of sectors really written
157	locals	157	locals
158	sectors_todo dd ?	158	sectors_todo dd ?
159	channel_lock dd ?	159	channel_lock dd ?
160	endl	160	endl
161	; 1. Initialize number of sectors: get number of requested sectors	161	; 1. Initialize number of sectors: get number of requested sectors
162	; and say that no sectors were read yet.	162	; and say that no sectors were read yet.
163	mov ecx, [numsectors]	163	mov ecx, [numsectors]
164	mov eax, [ecx]	164	mov eax, [ecx]
165	mov dword [ecx], 0	165	mov dword [ecx], 0
166	mov [sectors_todo], eax	166	mov [sectors_todo], eax
167	; 2. Acquire the global lock.	167	; 2. Acquire the global lock.
168	mov ecx, ide_mutex	168	mov ecx, ide_mutex
169	call mutex_lock	169	call mutex_lock
170	mov ecx, ide_channel2_mutex	170	mov ecx, ide_channel2_mutex
171	mov eax, [hd_data]	171	mov eax, [hd_data]
172	push ecx	172	push ecx
173	mov ecx, [hd_address_table]	173	mov ecx, [hd_address_table]
174	cmp [eax+HD_DATA.hdbase], ecx ; 0x1F0	174	cmp [eax+HD_DATA.hdbase], ecx ; 0x1F0
175	pop ecx	175	pop ecx
176	jne .IDE_Channel_2	176	jne .IDE_Channel_2
177	mov ecx, ide_channel1_mutex	177	mov ecx, ide_channel1_mutex
178	.IDE_Channel_2:	178	.IDE_Channel_2:
179	mov [channel_lock], ecx	179	mov [channel_lock], ecx
180	call mutex_lock	180	call mutex_lock
181	; 3. Convert parameters to the form suitable for worker procedures.	181	; 3. Convert parameters to the form suitable for worker procedures.
182	; Underlying procedures do not know about 64-bit sectors.	182	; Underlying procedures do not know about 64-bit sectors.
183	; Worker procedures use global variables and esi for [buffer].	183	; Worker procedures use global variables and esi for [buffer].
184	cmp dword [startsector+4], 0	184	cmp dword [startsector+4], 0
185	jnz .fail	185	jnz .fail
186	and [hd_error], 0	186	and [hd_error], 0
187	mov ecx, [hd_data]	187	mov ecx, [hd_data]
188	mov eax, [ecx+HD_DATA.hdbase]	188	mov eax, [ecx+HD_DATA.hdbase]
189	mov [hdbase], eax	189	mov [hdbase], eax
190	mov eax, [ecx+HD_DATA.hdid]	190	mov eax, [ecx+HD_DATA.hdid]
191	mov [hdid], eax	191	mov [hdid], eax
192	mov eax, [ecx+HD_DATA.hdpos]	192	mov eax, [ecx+HD_DATA.hdpos]
193	mov [hdpos], eax	193	mov [hdpos], eax
194	mov esi, [buffer]	194	mov esi, [buffer]
195	lea edi, [startsector]	195	lea edi, [startsector]
196	mov [cache_chain_ptr], edi	196	mov [cache_chain_ptr], edi
197	; 4. Worker procedures take max 16 sectors per time,	197	; 4. Worker procedures take max 16 sectors per time,
198	; loop until all sectors will be processed.	198	; loop until all sectors will be processed.
199	.sectors_loop:	199	.sectors_loop:
200	mov ecx, 16	200	mov ecx, 16
201	cmp ecx, [sectors_todo]	201	cmp ecx, [sectors_todo]
202	jbe @f	202	jbe @f
203	mov ecx, [sectors_todo]	203	mov ecx, [sectors_todo]
204	@@:	204	@@:
205	mov [cache_chain_size], cl	205	mov [cache_chain_size], cl
206	; DMA write is permitted only if [allow_dma_access]=1	206	; DMA write is permitted only if [allow_dma_access]=1
207	cmp [allow_dma_access], 2	207	cmp [allow_dma_access], 2
208	jae .nodma	208	jae .nodma
209	cmp [dma_hdd], 1	209	cmp [dma_hdd], 1
210	jnz .nodma	210	jnz .nodma
211	;--------------------------------------	211	;--------------------------------------
212	push eax	212	push eax
213	mov eax, [hd_address_table]	213	mov eax, [hd_address_table]
214	cmp [hdbase], eax ; 0x1F0	214	cmp [hdbase], eax ; 0x1F0
215	pop eax	215	pop eax
216	jnz @f	216	jnz @f
217		217
218	test [DRIVE_DATA+1], byte 10100000b	218	test [DRIVE_DATA+1], byte 10100000b
219	jnz .nodma	219	jnz .nodma
220		220
221	jmp .dma	221	jmp .dma
222	@@:	222	@@:
223	test [DRIVE_DATA+1], byte 1010b	223	test [DRIVE_DATA+1], byte 1010b
224	jnz .nodma	224	jnz .nodma
225	.dma:	225	.dma:
226	;--------------------------------------	226	;--------------------------------------
227	call cache_write_dma	227	call cache_write_dma
228	jmp .common	228	jmp .common
229	.nodma:	229	.nodma:
230	mov [cache_chain_size], 1	230	mov [cache_chain_size], 1
231	call cache_write_pio	231	call cache_write_pio
232	.common:	232	.common:
233	cmp [hd_error], 0	233	cmp [hd_error], 0
234	jnz .fail	234	jnz .fail
235	movzx ecx, [cache_chain_size]	235	movzx ecx, [cache_chain_size]
236	mov eax, [numsectors]	236	mov eax, [numsectors]
237	add [eax], ecx	237	add [eax], ecx
238	sub [sectors_todo], ecx	238	sub [sectors_todo], ecx
239	jz .done	239	jz .done
240	add [edi], ecx	240	add [edi], ecx
241	jc .fail	241	jc .fail
242	shl ecx, 9	242	shl ecx, 9
243	add esi, ecx	243	add esi, ecx
244	jmp .sectors_loop	244	jmp .sectors_loop
245	; 5. Loop is done, either due to error or because everything is done.	245	; 5. Loop is done, either due to error or because everything is done.
246	; Release the global lock and return the corresponding status.	246	; Release the global lock and return the corresponding status.
247	.fail:	247	.fail:
248	mov ecx, [channel_lock]	248	mov ecx, [channel_lock]
249	call mutex_unlock	249	call mutex_unlock
250	mov ecx, ide_mutex	250	mov ecx, ide_mutex
251	call mutex_unlock	251	call mutex_unlock
252	or eax, -1	252	or eax, -1
253	ret	253	ret
254	.done:	254	.done:
255	mov ecx, [channel_lock]	255	mov ecx, [channel_lock]
256	call mutex_unlock	256	call mutex_unlock
257	mov ecx, ide_mutex	257	mov ecx, ide_mutex
258	call mutex_unlock	258	call mutex_unlock
259	xor eax, eax	259	xor eax, eax
260	ret	260	ret
261	endp	261	endp
262		262
263	; This is a stub.	263	; This is a stub.
264	proc ide_querymedia stdcall, hd_data, mediainfo	264	proc ide_querymedia stdcall, hd_data, mediainfo
265	mov eax, [mediainfo]	265	mov eax, [mediainfo]
266	mov [eax+DISKMEDIAINFO.Flags], 0	266	mov [eax+DISKMEDIAINFO.Flags], 0
267	mov [eax+DISKMEDIAINFO.SectorSize], 512	267	mov [eax+DISKMEDIAINFO.SectorSize], 512
268	or dword [eax+DISKMEDIAINFO.Capacity], 0xFFFFFFFF	268	or dword [eax+DISKMEDIAINFO.Capacity], 0xFFFFFFFF
269	or dword [eax+DISKMEDIAINFO.Capacity+4], 0xFFFFFFFF	269	or dword [eax+DISKMEDIAINFO.Capacity+4], 0xFFFFFFFF
270	xor eax, eax	270	xor eax, eax
271	ret	271	ret
272	endp	272	endp
273		273
274	;-----------------------------------------------------------------------------	274	;-----------------------------------------------------------------------------
275	align 4	275	align 4
276	; input: eax = sector, edi -> buffer	276	; input: eax = sector, edi -> buffer
277	; output: edi = edi + 512	277	; output: edi = edi + 512
278	hd_read_pio:	278	hd_read_pio:
279	push eax edx	279	push eax edx
280		280
281	; Select the desired drive	281	; Select the desired drive
282	mov edx, [hdbase]	282	mov edx, [hdbase]
283	add edx, 6 ;адрес регистра головок	283	add edx, 6 ;адрес регистра головок
284	mov al, byte [hdid]	284	mov al, byte [hdid]
285	add al, 128+64+32	285	add al, 128+64+32
286	out dx, al; номер головки/номер диска	286	out dx, al; номер головки/номер диска
287		287
288	call wait_for_hd_idle	288	call wait_for_hd_idle
289	cmp [hd_error], 0	289	cmp [hd_error], 0
290	jne hd_read_error	290	jne hd_read_error
291		291
292	; ATA with 28 or 48 bit for sector number?	292	; ATA with 28 or 48 bit for sector number?
293	mov eax, [esp+4]	293	mov eax, [esp+4]
294	cmp eax, 0x10000000	294	cmp eax, 0x10000000
295	jae .lba48	295	jae .lba48
296	;--------------------------------------	296	;--------------------------------------
297	.lba28:	297	.lba28:
298	pushfd	298	pushfd
299	cli	299	cli
300	xor eax, eax	300	xor eax, eax
301	mov edx, [hdbase]	301	mov edx, [hdbase]
302	inc edx	302	inc edx
303	out dx, al ; ATA Features регистр "особенностей"	303	out dx, al ; ATA Features регистр "особенностей"
304	inc edx	304	inc edx
305	inc eax	305	inc eax
306	out dx, al ; ATA Sector Counter счётчик секторов	306	out dx, al ; ATA Sector Counter счётчик секторов
307	inc edx	307	inc edx
308	mov eax, [esp+4+4]	308	mov eax, [esp+4+4]
309	out dx, al ; LBA Low LBA (7:0)	309	out dx, al ; LBA Low LBA (7:0)
310	shr eax, 8	310	shr eax, 8
311	inc edx	311	inc edx
312	out dx, al ; LBA Mid LBA (15:8)	312	out dx, al ; LBA Mid LBA (15:8)
313	shr eax, 8	313	shr eax, 8
314	inc edx	314	inc edx
315	out dx, al ; LBA High LBA (23:16)	315	out dx, al ; LBA High LBA (23:16)
316	shr eax, 8	316	shr eax, 8
317	inc edx	317	inc edx
318	and al, 1+2+4+8 ; LBA (27:24)	318	and al, 1+2+4+8 ; LBA (27:24)
319	add al, byte [hdid]	319	add al, byte [hdid]
320	add al, 128+64+32	320	add al, 128+64+32
321	out dx, al ; номер головки/номер диска	321	out dx, al ; номер головки/номер диска
322	inc edx	322	inc edx
323	mov al, 20h ; READ SECTOR(S)	323	mov al, 20h ; READ SECTOR(S)
324	out dx, al ; ATACommand регистр команд	324	out dx, al ; ATACommand регистр команд
325	popfd	325	popfd
326	jmp .continue	326	jmp .continue
327	;--------------------------------------	327	;--------------------------------------
328	.lba48:	328	.lba48:
329	pushfd	329	pushfd
330	cli	330	cli
331	xor eax, eax	331	xor eax, eax
332	mov edx, [hdbase]	332	mov edx, [hdbase]
333	inc edx	333	inc edx
334	out dx, al ; Features Previous Reserved	334	out dx, al ; Features Previous Reserved
335	out dx, al ; Features Current Reserved	335	out dx, al ; Features Current Reserved
336	inc edx	336	inc edx
337	out dx, al ; Sector Count Previous Sector count (15:8)	337	out dx, al ; Sector Count Previous Sector count (15:8)
338	inc eax	338	inc eax
339	out dx, al ; Sector Count Current Sector count (7:0)	339	out dx, al ; Sector Count Current Sector count (7:0)
340	inc edx	340	inc edx
341	mov eax, [esp+4+4]	341	mov eax, [esp+4+4]
342	rol eax, 8	342	rol eax, 8
343	out dx, al ; LBA Low Previous LBA (31:24)	343	out dx, al ; LBA Low Previous LBA (31:24)
344	xor eax, eax ; because only 32 bit cache	344	xor eax, eax ; because only 32 bit cache
345	inc edx	345	inc edx
346	out dx, al ; LBA Mid Previous LBA (39:32)	346	out dx, al ; LBA Mid Previous LBA (39:32)
347	inc edx	347	inc edx
348	out dx, al ; LBA High Previous LBA (47:40)	348	out dx, al ; LBA High Previous LBA (47:40)
349	sub edx, 2	349	sub edx, 2
350	mov eax, [esp+4+4]	350	mov eax, [esp+4+4]
351	out dx, al ; LBA Low Current LBA (7:0)	351	out dx, al ; LBA Low Current LBA (7:0)
352	shr eax, 8	352	shr eax, 8
353	inc edx	353	inc edx
354	out dx, al ; LBA Mid Current LBA (15:8)	354	out dx, al ; LBA Mid Current LBA (15:8)
355	shr eax, 8	355	shr eax, 8
356	inc edx	356	inc edx
357	out dx, al ; LBA High Current LBA (23:16)	357	out dx, al ; LBA High Current LBA (23:16)
358	inc edx	358	inc edx
359	mov al, byte [hdid]	359	mov al, byte [hdid]
360	add al, 128+64+32	360	add al, 128+64+32
361	out dx, al ; номер головки/номер диска	361	out dx, al ; номер головки/номер диска
362	inc edx	362	inc edx
363	mov al, 24h ; READ SECTOR(S) EXT	363	mov al, 24h ; READ SECTOR(S) EXT
364	out dx, al ; ATACommand регистр команд	364	out dx, al ; ATACommand регистр команд
365	popfd	365	popfd
366	;--------------------------------------	366	;--------------------------------------
367	.continue:	367	.continue:
368	call wait_for_sector_buffer	368	call wait_for_sector_buffer
369		369
370	cmp [hd_error], 0	370	cmp [hd_error], 0
371	jne hd_read_error	371	jne hd_read_error
372		372
373	pushfd	373	pushfd
374	cli	374	cli
375		375
376	mov ecx, 256	376	mov ecx, 256
377	mov edx, [hdbase]	377	mov edx, [hdbase]
378	cld	378	cld
379	rep insw	379	rep insw
380	popfd	380	popfd
381		381
382	pop edx eax	382	pop edx eax
383	ret	383	ret
384	;-----------------------------------------------------------------------------	384	;-----------------------------------------------------------------------------
385	align 4	385	align 4
386	; edi -> sector, esi -> data	386	; edi -> sector, esi -> data
387	cache_write_pio:	387	cache_write_pio:
388	; Select the desired drive	388	; Select the desired drive
389	mov edx, [hdbase]	389	mov edx, [hdbase]
390	add edx, 6 ;адрес регистра головок	390	add edx, 6 ;адрес регистра головок
391	mov al, byte [hdid]	391	mov al, byte [hdid]
392	add al, 128+64+32	392	add al, 128+64+32
393	out dx, al ; номер головки/номер диска	393	out dx, al ; номер головки/номер диска
394		394
395	call wait_for_hd_idle	395	call wait_for_hd_idle
396	cmp [hd_error], 0	396	cmp [hd_error], 0
397	jne hd_write_error	397	jne hd_write_error
398		398
399	; ATA with 28 or 48 bit for sector number?	399	; ATA with 28 or 48 bit for sector number?
400	mov eax, [edi]	400	mov eax, [edi]
401	cmp eax, 0x10000000	401	cmp eax, 0x10000000
402	jae .lba48	402	jae .lba48
403	;--------------------------------------	403	;--------------------------------------
404	.lba28:	404	.lba28:
405	pushfd	405	pushfd
406	cli	406	cli
407	xor eax, eax	407	xor eax, eax
408	mov edx, [hdbase]	408	mov edx, [hdbase]
409	inc edx	409	inc edx
410	out dx, al ; ATA Features регистр "особенностей"	410	out dx, al ; ATA Features регистр "особенностей"
411	inc edx	411	inc edx
412	inc eax	412	inc eax
413	out dx, al ; ATA Sector Counter счётчик секторов	413	out dx, al ; ATA Sector Counter счётчик секторов
414	inc edx	414	inc edx
415	mov eax, [edi] ; eax = sector to write	415	mov eax, [edi] ; eax = sector to write
416	out dx, al ; LBA Low LBA (7:0)	416	out dx, al ; LBA Low LBA (7:0)
417	shr eax, 8	417	shr eax, 8
418	inc edx	418	inc edx
419	out dx, al ; LBA Mid LBA (15:8)	419	out dx, al ; LBA Mid LBA (15:8)
420	shr eax, 8	420	shr eax, 8
421	inc edx	421	inc edx
422	out dx, al ; LBA High LBA (23:16)	422	out dx, al ; LBA High LBA (23:16)
423	shr eax, 8	423	shr eax, 8
424	inc edx	424	inc edx
425	and al, 1+2+4+8 ; LBA (27:24)	425	and al, 1+2+4+8 ; LBA (27:24)
426	add al, byte [hdid]	426	add al, byte [hdid]
427	add al, 128+64+32	427	add al, 128+64+32
428	out dx, al ; номер головки/номер диска	428	out dx, al ; номер головки/номер диска
429	inc edx	429	inc edx
430	mov al, 30h ; WRITE SECTOR(S)	430	mov al, 30h ; WRITE SECTOR(S)
431	out dx, al ; ATACommand регистр команд	431	out dx, al ; ATACommand регистр команд
432	jmp .continue	432	jmp .continue
433	;--------------------------------------	433	;--------------------------------------
434	.lba48:	434	.lba48:
435	pushfd	435	pushfd
436	cli	436	cli
437	xor eax, eax	437	xor eax, eax
438	mov edx, [hdbase]	438	mov edx, [hdbase]
439	inc edx	439	inc edx
440	out dx, al ; Features Previous Reserved	440	out dx, al ; Features Previous Reserved
441	out dx, al ; Features Current Reserved	441	out dx, al ; Features Current Reserved
442	inc edx	442	inc edx
443	out dx, al ; Sector Count Previous Sector count (15:8)	443	out dx, al ; Sector Count Previous Sector count (15:8)
444	inc eax	444	inc eax
445	out dx, al ; Sector Count Current Sector count (7:0)	445	out dx, al ; Sector Count Current Sector count (7:0)
446	inc edx	446	inc edx
447	mov eax, [edi]	447	mov eax, [edi]
448	rol eax, 8	448	rol eax, 8
449	out dx, al ; LBA Low Previous LBA (31:24)	449	out dx, al ; LBA Low Previous LBA (31:24)
450	xor eax, eax ; because only 32 bit cache	450	xor eax, eax ; because only 32 bit cache
451	inc edx	451	inc edx
452	out dx, al ; LBA Mid Previous LBA (39:32)	452	out dx, al ; LBA Mid Previous LBA (39:32)
453	inc edx	453	inc edx
454	out dx, al ; LBA High Previous LBA (47:40)	454	out dx, al ; LBA High Previous LBA (47:40)
455	sub edx, 2	455	sub edx, 2
456	mov eax, [edi]	456	mov eax, [edi]
457	out dx, al ; LBA Low Current LBA (7:0)	457	out dx, al ; LBA Low Current LBA (7:0)
458	shr eax, 8	458	shr eax, 8
459	inc edx	459	inc edx
460	out dx, al ; LBA Mid Current LBA (15:8)	460	out dx, al ; LBA Mid Current LBA (15:8)
461	shr eax, 8	461	shr eax, 8
462	inc edx	462	inc edx
463	out dx, al ; LBA High Current LBA (23:16)	463	out dx, al ; LBA High Current LBA (23:16)
464	inc edx	464	inc edx
465	mov al, byte [hdid]	465	mov al, byte [hdid]
466	add al, 128+64+32	466	add al, 128+64+32
467	out dx, al ; номер головки/номер диска	467	out dx, al ; номер головки/номер диска
468	inc edx	468	inc edx
469	mov al, 34h ; WRITE SECTOR(S) EXT	469	mov al, 34h ; WRITE SECTOR(S) EXT
470	out dx, al ; ATACommand регистр команд	470	out dx, al ; ATACommand регистр команд
471	;--------------------------------------	471	;--------------------------------------
472	.continue:	472	.continue:
473	popfd	473	popfd
474	call wait_for_sector_buffer	474	call wait_for_sector_buffer
475		475
476	cmp [hd_error], 0	476	cmp [hd_error], 0
477	jne hd_write_error	477	jne hd_write_error
478		478
479	push ecx esi	479	push ecx esi
480		480
481	pushfd	481	pushfd
482	cli	482	cli
483	mov ecx, 256	483	mov ecx, 256
484	mov edx, [hdbase]	484	mov edx, [hdbase]
485	cld	485	cld
486	rep outsw	486	rep outsw
487	popfd	487	popfd
488		488
489	pop esi ecx	489	pop esi ecx
490	ret	490	ret
491	;-----------------------------------------------------------------------------	491	;-----------------------------------------------------------------------------
492	align 4	492	align 4
493	save_hd_wait_timeout:	493	save_hd_wait_timeout:
494	push eax	494	push eax
495	mov eax, [timer_ticks]	495	mov eax, [timer_ticks]
496	add eax, 300 ; 3 sec timeout	496	add eax, 300 ; 3 sec timeout
497	mov [hd_wait_timeout], eax	497	mov [hd_wait_timeout], eax
498	pop eax	498	pop eax
499	ret	499	ret
500	;-----------------------------------------------------------------------------	500	;-----------------------------------------------------------------------------

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/hd_drv.inc – Rev 4578 → 4624