Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 5570 $

; HDD driver

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

hd4_data        HD_DATA         ?,    0, 5

hd5_data        HD_DATA         ?, 0x10, 6

hd6_data        HD_DATA         ?,    0, 7

hd7_data        HD_DATA         ?, 0x10, 8

hd8_data        HD_DATA         ?,    0, 9

hd9_data        HD_DATA         ?, 0x10, 10

hd10_data       HD_DATA         ?,    0, 11

hd11_data       HD_DATA         ?, 0x10, 12

ide_mutex_table:

        dd ide_channel1_mutex

        dd ide_channel2_mutex

        dd ide_channel3_mutex

        dd ide_channel4_mutex

        dd ide_channel5_mutex

        dd ide_channel6_mutex

endg

;-----------------------------------------------------------------

uglobal

ide_mutex               MUTEX

ide_channel1_mutex      MUTEX

ide_channel2_mutex      MUTEX

ide_channel3_mutex      MUTEX

ide_channel4_mutex      MUTEX

ide_channel5_mutex      MUTEX

ide_channel6_mutex      MUTEX

blockSize:

rb 4

sector:

rb 6

allow_dma_access        db ?

IDE_common_irq_param    db ?

eventPointer            dd ?

eventID                 dd ?

endg

;-----------------------------------------------------------------

ide_read:

        mov     al, 25h     ; READ DMA EXT

        jmp     ide_read_write

ide_write:

        mov     al, 35h     ; WRITE DMA EXT

; fall through to ide_read_write

proc ide_read_write stdcall uses esi edi ebx, \

        hd_data, buffer, startsector:qword, numsectors

        ; hd_data = pointer to hd*_data

        ; buffer = pointer to buffer with/for data

        ; startsector = 64-bit start sector

        ; numsectors = pointer to number of sectors on input,

        ;  must be filled with number of sectors really read/written

locals

sectors_todo    dd      ?

channel_lock    dd      ?

operation       db      ?

endl

        mov     [operation], al

; 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

; acquire the global lock

        mov     ecx, ide_mutex

        call    mutex_lock

        mov     ecx, [hd_data]

        mov     ecx, [ecx+HD_DATA.hdpos]

        dec     ecx

        shr     ecx, 1

        shl     ecx, 2

        mov     ecx, [ecx + ide_mutex_table]

        mov     [channel_lock], ecx

        call    mutex_lock

; prepare worker procedures variables

        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     [sector], eax

        mov     ax, word [startsector+4]

        mov     [sector+4], ax

        mov     esi, [buffer]

        mov     edi, esi

        mov     bl, [operation]

        mov     ecx, [hdpos]

        dec     ecx

        shr     ecx, 2

        imul    ecx, sizeof.IDE_DATA

        add     ecx, IDE_controller_1

        mov     [IDE_controller_pointer], ecx

        mov     eax, [hdpos]

        dec     eax

        and     eax, 11b

        shr     eax, 1

        add     eax, ecx

        cmp     [eax+IDE_DATA.dma_hdd_channel_1], 1

        jz      .next

        dec     ebx     ; READ/WRITE SECTOR(S) EXT

; worker procedures take max 8000h sectors per time

; loop until all sectors will be processed

.next:

        mov     ecx, 8000h

        cmp     ecx, [sectors_todo]

        jbe     @f

        mov     ecx, [sectors_todo]

@@:

        mov     [blockSize], ecx

        push    ecx

        call    IDE_transfer

        pop     ecx

        jc      .out

        mov     eax, [numsectors]

        add     [eax], ecx

        sub     [sectors_todo], ecx

        jz      .out

        add     [sector], ecx

        adc     word [sector+4], 0

        jmp     .next

; loop is done, either due to error or because everything is done

; release the global lock and return the corresponding status

.out:

        sbb     eax, eax

        push    eax

        mov     ecx, [channel_lock]

        call    mutex_unlock

        mov     ecx, ide_mutex

        call    mutex_unlock

        pop     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

;-----------------------------------------------------------------

; input: esi -> buffer, bl = command, [sector], [blockSize]

; output: esi -> next block in buffer

; for pio read esi equal edi

IDE_transfer:

        mov     edx, [hdbase]

        add     edx, 6

        mov     al, byte [hdid]

        add     al, 224

        out     dx, al  ; select the desired drive

        call    save_hd_wait_timeout

        inc     edx

@@:

        call    check_hd_wait_timeout

        jc      .hd_error

        in      al, dx

        test    al, 128 ; ready for command?

        jnz     @b

        pushfd          ; fill the ports

        cli

        mov     edx, [hdbase]

        inc     edx

        inc     edx

        mov     al, [blockSize+1]

        out     dx, al  ; Sector count (15:8)

        inc     edx

        mov     eax, [sector+3]

        out     dx, al  ; LBA (31:24)

        inc     edx

        shr     eax, 8

        out     dx, al  ; LBA (39:32)

        inc     edx

        shr     eax, 8

        out     dx, al  ; LBA (47:40)

        sub     edx, 3

        mov     al, [blockSize]

        out     dx, al  ; Sector count (7:0)

        inc     edx

        mov     eax, [sector]

        out     dx, al  ; LBA (7:0)

        inc     edx

        shr     eax, 8

        out     dx, al  ; LBA (15:8)

        inc     edx

        shr     eax, 8

        out     dx, al  ; LBA (23:16)

        inc     edx

        mov     al, byte [hdid]

        add     al, 224

        out     dx, al

        test    bl, 1

        jz      .PIO

; DMA

        mov     dword [esp], 0x1000

        call    kernel_alloc

        mov     edi, eax

        push    eax

        shl     dword [blockSize], 9

        mov     eax, esi

        add     eax, [blockSize]

        push    eax

; check buffer pages physical addresses and fill the scatter-gather list

; buffer may be not aligned and may have size not divisible by page size

; [edi] = block physical address, [edi+4] = block size in bytes

; block addresses can not cross 10000h borders

        mov     ecx, esi

        and     ecx, 0xFFF

        jz      .aligned

        mov     eax, esi

        call    get_pg_addr

        add     eax, ecx

        neg     ecx

        add     ecx, 0x1000

        mov     [edi], eax

        cmp     ecx, [blockSize]

        jnc     .end

        mov     [edi+4], ecx

        add     esi, 0x1000

        add     edi, 8

        sub     [blockSize], ecx

.aligned:

        mov     eax, esi

        call    get_pg_addr

        mov     ecx, eax

        mov     [edi], eax

        and     ecx, 0xFFFF

        neg     ecx

        add     ecx, 0x10000

        cmp     [blockSize], ecx

        jnc     @f

        mov     ecx, [blockSize]

        and     ecx, 0xF000

        jz      .end

@@:

        push    ecx

@@:

        add     esi, 0x1000

        add     eax, 0x1000

        sub     ecx, 0x1000

        jz      @f

        mov     edx, eax

        mov     eax, esi

        call    get_pg_addr

        cmp     eax, edx

        jz      @b

@@:

        pop     edx

        sub     edx, ecx

        mov     [edi+4], edx

        add     edi, 8

        sub     [blockSize], edx

        jnz     .aligned

        sub     edi, 8

        jmp     @f

.end:

        mov     ecx, [blockSize]

        mov     [edi+4], ecx

@@:

        mov     byte [edi+7], 80h   ; list end

        pop     esi

        pop     edi

; select controller Primary or Secondary

        mov     ecx, [IDE_controller_pointer]

        mov     dx, [ecx+IDE_DATA.RegsBaseAddres]

        mov     eax, [hdpos]

        dec     eax

        test    eax, 10b

        jz      @f

        add     edx, 8

@@:

        add     edx, 2      ; Bus Master IDE Status register

        mov     al, 6

        out     dx, al      ; clear Error bit and Interrupt bit

        add     edx, 2      ; Bus Master IDE PRD Table Address

        mov     eax, edi

        call    get_pg_addr

        out     dx, eax     ; send scatter-gather list physical address

        push    edx

        mov     edx, [hdbase]

        add     edx, 7      ; ATACommand

        mov     al, bl

        out     dx, al      ; Start hard drive

        pop     edx

        sub     edx, 4      ; Bus Master IDE Command register

        mov     al, 1       ; set direction

        cmp     bl, 35h     ; write

        jz      @f

        add     al, 8       ; read

@@:

        out     dx, al      ; Start Bus Master

        mov     [IDE_common_irq_param], 14

        mov     eax, [hdpos]

        dec     eax

        test    eax, 10b

        jz      @f

        inc     [IDE_common_irq_param]

@@:

        push    edi esi ebx

        xor     ecx, ecx

        xor     esi, esi

        call    create_event

        mov     [eventPointer], eax

        mov     [eventID], edx

        sti

        mov     ebx, edx

        mov     ecx, 300

        call    wait_event_timeout

        test    eax, eax

        jnz     @f

        mov     [IDE_common_irq_param], 0

        mov     eax, [eventPointer]

        mov     ebx, [eventID]

        call    destroy_event

        mov     [eventPointer], 0

@@:

        pop     ebx esi

        call    kernel_free

        cmp     [eventPointer], 0

        jz      .hd_error

        ret

.PIO:

        inc     edx     ; ATACommand

        mov     al, bl

        out     dx, al  ; Start hard drive

        popfd

.sectorTransfer:

        call    save_hd_wait_timeout

        in      al, dx

        in      al, dx

        in      al, dx

        in      al, dx

@@:

        call    check_hd_wait_timeout

        jc      .hd_error

        in      al, dx

        test    al, 8   ; ready for transfer?

        jz      @b

        cmp     [hd_setup], 1   ; do not mark error for setup request

        jz      @f

        test    al, 1   ; previous command ended up with an error

        jnz     .hd_error

@@:

        pushfd

        cli

        cld

        mov     ecx, 256

        mov     edx, [hdbase]

        cmp     bl, 34h

        jz      .write

        rep insw

        jmp     @f

.write:

        rep outsw

@@:

        popfd

        add     edx, 7

        dec     dword [blockSize]

        jnz     .sectorTransfer

        ret

.hd_error:

        cmp     bl, 30h

        jnc     hd_write_error

;-----------------------------------------------------------------

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

        stc

        ret

;-----------------------------------------------------------------

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

        stc

        ret

;-----------------------------------------------------------------

save_hd_wait_timeout:

        mov     eax, [timer_ticks]

        add     eax, 300        ; 3 sec timeout

        mov     [hd_wait_timeout], eax

        ret

;-----------------------------------------------------------------

check_hd_wait_timeout:

        mov     eax, [timer_ticks]

        cmp     [hd_wait_timeout], eax

        jc      @f

        ret

@@:

        if lang eq sp

        DEBUGF 1,"K : FS - HD tiempo de espera agotado\n"

        else

        DEBUGF 1,"K : FS - HD timeout\n"

        end if

        stc

        ret

;-----------------------------------------------------------------

align 4

IDE_irq_14_handler:

IDE_irq_15_handler:

IDE_common_irq_handler:

; DEBUGF  1, 'K : IDE_irq_handler %x\n', [IDE_common_irq_param]:2

        cmp     [IDE_common_irq_param], 0

        jz      .exit

        pushfd

        cli

        pushad

        mov     ecx, [IDE_controller_pointer]

        mov     dx, [ecx+IDE_DATA.RegsBaseAddres]

        cmp     [IDE_common_irq_param], 14

        jz      @f

        add     dx, 8

@@:

        add     edx, 2  ; Bus Master IDE Status register

        in      al, dx

        test    al, 4

        jz      @f

        mov     [IDE_common_irq_param], 0

        out     dx, al  ; clear Interrupt bit

        sub     edx, 2

        xor     eax, eax

        out     dx, al  ; clear Bus Master IDE Command register

        mov     edx, [hdbase]

        add     edx, 7

        in      al, dx  ; read status register

        mov     eax, [eventPointer]

        mov     ebx, [eventID]

        xor     edx, edx

        xor     esi, esi

        call    raise_event

        popad

        popfd

        mov     al, 1   ; remove the interrupt request

        ret

@@:

        popad

        popfd

.exit:

        xor     eax, eax    ; not our interrupt

        ret

;-----------------------------------------------------------------

proc clear_pci_ide_interrupts

        mov     esi, pcidev_list

align 4

.loop:

        mov     esi, [esi+PCIDEV.fd]

        cmp     esi, pcidev_list

        jz      .done

;        cmp     [esi+PCIDEV.class], 0x01018F

        mov     eax, [esi+PCIDEV.class]

        shr     eax, 4

        cmp     eax, 0x01018

        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