WebSVN – Kolibri OS – Diff – /drivers/unfinished/ensoniq.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;alpha version
 
format MS COFF
 
DEBUG       equ 1
 
 
include 'proc32.inc'
include 'imports.inc'
 
REMAP_IRQ   equ 0
 
;irq 0,13 unavailable
;               FEDCBA9876543210
 
VALID_IRQ   equ 1101111111111110b
 
IRQ_LINE    equ 0
 
CPU_FREQ    equ  2600d
 
BIT0  EQU 0x00000001
BIT1  EQU 0x00000002
BIT2  EQU 0x00000004
BIT3  EQU 0x00000008
BIT4  EQU 0x00000010
BIT5  EQU 0x00000020
BIT6  EQU 0x00000040
BIT7  EQU 0x00000080
BIT8  EQU 0x00000100
BIT9  EQU 0x00000200
BIT10 EQU 0x00000400
BIT11 EQU 0x00000800
BIT12 EQU 0x00001000
BIT13 EQU 0x00002000
BIT14 EQU 0x00004000
BIT15 EQU 0x00008000
BIT16 EQU 0x00010000
BIT17 EQU 0x00020000
BIT18 EQU 0x00040000
BIT19 EQU 0x00080000
BIT20 EQU 0x00100000
BIT21 EQU 0x00200000
BIT22 EQU 0x00400000
BIT23 EQU 0x00800000
BIT24 EQU 0x00100000
BIT25 EQU 0x02000000
BIT26 EQU 0x04000000
BIT27 EQU 0x08000000
BIT28 EQU 0x10000000
BIT29 EQU 0x20000000
BIT30 EQU 0x40000000
BIT31 EQU 0x80000000
 
 
PCM_OUT_BDL       equ  0x10      ; PCM out buffer descriptors list
PCM_OUT_CR_REG    equ  0x1b      ; PCM out Control Register
PCM_OUT_LVI_REG   equ  0x15      ; PCM last valid index
PCM_OUT_SR_REG    equ  0x16      ; PCM out Status register
PCM_OUT_PIV_REG   equ  0x1a
PCM_OUT_CIV_REG   equ  0x14      ; PCM out current index
 
PCM_IN_CR_REG     equ  0x0b      ; PCM in Control Register
MC_IN_CR_REG      equ  0x2b      ; MIC in Control Register
RR                equ  BIT1      ; reset registers.  Nukes all regs
 
CODEC_MASTER_VOL_REG            equ     0x02
CODEC_AUX_VOL                   equ     0x04    ;
CODEC_PCM_OUT_REG               equ     18h     ; PCM output volume
CODEC_EXT_AUDIO_REG             equ     28h     ; extended audio
CODEC_EXT_AUDIO_CTRL_REG        equ     2ah     ; extended audio control
CODEC_PCM_FRONT_DACRATE_REG     equ     2ch     ; PCM out sample rate
CODEC_PCM_SURND_DACRATE_REG     equ     2eh     ; surround sound sample rate
CODEC_PCM_LFE_DACRATE_REG       equ     30h     ; LFE sample rate
 
GLOB_CTRL      equ  0x2C        ;   Global Control
CTRL_STAT       equ  0x30        ;   Global Status
CTRL_CAS        equ  0x34        ;   Codec Access Semiphore
 
CAS_FLAG        equ  0x01        ;   Codec Access Semiphore Bit
 
CTRL_ST_CREADY  equ  BIT8+BIT9+BIT28 ;   Primary Codec Ready
 
CTRL_ST_RCS     equ  0x00008000  ;   Read Completion Status
 
CTRL_CNT_CRIE   equ  BIT4+BIT5+BIT6  ;   Codecs Resume Interrupt Enable
CTRL_CNT_AC_OFF equ  0x00000008  ;   ACLINK Off
CTRL_CNT_WARM   equ  0x00000004  ;   AC97 Warm Reset
CTRL_CNT_COLD   equ  0x00000002  ;   AC97 Cold Reset
CTRL_CNT_GIE    equ  0x00000001  ;   GPI Interrupt Enable
 
CODEC_REG_POWERDOWN   equ 0x26
CODEC_REG_ST          equ 0x26
 
DEV_PLAY              equ  1
DEV_STOP              equ  2
DEV_CALLBACK          equ  3
DEV_SET_BUFF          equ  4
DEV_NOTIFY            equ  5
DEV_SET_MASTERVOL     equ  6
DEV_GET_MASTERVOL     equ  7
DEV_GET_INFO          equ  8
 
struc AC_CNTRL              ;AC controller base class
{ .bus                dd ?
  .devfn              dd ?
 
  .vendor             dd ?
  .dev_id             dd ?
  .pci_cmd            dd ?
  .pci_stat           dd ?
 
  .codec_io_base      dd ?
  .codec_mem_base     dd ?
 
  .ctrl_io_base       dd ?
  .ctrl_mem_base      dd ?
  .cfg_reg            dd ?
  .int_line           dd ?
 
  .vendor_ids         dd ?    ;vendor id string
  .ctrl_ids           dd ?    ;hub id string
 
  .buffer             dd ?
 
  .notify_pos         dd ?
  .notify_task        dd ?
 
  .lvi_reg            dd ?
  .ctrl_setup         dd ?
  .user_callback      dd ?
  .codec_read16       dd ?
  .codec_write16      dd ?
 
  .ctrl_read8         dd ?
  .ctrl_read16        dd ?
  .ctrl_read32        dd ?
 
  .ctrl_write8        dd ?
  .ctrl_write16       dd ?
  .ctrl_write32       dd ?
}
 
struc CODEC                ;Audio Chip base class
{
  .chip_id            dd ?
  .flags              dd ?
  .status             dd ?
 
  .ac_vendor_ids      dd ?    ;ac vendor id string
  .chip_ids           dd ?    ;chip model string
 
  .shadow_flag        dd ?
                      dd ?
 
  .regs               dw ?     ; codec registers
  .reg_master_vol     dw ?     ;0x02
  .reg_aux_out_vol    dw ?     ;0x04
  .reg_mone_vol       dw ?     ;0x06
  .reg_master_tone    dw ?     ;0x08
  .reg_beep_vol       dw ?     ;0x0A
  .reg_phone_vol      dw ?     ;0x0C
  .reg_mic_vol        dw ?     ;0x0E
  .reg_line_in_vol    dw ?     ;0x10
  .reg_cd_vol         dw ?     ;0x12
  .reg_video_vol      dw ?     ;0x14
  .reg_aux_in_vol     dw ?     ;0x16
  .reg_pcm_out_vol    dw ?     ;0x18
  .reg_rec_select     dw ?     ;0x1A
  .reg_rec_gain       dw ?     ;0x1C
  .reg_rec_gain_mic   dw ?     ;0x1E
  .reg_gen            dw ?     ;0x20
  .reg_3d_ctrl        dw ?     ;0X22
  .reg_page           dw ?     ;0X24
  .reg_powerdown      dw ?     ;0x26
  .reg_ext_audio      dw ?     ;0x28
  .reg_ext_st         dw ?     ;0x2a
  .reg_pcm_front_rate dw ?     ;0x2c
  .reg_pcm_surr_rate  dw ?     ;0x2e
  .reg_lfe_rate       dw ?     ;0x30
  .reg_pcm_in_rate    dw ?     ;0x32
                      dw ?     ;0x34
  .reg_cent_lfe_vol   dw ?     ;0x36
  .reg_surr_vol       dw ?     ;0x38
  .reg_spdif_ctrl     dw ?     ;0x3A
                      dw ?     ;0x3C
                      dw ?     ;0x3E
                      dw ?     ;0x40
                      dw ?     ;0x42
                      dw ?     ;0x44
                      dw ?     ;0x46
                      dw ?     ;0x48
                      dw ?     ;0x4A
                      dw ?     ;0x4C
                      dw ?     ;0x4E
                      dw ?     ;0x50
                      dw ?     ;0x52
                      dw ?     ;0x54
                      dw ?     ;0x56
                      dw ?     ;0x58
                      dw ?     ;0x5A
                      dw ?     ;0x5C
                      dw ?     ;0x5E
  .reg_page_0         dw ?     ;0x60
  .reg_page_1         dw ?     ;0x62
  .reg_page_2         dw ?     ;0x64
  .reg_page_3         dw ?     ;0x66
  .reg_page_4         dw ?     ;0x68
  .reg_page_5         dw ?     ;0x6A
  .reg_page_6         dw ?     ;0x6C
  .reg_page_7         dw ?     ;0x6E
                      dw ?     ;0x70
                      dw ?     ;0x72
                      dw ?     ;0x74
                      dw ?     ;0x76
                      dw ?     ;0x78
                      dw ?     ;0x7A
  .reg_vendor_id_1    dw ?     ;0x7C
  .reg_vendor_id_2    dw ?     ;0x7E
 
 
  .reset              dd ?    ;virual
  .set_master_vol     dd ?
}
 
struc CTRL_INFO
{   .pci_cmd        dd  ?
    .irq            dd  ?
    .glob_cntrl     dd  ?
    .glob_sta       dd  ?
    .codec_io_base  dd  ?
    .ctrl_io_base   dd  ?
    .codec_mem_base dd  ?
    .ctrl_mem_base  dd  ?
    .codec_id       dd  ?
}
 
struc IOCTL
{  .handle           dd ?
   .io_code          dd ?
   .input            dd ?
   .inp_size         dd ?
   .output           dd ?
   .out_size         dd ?
}
 
virtual at 0
  IOCTL IOCTL
end virtual
 
EVENT_NOTIFY          equ 0x00000200
 
OS_BASE         equ 0x80000000
SLOT_BASE       equ OS_BASE+0x0080000
new_app_base    equ 0
 
public START
public service_proc
public version
 
section '.flat' code readable align 16
 
proc START stdcall, state:dword
 
        cmp     [state], 1
        jne     .stop
 
     if DEBUG
        mov     esi, msgDetect
        call    SysMsgBoardStr
     end if
 
        call    detect_controller
        test    eax, eax
        jz      .fail
 
     if DEBUG
        mov     esi, [ctrl.vendor_ids]
        call    SysMsgBoardStr
        mov     esi, [ctrl.ctrl_ids]
        call    SysMsgBoardStr
 
     end if
        call    init_controller
        test    eax, eax
        jz      .fail
 
        jmp     .fail     ;force fail
 
     if DEBUG
        mov     esi, msgInitCodec
        call    SysMsgBoardStr
     end if
 
        call    init_codec
        test    eax, eax
        jz      .fail
 
     if DEBUG
        mov     esi, [codec.ac_vendor_ids]
        call    SysMsgBoardStr
 
        mov     esi, [codec.chip_ids]
        call    SysMsgBoardStr
     end if
 
        call    reset_controller
        call    setup_codec
 
        mov     esi, msgPrimBuff
        call    SysMsgBoardStr
 
        call    create_primary_buff
 
        mov     eax, VALID_IRQ
        mov     ebx, [ctrl.int_line]
        mov     esi, msgInvIRQ
        bt      eax, ebx
        jnc     .fail
 
 
 
 
 
        stdcall AttachIntHandler, ebx, ac97_irq, dword 0
        stdcall RegService, sz_sound_srv, service_proc
        ret
.fail:
     if DEBUG
        mov     esi, msgFail
        call    SysMsgBoardStr
     end if
        xor     eax, eax
        ret
.stop:
        call    stop
        xor     eax, eax
        ret
endp
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
align 4
proc service_proc stdcall, ioctl:dword
 
        mov     edi, [ioctl]
        mov     eax, [edi+io_code]
        cmp     eax, DEV_PLAY
        jne     @F
     if DEBUG
        mov     esi, msgPlay
        call    SysMsgBoardStr
     end if
        call    play
        ret
@@:
        cmp     eax, DEV_STOP
        jne     @F
     if DEBUG
        mov     esi, msgStop
        call    SysMsgBoardStr
     end if
        call    stop
        ret
@@:
        cmp     eax, DEV_CALLBACK
        jne     @F
        mov     ebx, [edi+input]
        stdcall set_callback, [ebx]
        ret
@@:
        cmp     eax, DEV_SET_MASTERVOL
        jne     @F
        mov     eax, [edi+input]
        mov     eax, [eax]
        call    set_master_vol      ;eax= vol
        ret
@@:
        cmp     eax, DEV_GET_MASTERVOL
        jne     @F
        mov     ebx, [edi+output]
        stdcall get_master_vol, ebx
        ret
;@@:
;           cmp eax, DEV_GET_INFO
;           jne @F
;           mov ebx, [edi+output]
;           stdcall get_dev_info, ebx
;           ret
@@:
.fail:
        or      eax, -1
        ret
endp
 
restore   handle
restore   io_code
restore   input
restore   inp_size
restore   output
restore   out_size
 
 
align 4
proc ac97_irq
 
;     if DEBUG
;           mov esi, msgIRQ
;           call SysMsgBoardStr
;     end if
 
 
        cmp     [ctrl.user_callback], 0
        je      @f
 
        stdcall [ctrl.user_callback], ebx
@@:
        ret
 
.skip:
        mov     edx, PCM_OUT_CR_REG
        mov     ax, 0x11              ;0x1D
        call    [ctrl.ctrl_write8]
        ret
endp
 
align 4
proc create_primary_buff
 
        stdcall KernelAlloc, 0x10000
        mov     [ctrl.buffer], eax
 
        mov     edi, eax
        mov     ecx, 0x10000/4
        xor     eax, eax
        cld
        rep stosd
 
        mov     eax, [ctrl.buffer]
        call    GetPgAddr
 
        mov     ebx, 0xC0002000
        mov     ecx, 4
        mov     edi, pcmout_bdl
@@:
        mov     [edi], eax
        mov     [edi+4], ebx
 
        mov     [edi+32], eax
        mov     [edi+4+32], ebx
 
        mov     [edi+64], eax
        mov     [edi+4+64], ebx
 
        mov     [edi+96], eax
        mov     [edi+4+96], ebx
 
        mov     [edi+128], eax
        mov     [edi+4+128], ebx
 
        mov     [edi+160], eax
        mov     [edi+4+160], ebx
 
        mov     [edi+192], eax
        mov     [edi+4+192], ebx
 
        mov     [edi+224], eax
        mov     [edi+4+224], ebx
 
        add     eax, 0x4000
        add     edi, 8
        loop    @B
 
        mov     edi, buff_list
        mov     eax, [ctrl.buffer]
        mov     ecx, 4
@@:
        mov     [edi], eax
        mov     [edi+16], eax
        mov     [edi+32], eax
        mov     [edi+48], eax
        mov     [edi+64], eax
        mov     [edi+80], eax
        mov     [edi+96], eax
        mov     [edi+112], eax
 
        add     eax, 0x4000
        add     edi, 4
        loop    @B
 
        mov     eax, pcmout_bdl
        mov     ebx, eax
        call    GetPgAddr     ;eax
        and     ebx, 0xFFF
        add     eax, ebx
 
        mov     edx, PCM_OUT_BDL
        call    [ctrl.ctrl_write32]
 
        mov     eax, 16
        mov     [ctrl.lvi_reg], eax
        mov     edx, PCM_OUT_LVI_REG
        call    [ctrl.ctrl_write8]
        ret
endp
 
align 4
proc detect_controller
         locals
           last_bus dd ?
           bus      dd ?
           devfn    dd ?
         endl
 
        xor     eax, eax
        mov     [bus], eax
        inc     eax
        call    PciApi
        cmp     eax, -1
        je      .err
 
        mov     [last_bus], eax
 
.next_bus:
        and     [devfn], 0
.next_dev:
        stdcall PciRead32, [bus], [devfn], dword 0
        test    eax, eax
        jz      .next
        cmp     eax, -1
        je      .next
 
        mov     edi, devices
@@:
        mov     ebx, [edi]
        test    ebx, ebx
        jz      .next
 
        cmp     eax, ebx
        je      .found
        add     edi, 12
        jmp     @B
 
.next:
        inc     [devfn]
        cmp     [devfn], 256
        jb      .next_dev
        mov     eax, [bus]
        inc     eax
        mov     [bus], eax
        cmp     eax, [last_bus]
        jna     .next_bus
        xor     eax, eax
        ret
.found:
        mov     ebx, [bus]
        mov     [ctrl.bus], ebx
 
        mov     ecx, [devfn]
        mov     [ctrl.devfn], ecx
 
        mov     edx, eax
        and     edx, 0xFFFF
        mov     [ctrl.vendor], edx
        shr     eax, 16
        mov     [ctrl.dev_id], eax
 
        mov     ebx, [edi+4]
        mov     [ctrl.ctrl_ids], ebx
        mov     esi, [edi+8]
        mov     [ctrl.ctrl_setup], esi
 
        cmp     ebx, 0x1274
        jne     @F
        mov     [ctrl.vendor_ids], msgEnsoniq
        ret
@@:
        mov     [ctrl.vendor_ids], 0    ;something  wrong ?
        ret
.err:
        xor     eax, eax
        ret
endp
 
align 4
proc init_controller
 
        mov     esi, msgPCIcmd
        call    SysMsgBoardStr
 
        stdcall PciRead32, [ctrl.bus], [ctrl.devfn], dword 4
        mov     ebx, eax
        and     eax, 0xFFFF
        mov     [ctrl.pci_cmd], eax
        shr     ebx, 16
        mov     [ctrl.pci_stat], ebx
 
        call    dword2str
        call    SysMsgBoardStr
 
        mov     esi, msgIObase
        call    SysMsgBoardStr
 
        stdcall PciRead32, [ctrl.bus], [ctrl.devfn], dword 0x10
;           and eax, -16
        mov     [ctrl.ctrl_io_base], eax
 
        call    dword2str
        call    SysMsgBoardStr
 
        mov     esi, msgIRQline
        call    SysMsgBoardStr
 
        stdcall PciRead32, [ctrl.bus], [ctrl.devfn], dword 0x3C
        and     eax, 0xFF
        mov     [ctrl.int_line], eax
 
        call    dword2str
        call    SysMsgBoardStr
 
        call    [ctrl.ctrl_setup]
        xor     eax, eax
        inc     eax
        ret
endp
 
align 4
proc set_ICH
        mov     [ctrl.codec_read16], codec_io_r16    ;virtual
        mov     [ctrl.codec_write16], codec_io_w16   ;virtual
 
        mov     [ctrl.ctrl_read8 ], ctrl_io_r8      ;virtual
        mov     [ctrl.ctrl_read16], ctrl_io_r16      ;virtual
        mov     [ctrl.ctrl_read32], ctrl_io_r32      ;virtual
 
        mov     [ctrl.ctrl_write8 ], ctrl_io_w8     ;virtual
        mov     [ctrl.ctrl_write16], ctrl_io_w16     ;virtual
        mov     [ctrl.ctrl_write32], ctrl_io_w32     ;virtual
        ret
endp
 
align 4
proc reset_controller
 
        xor     eax, eax
        mov     edx, PCM_IN_CR_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, PCM_OUT_CR_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, MC_IN_CR_REG
        call    [ctrl.ctrl_write8]
 
        mov     eax, RR
        mov     edx, PCM_IN_CR_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, PCM_OUT_CR_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, MC_IN_CR_REG
        call    [ctrl.ctrl_write8]
        ret
endp
 
align 4
proc init_codec
         locals
           counter dd ?
         endl
 
        mov     esi, msgControl
        call    SysMsgBoardStr
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        call    dword2str
        call    SysMsgBoardStr
 
        mov     esi, msgStatus
        call    SysMsgBoardStr
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
 
        call    dword2str
        call    SysMsgBoardStr
 
        test    eax, CTRL_ST_CREADY
        jnz     .ready
 
        call    reset_codec
        and     eax, eax
        jz      .err
 
        xor     edx, edx    ;ac_reg_0
        call    [ctrl.codec_write16]
 
        xor     eax, eax
        mov     edx, CODEC_REG_POWERDOWN
        call    [ctrl.codec_write16]
 
        mov     [counter], 200    ; total 200*5 ms = 1s
.wait:
        mov     edx, CODEC_REG_POWERDOWN
        call    [ctrl.codec_read16]
        and     eax, 0x0F
        cmp     eax, 0x0F
        jz      .ready
 
        mov     eax, 5000  ; wait 5 ms
        call    StallExec
        sub     [counter] , 1
        jnz     .wait
.err:
        xor     eax, eax       ; timeout error
        ret
.ready:
        call    detect_codec
 
        xor     eax, eax
        inc     eax
        ret
endp
 
align 4
proc reset_codec
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
 
        test    eax, 0x02
        jz      .cold
 
        call    warm_reset
        jnc     .ok
.cold:
        call    cold_reset
        jnc     .ok
 
     if DEBUG
        mov     esi, msgCFail
        call    SysMsgBoardStr
     end if
        xor     eax, eax    ; timeout error
        ret
.ok:
     if DEBUG
        mov     esi, msgResetOk
        call    SysMsgBoardStr
     end if
 
        xor     eax, eax
        inc     eax
        ret
endp
 
align 4
proc warm_reset
           locals
             counter dd ?
           endl
 
        mov     eax, 0x06
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
 
     if DEBUG
        mov     esi, msgWarm
        call    SysMsgBoardStr
     end if
 
        mov     [counter], 10      ; total 10*100 ms = 1s
.wait:
        mov     eax, 100000        ; wait 100 ms
        call    StallExec
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        test    eax, 4
        jz      .ok
        sub     [counter], 1
        jnz     .wait
 
     if DEBUG
        mov     esi, msgWRFail
        call    SysMsgBoardStr
     end if
 
        stc
        ret
.ok:
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        and     eax, CTRL_ST_CREADY
        jz      .fail
        clc
        ret
.fail:
        stc
        ret
endp
 
align 4
proc cold_reset
           locals
             counter dd ?
           endl
 
        xor     eax, eax
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
 
     if DEBUG
        mov     esi, msgCold
        call    SysMsgBoardStr
     end if
 
        mov     eax, 1000000       ; wait 1 s
        call    StallExec
 
        mov     eax, 2
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
 
        mov     [counter], 10      ; total 10*100 ms = 1s
.wait:
        mov     eax, 100000        ; wait 100 ms
        call    StallExec
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        test    eax, 4
        jz      .ok
        sub     [counter], 1
        jnz     .wait
 
     if DEBUG
        mov     esi, msgCRFail
        call    SysMsgBoardStr
     end if
        stc
        ret
.ok:
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        and     eax, CTRL_ST_CREADY
        jz      .fail
        clc
        ret
.fail:
        stc
        ret
endp
 
align 4
play:
        mov     eax, 16
        mov     [ctrl.lvi_reg], eax
        mov     edx, PCM_OUT_LVI_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, PCM_OUT_CR_REG
        mov     ax, 0x1D
        call    [ctrl.ctrl_write8]
        xor     eax, eax
        ret
 
align 4
stop:
        mov     edx, PCM_OUT_CR_REG
        mov     ax, 0x0
        call    [ctrl.ctrl_write8]
 
        mov     ax, 0x1c
        mov     edx, PCM_OUT_SR_REG
        call    [ctrl.ctrl_write16]
        xor     eax, eax
        ret
 
align 4
proc get_dev_info stdcall, p_info:dword
           virtual at esi
             CTRL_INFO CTRL_INFO
           end virtual
 
        mov     esi, [p_info]
        mov     eax, [ctrl.int_line]
        mov     ebx, [ctrl.codec_io_base]
        mov     ecx, [ctrl.ctrl_io_base]
        mov     edx, [ctrl.codec_mem_base]
        mov     edi, [ctrl.ctrl_mem_base]
 
        mov     [CTRL_INFO.irq], eax
        mov     [CTRL_INFO.codec_io_base], ebx
        mov     [CTRL_INFO.ctrl_io_base], ecx
        mov     [CTRL_INFO.codec_mem_base], edx
        mov     [CTRL_INFO.ctrl_mem_base], edi
 
        mov     eax, [codec.chip_id]
        mov     [CTRL_INFO.codec_id], eax
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        mov     [CTRL_INFO.glob_cntrl], eax
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        mov     [CTRL_INFO.glob_sta], eax
 
        mov     ebx, [ctrl.pci_cmd]
        mov     [CTRL_INFO.pci_cmd], ebx
        ret
endp
 
align 4
proc set_callback stdcall, handler:dword
        mov     eax, [handler]
        mov     [ctrl.user_callback], eax
        ret
endp
 
align 4
proc codec_read stdcall, ac_reg:dword      ; reg = edx, reval = eax
 
        mov     edx, [ac_reg]
 
        mov     ebx, edx
        shr     ebx, 1
        bt      [codec.shadow_flag], ebx
        jc      .use_shadow
 
        call    [ctrl.codec_read16]  ;change edx !!!
        mov     ecx, eax
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        test    eax, CTRL_ST_RCS
        jz      .read_ok
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_write32]
        xor     eax, eax
        not     eax             ;timeout
        ret
.read_ok:
        mov     edx, [ac_reg]
        mov     [codec.regs+edx], cx
        bts     [codec.shadow_flag], ebx
        mov     eax, ecx
        ret
.use_shadow:
        movzx   eax, word [codec.regs+edx]
        ret
endp
 
align 4
proc codec_write stdcall, ac_reg:dword
        push    eax
        call    check_semafore
        and     eax, eax
        jz      .err
        pop     eax
 
        mov     esi, [ac_reg]
        mov     edx, esi
        call    [ctrl.codec_write16]
        mov     [codec.regs+esi], ax
        shr     esi, 1
        bts     [codec.shadow_flag], esi
        ret
.err:
        pop     eax
        ret
endp
 
align 4
proc codec_check_ready
 
        mov     edx, CTRL_ST
        call    [ctrl.ctrl_read32]
        and     eax, CTRL_ST_CREADY
        jz      .not_ready
 
        xor     eax, wax
        inc     eax
        ret
.not_ready:
        xor     eax, eax
        ret
endp
 
align 4
proc check_semafore
           local counter:DWORD
 
        mov     [counter], 100
.l1:
        mov     edx, CTRL_CAS
        call    [ctrl.ctrl_read8]
        and     eax, CAS_FLAG
        jz      .ok
 
        mov     eax, 1
        call    StallExec
        sub     [counter], 1
        jnz     .l1
        xor     eax, eax
        ret
align 4
.ok:
        xor     eax, eax
        inc     eax
        ret
endp
 
align 4
proc StallExec
        push    ecx
        push    edx
        push    ebx
        push    eax
 
        mov     ecx, CPU_FREQ
        mul     ecx
        mov     ebx, eax      ;low
        mov     ecx, edx      ;high
        rdtsc
        add     ebx, eax
        adc     ecx, edx
@@:
        rdtsc
        sub     eax, ebx
        sbb     edx, ecx
        js      @B
 
        pop     eax
        pop     ebx
        pop     edx
        pop     ecx
        ret
endp
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;          CONTROLLER IO functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
codec_io_r16:
        add     edx, [ctrl.codec_io_base]
        in      ax, dx
        ret
 
align 4
codec_io_w16:
        add     edx, [ctrl.codec_io_base]
        out     dx, ax
        ret
 
align 4
ctrl_io_r8:
        add     edx, [ctrl.ctrl_io_base]
        in      al, dx
        ret
 
align 4
ctrl_io_r16:
        add     edx, [ctrl.ctrl_io_base]
        in      ax, dx
        ret
 
align 4
ctrl_io_r32:
        add     edx, [ctrl.ctrl_io_base]
        in      eax, dx
        ret
 
align 4
ctrl_io_w8:
        add     edx, [ctrl.ctrl_io_base]
        out     dx, al
        ret
 
align 4
ctrl_io_w16:
        add     edx, [ctrl.ctrl_io_base]
        out     dx, ax
        ret
 
align 4
ctrl_io_w32:
        add     edx, [ctrl.ctrl_io_base]
        out     dx, eax
        ret
 
 
align 4
dword2str:
        mov     esi, hex_buff
        mov     ecx, -8
@@:
        rol     eax, 4
        mov     ebx, eax
        and     ebx, 0x0F
        mov     bl, [ebx+hexletters]
        mov     [8+esi+ecx], bl
        inc     ecx
        jnz     @B
        ret
 
hexletters   db '0123456789ABCDEF'
hex_buff     db 8 dup(0),13,10,0
 
 
include "codec.inc"
 
align 4
devices dd (0x5000 shl 16)+0x1274,msgEnsoniq,set_ICH
        dd (0x5880 shl 16)+0x1274,msgVibra128,set_ICH
        dd 0    ;terminator
 
version      dd 0x00040004
 
msgEnsoniq   db 'Ensonic 1371',13,10,0
msgVibra128  db 'Sound Blaster AudioPCI Vibra 128',13,10,0
 
sz_sound_srv db 'SOUND',0
 
msgDetect    db 'detect hardware...',13,10,0
msgFail      db 'device not found',13,10,0
 
msgInvIRQ    db 'IRQ line not assigned or invalid', 13,10, 0
msgPlay      db 'start play', 13,10,0
msgStop      db 'stop play',  13,10,0
msgNotify    db 'call notify',13,10,0
msgIRQ       db 'AC97 IRQ', 13,10,0
msgInitCtrl  db 'init controller',13,10,0
msgInitCodec db 'init codec',13,10,0
msgPrimBuff  db 'create primary buffer',13,10,0
msgReg       db 'set service handler',13,10,0
msgOk        db 'service installed',13,10,0
msgCold      db 'cold reset',13,10,0
msgWarm      db 'warm reset',13,10,0
msgWRFail    db 'warm reset failed',13,10,0
msgCRFail    db 'cold reset failed',13,10,0
msgCFail     db 'codec not ready',13,10,0
msgResetOk   db 'reset complete',13,10,0
msgStatus    db 'global status   ',0
msgControl   db 'global control  ',0
msgPCIcmd    db 'PCI command     ',0
msgIObase    db 'IO base         ',0
msgIRQline   db 'IRQ line        ',0
 
section '.data' data readable writable align 16
 
pcmout_bdl       rq 32
buff_list        rd 32
 
codec CODEC
ctrl AC_CNTRL
 
lpc_bus  rd 1
civ_val  rd 1

Rev 5363	Rev 7585
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. 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	;alpha version	8	;alpha version
9		9
10	format MS COFF	10	format MS COFF
11		11
12	DEBUG equ 1	12	DEBUG equ 1
13		13
14		14
15	include 'proc32.inc'	15	include 'proc32.inc'
16	include 'imports.inc'	16	include 'imports.inc'
17		17
18	REMAP_IRQ equ 0	18	REMAP_IRQ equ 0
19		19
20	;irq 0,1,2,8,12,13 недоступны	20	;irq 0,13 unavailable
21	; FEDCBA9876543210	21	; FEDCBA9876543210
22	VALID_IRQ equ 1100111011111000b	-
23	ATTCH_IRQ equ 0000111010101000b	22	VALID_IRQ equ 1101111111111110b
24		23
25	IRQ_LINE equ 0	24	IRQ_LINE equ 0
26		25
27	CPU_FREQ equ 2600d	26	CPU_FREQ equ 2600d
28		27
29	BIT0 EQU 0x00000001	28	BIT0 EQU 0x00000001
30	BIT1 EQU 0x00000002	29	BIT1 EQU 0x00000002
31	BIT2 EQU 0x00000004	30	BIT2 EQU 0x00000004
32	BIT3 EQU 0x00000008	31	BIT3 EQU 0x00000008
33	BIT4 EQU 0x00000010	32	BIT4 EQU 0x00000010
34	BIT5 EQU 0x00000020	33	BIT5 EQU 0x00000020
35	BIT6 EQU 0x00000040	34	BIT6 EQU 0x00000040
36	BIT7 EQU 0x00000080	35	BIT7 EQU 0x00000080
37	BIT8 EQU 0x00000100	36	BIT8 EQU 0x00000100
38	BIT9 EQU 0x00000200	37	BIT9 EQU 0x00000200
39	BIT10 EQU 0x00000400	38	BIT10 EQU 0x00000400
40	BIT11 EQU 0x00000800	39	BIT11 EQU 0x00000800
41	BIT12 EQU 0x00001000	40	BIT12 EQU 0x00001000
42	BIT13 EQU 0x00002000	41	BIT13 EQU 0x00002000
43	BIT14 EQU 0x00004000	42	BIT14 EQU 0x00004000
44	BIT15 EQU 0x00008000	43	BIT15 EQU 0x00008000
45	BIT16 EQU 0x00010000	44	BIT16 EQU 0x00010000
46	BIT17 EQU 0x00020000	45	BIT17 EQU 0x00020000
47	BIT18 EQU 0x00040000	46	BIT18 EQU 0x00040000
48	BIT19 EQU 0x00080000	47	BIT19 EQU 0x00080000
49	BIT20 EQU 0x00100000	48	BIT20 EQU 0x00100000
50	BIT21 EQU 0x00200000	49	BIT21 EQU 0x00200000
51	BIT22 EQU 0x00400000	50	BIT22 EQU 0x00400000
52	BIT23 EQU 0x00800000	51	BIT23 EQU 0x00800000
53	BIT24 EQU 0x00100000	52	BIT24 EQU 0x00100000
54	BIT25 EQU 0x02000000	53	BIT25 EQU 0x02000000
55	BIT26 EQU 0x04000000	54	BIT26 EQU 0x04000000
56	BIT27 EQU 0x08000000	55	BIT27 EQU 0x08000000
57	BIT28 EQU 0x10000000	56	BIT28 EQU 0x10000000
58	BIT29 EQU 0x20000000	57	BIT29 EQU 0x20000000
59	BIT30 EQU 0x40000000	58	BIT30 EQU 0x40000000
60	BIT31 EQU 0x80000000	59	BIT31 EQU 0x80000000
61		60
62		61
63	PCM_OUT_BDL equ 0x10 ; PCM out buffer descriptors list	62	PCM_OUT_BDL equ 0x10 ; PCM out buffer descriptors list
64	PCM_OUT_CR_REG equ 0x1b ; PCM out Control Register	63	PCM_OUT_CR_REG equ 0x1b ; PCM out Control Register
65	PCM_OUT_LVI_REG equ 0x15 ; PCM last valid index	64	PCM_OUT_LVI_REG equ 0x15 ; PCM last valid index
66	PCM_OUT_SR_REG equ 0x16 ; PCM out Status register	65	PCM_OUT_SR_REG equ 0x16 ; PCM out Status register
67	PCM_OUT_PIV_REG equ 0x1a	66	PCM_OUT_PIV_REG equ 0x1a
68	PCM_OUT_CIV_REG equ 0x14 ; PCM out current index	67	PCM_OUT_CIV_REG equ 0x14 ; PCM out current index
69		68
70	PCM_IN_CR_REG equ 0x0b ; PCM in Control Register	69	PCM_IN_CR_REG equ 0x0b ; PCM in Control Register
71	MC_IN_CR_REG equ 0x2b ; MIC in Control Register	70	MC_IN_CR_REG equ 0x2b ; MIC in Control Register
72	RR equ BIT1 ; reset registers. Nukes all regs	71	RR equ BIT1 ; reset registers. Nukes all regs
73		72
74	CODEC_MASTER_VOL_REG equ 0x02	73	CODEC_MASTER_VOL_REG equ 0x02
75	CODEC_AUX_VOL equ 0x04 ;	74	CODEC_AUX_VOL equ 0x04 ;
76	CODEC_PCM_OUT_REG equ 18h ; PCM output volume	75	CODEC_PCM_OUT_REG equ 18h ; PCM output volume
77	CODEC_EXT_AUDIO_REG equ 28h ; extended audio	76	CODEC_EXT_AUDIO_REG equ 28h ; extended audio
78	CODEC_EXT_AUDIO_CTRL_REG equ 2ah ; extended audio control	77	CODEC_EXT_AUDIO_CTRL_REG equ 2ah ; extended audio control
79	CODEC_PCM_FRONT_DACRATE_REG equ 2ch ; PCM out sample rate	78	CODEC_PCM_FRONT_DACRATE_REG equ 2ch ; PCM out sample rate
80	CODEC_PCM_SURND_DACRATE_REG equ 2eh ; surround sound sample rate	79	CODEC_PCM_SURND_DACRATE_REG equ 2eh ; surround sound sample rate
81	CODEC_PCM_LFE_DACRATE_REG equ 30h ; LFE sample rate	80	CODEC_PCM_LFE_DACRATE_REG equ 30h ; LFE sample rate
82		81
83	GLOB_CTRL equ 0x2C ; Global Control	82	GLOB_CTRL equ 0x2C ; Global Control
84	CTRL_STAT equ 0x30 ; Global Status	83	CTRL_STAT equ 0x30 ; Global Status
85	CTRL_CAS equ 0x34 ; Codec Access Semiphore	84	CTRL_CAS equ 0x34 ; Codec Access Semiphore
86		85
87	CAS_FLAG equ 0x01 ; Codec Access Semiphore Bit	86	CAS_FLAG equ 0x01 ; Codec Access Semiphore Bit
88		87
89	CTRL_ST_CREADY equ BIT8+BIT9+BIT28 ; Primary Codec Ready	88	CTRL_ST_CREADY equ BIT8+BIT9+BIT28 ; Primary Codec Ready
90		89
91	CTRL_ST_RCS equ 0x00008000 ; Read Completion Status	90	CTRL_ST_RCS equ 0x00008000 ; Read Completion Status
92		91
93	CTRL_CNT_CRIE equ BIT4+BIT5+BIT6 ; Codecs Resume Interrupt Enable	92	CTRL_CNT_CRIE equ BIT4+BIT5+BIT6 ; Codecs Resume Interrupt Enable
94	CTRL_CNT_AC_OFF equ 0x00000008 ; ACLINK Off	93	CTRL_CNT_AC_OFF equ 0x00000008 ; ACLINK Off
95	CTRL_CNT_WARM equ 0x00000004 ; AC97 Warm Reset	94	CTRL_CNT_WARM equ 0x00000004 ; AC97 Warm Reset
96	CTRL_CNT_COLD equ 0x00000002 ; AC97 Cold Reset	95	CTRL_CNT_COLD equ 0x00000002 ; AC97 Cold Reset
97	CTRL_CNT_GIE equ 0x00000001 ; GPI Interrupt Enable	96	CTRL_CNT_GIE equ 0x00000001 ; GPI Interrupt Enable
98		97
99	CODEC_REG_POWERDOWN equ 0x26	98	CODEC_REG_POWERDOWN equ 0x26
100	CODEC_REG_ST equ 0x26	99	CODEC_REG_ST equ 0x26
101		100
102	DEV_PLAY equ 1	101	DEV_PLAY equ 1
103	DEV_STOP equ 2	102	DEV_STOP equ 2
104	DEV_CALLBACK equ 3	103	DEV_CALLBACK equ 3
105	DEV_SET_BUFF equ 4	104	DEV_SET_BUFF equ 4
106	DEV_NOTIFY equ 5	105	DEV_NOTIFY equ 5
107	DEV_SET_MASTERVOL equ 6	106	DEV_SET_MASTERVOL equ 6
108	DEV_GET_MASTERVOL equ 7	107	DEV_GET_MASTERVOL equ 7
109	DEV_GET_INFO equ 8	108	DEV_GET_INFO equ 8
110		109
111	struc AC_CNTRL ;AC controller base class	110	struc AC_CNTRL ;AC controller base class
112	{ .bus dd ?	111	{ .bus dd ?
113	.devfn dd ?	112	.devfn dd ?
114		113
115	.vendor dd ?	114	.vendor dd ?
116	.dev_id dd ?	115	.dev_id dd ?
117	.pci_cmd dd ?	116	.pci_cmd dd ?
118	.pci_stat dd ?	117	.pci_stat dd ?
119		118
120	.codec_io_base dd ?	119	.codec_io_base dd ?
121	.codec_mem_base dd ?	120	.codec_mem_base dd ?
122		121
123	.ctrl_io_base dd ?	122	.ctrl_io_base dd ?
124	.ctrl_mem_base dd ?	123	.ctrl_mem_base dd ?
125	.cfg_reg dd ?	124	.cfg_reg dd ?
126	.int_line dd ?	125	.int_line dd ?
127		126
128	.vendor_ids dd ? ;vendor id string	127	.vendor_ids dd ? ;vendor id string
129	.ctrl_ids dd ? ;hub id string	128	.ctrl_ids dd ? ;hub id string
130		129
131	.buffer dd ?	130	.buffer dd ?
132		131
133	.notify_pos dd ?	132	.notify_pos dd ?
134	.notify_task dd ?	133	.notify_task dd ?
135		134
136	.lvi_reg dd ?	135	.lvi_reg dd ?
137	.ctrl_setup dd ?	136	.ctrl_setup dd ?
138	.user_callback dd ?	137	.user_callback dd ?
139	.codec_read16 dd ?	138	.codec_read16 dd ?
140	.codec_write16 dd ?	139	.codec_write16 dd ?
141		140
142	.ctrl_read8 dd ?	141	.ctrl_read8 dd ?
143	.ctrl_read16 dd ?	142	.ctrl_read16 dd ?
144	.ctrl_read32 dd ?	143	.ctrl_read32 dd ?
145		144
146	.ctrl_write8 dd ?	145	.ctrl_write8 dd ?
147	.ctrl_write16 dd ?	146	.ctrl_write16 dd ?
148	.ctrl_write32 dd ?	147	.ctrl_write32 dd ?
149	}	148	}
150		149
151	struc CODEC ;Audio Chip base class	150	struc CODEC ;Audio Chip base class
152	{	151	{
153	.chip_id dd ?	152	.chip_id dd ?
154	.flags dd ?	153	.flags dd ?
155	.status dd ?	154	.status dd ?
156		155
157	.ac_vendor_ids dd ? ;ac vendor id string	156	.ac_vendor_ids dd ? ;ac vendor id string
158	.chip_ids dd ? ;chip model string	157	.chip_ids dd ? ;chip model string
159		158
160	.shadow_flag dd ?	159	.shadow_flag dd ?
161	dd ?	160	dd ?
162		161
163	.regs dw ? ; codec registers	162	.regs dw ? ; codec registers
164	.reg_master_vol dw ? ;0x02	163	.reg_master_vol dw ? ;0x02
165	.reg_aux_out_vol dw ? ;0x04	164	.reg_aux_out_vol dw ? ;0x04
166	.reg_mone_vol dw ? ;0x06	165	.reg_mone_vol dw ? ;0x06
167	.reg_master_tone dw ? ;0x08	166	.reg_master_tone dw ? ;0x08
168	.reg_beep_vol dw ? ;0x0A	167	.reg_beep_vol dw ? ;0x0A
169	.reg_phone_vol dw ? ;0x0C	168	.reg_phone_vol dw ? ;0x0C
170	.reg_mic_vol dw ? ;0x0E	169	.reg_mic_vol dw ? ;0x0E
171	.reg_line_in_vol dw ? ;0x10	170	.reg_line_in_vol dw ? ;0x10
172	.reg_cd_vol dw ? ;0x12	171	.reg_cd_vol dw ? ;0x12
173	.reg_video_vol dw ? ;0x14	172	.reg_video_vol dw ? ;0x14
174	.reg_aux_in_vol dw ? ;0x16	173	.reg_aux_in_vol dw ? ;0x16
175	.reg_pcm_out_vol dw ? ;0x18	174	.reg_pcm_out_vol dw ? ;0x18
176	.reg_rec_select dw ? ;0x1A	175	.reg_rec_select dw ? ;0x1A
177	.reg_rec_gain dw ? ;0x1C	176	.reg_rec_gain dw ? ;0x1C
178	.reg_rec_gain_mic dw ? ;0x1E	177	.reg_rec_gain_mic dw ? ;0x1E
179	.reg_gen dw ? ;0x20	178	.reg_gen dw ? ;0x20
180	.reg_3d_ctrl dw ? ;0X22	179	.reg_3d_ctrl dw ? ;0X22
181	.reg_page dw ? ;0X24	180	.reg_page dw ? ;0X24
182	.reg_powerdown dw ? ;0x26	181	.reg_powerdown dw ? ;0x26
183	.reg_ext_audio dw ? ;0x28	182	.reg_ext_audio dw ? ;0x28
184	.reg_ext_st dw ? ;0x2a	183	.reg_ext_st dw ? ;0x2a
185	.reg_pcm_front_rate dw ? ;0x2c	184	.reg_pcm_front_rate dw ? ;0x2c
186	.reg_pcm_surr_rate dw ? ;0x2e	185	.reg_pcm_surr_rate dw ? ;0x2e
187	.reg_lfe_rate dw ? ;0x30	186	.reg_lfe_rate dw ? ;0x30
188	.reg_pcm_in_rate dw ? ;0x32	187	.reg_pcm_in_rate dw ? ;0x32
189	dw ? ;0x34	188	dw ? ;0x34
190	.reg_cent_lfe_vol dw ? ;0x36	189	.reg_cent_lfe_vol dw ? ;0x36
191	.reg_surr_vol dw ? ;0x38	190	.reg_surr_vol dw ? ;0x38
192	.reg_spdif_ctrl dw ? ;0x3A	191	.reg_spdif_ctrl dw ? ;0x3A
193	dw ? ;0x3C	192	dw ? ;0x3C
194	dw ? ;0x3E	193	dw ? ;0x3E
195	dw ? ;0x40	194	dw ? ;0x40
196	dw ? ;0x42	195	dw ? ;0x42
197	dw ? ;0x44	196	dw ? ;0x44
198	dw ? ;0x46	197	dw ? ;0x46
199	dw ? ;0x48	198	dw ? ;0x48
200	dw ? ;0x4A	199	dw ? ;0x4A
201	dw ? ;0x4C	200	dw ? ;0x4C
202	dw ? ;0x4E	201	dw ? ;0x4E
203	dw ? ;0x50	202	dw ? ;0x50
204	dw ? ;0x52	203	dw ? ;0x52
205	dw ? ;0x54	204	dw ? ;0x54
206	dw ? ;0x56	205	dw ? ;0x56
207	dw ? ;0x58	206	dw ? ;0x58
208	dw ? ;0x5A	207	dw ? ;0x5A
209	dw ? ;0x5C	208	dw ? ;0x5C
210	dw ? ;0x5E	209	dw ? ;0x5E
211	.reg_page_0 dw ? ;0x60	210	.reg_page_0 dw ? ;0x60
212	.reg_page_1 dw ? ;0x62	211	.reg_page_1 dw ? ;0x62
213	.reg_page_2 dw ? ;0x64	212	.reg_page_2 dw ? ;0x64
214	.reg_page_3 dw ? ;0x66	213	.reg_page_3 dw ? ;0x66
215	.reg_page_4 dw ? ;0x68	214	.reg_page_4 dw ? ;0x68
216	.reg_page_5 dw ? ;0x6A	215	.reg_page_5 dw ? ;0x6A
217	.reg_page_6 dw ? ;0x6C	216	.reg_page_6 dw ? ;0x6C
218	.reg_page_7 dw ? ;0x6E	217	.reg_page_7 dw ? ;0x6E
219	dw ? ;0x70	218	dw ? ;0x70
220	dw ? ;0x72	219	dw ? ;0x72
221	dw ? ;0x74	220	dw ? ;0x74
222	dw ? ;0x76	221	dw ? ;0x76
223	dw ? ;0x78	222	dw ? ;0x78
224	dw ? ;0x7A	223	dw ? ;0x7A
225	.reg_vendor_id_1 dw ? ;0x7C	224	.reg_vendor_id_1 dw ? ;0x7C
226	.reg_vendor_id_2 dw ? ;0x7E	225	.reg_vendor_id_2 dw ? ;0x7E
227		226
228		227
229	.reset dd ? ;virual	228	.reset dd ? ;virual
230	.set_master_vol dd ?	229	.set_master_vol dd ?
231	}	230	}
232		231
233	struc CTRL_INFO	232	struc CTRL_INFO
234	{ .pci_cmd dd ?	233	{ .pci_cmd dd ?
235	.irq dd ?	234	.irq dd ?
236	.glob_cntrl dd ?	235	.glob_cntrl dd ?
237	.glob_sta dd ?	236	.glob_sta dd ?
238	.codec_io_base dd ?	237	.codec_io_base dd ?
239	.ctrl_io_base dd ?	238	.ctrl_io_base dd ?
240	.codec_mem_base dd ?	239	.codec_mem_base dd ?
241	.ctrl_mem_base dd ?	240	.ctrl_mem_base dd ?
242	.codec_id dd ?	241	.codec_id dd ?
243	}	242	}
244		243
245	struc IOCTL	244	struc IOCTL
246	{ .handle dd ?	245	{ .handle dd ?
247	.io_code dd ?	246	.io_code dd ?
248	.input dd ?	247	.input dd ?
249	.inp_size dd ?	248	.inp_size dd ?
250	.output dd ?	249	.output dd ?
251	.out_size dd ?	250	.out_size dd ?
252	}	251	}
253		252
254	virtual at 0	253	virtual at 0
255	IOCTL IOCTL	254	IOCTL IOCTL
256	end virtual	255	end virtual
257		256
258	EVENT_NOTIFY equ 0x00000200	257	EVENT_NOTIFY equ 0x00000200
259		258
260	OS_BASE equ 0x80000000	259	OS_BASE equ 0x80000000
261	SLOT_BASE equ OS_BASE+0x0080000	260	SLOT_BASE equ OS_BASE+0x0080000
262	new_app_base equ 0	261	new_app_base equ 0
263		262
264	public START	263	public START
265	public service_proc	264	public service_proc
266	public version	265	public version
267		266
268	section '.flat' code readable align 16	267	section '.flat' code readable align 16
269		268
270	proc START stdcall, state:dword	269	proc START stdcall, state:dword
271		270
272	cmp [state], 1	271	cmp [state], 1
273	jne .stop	272	jne .stop
274		273
275	if DEBUG	274	if DEBUG
276	mov esi, msgDetect	275	mov esi, msgDetect
277	call SysMsgBoardStr	276	call SysMsgBoardStr
278	end if	277	end if
279		278
280	call detect_controller	279	call detect_controller
281	test eax, eax	280	test eax, eax
282	jz .fail	281	jz .fail
283		282
284	if DEBUG	283	if DEBUG
285	mov esi, [ctrl.vendor_ids]	284	mov esi, [ctrl.vendor_ids]
286	call SysMsgBoardStr	285	call SysMsgBoardStr
287	mov esi, [ctrl.ctrl_ids]	286	mov esi, [ctrl.ctrl_ids]
288	call SysMsgBoardStr	287	call SysMsgBoardStr
289		288
290	end if	289	end if
291	call init_controller	290	call init_controller
292	test eax, eax	291	test eax, eax
293	jz .fail	292	jz .fail
294		293
295	jmp .fail ;force fail	294	jmp .fail ;force fail
296		295
297	if DEBUG	296	if DEBUG
298	mov esi, msgInitCodec	297	mov esi, msgInitCodec
299	call SysMsgBoardStr	298	call SysMsgBoardStr
300	end if	299	end if
301		300
302	call init_codec	301	call init_codec
303	test eax, eax	302	test eax, eax
304	jz .fail	303	jz .fail
305		304
306	if DEBUG	305	if DEBUG
307	mov esi, [codec.ac_vendor_ids]	306	mov esi, [codec.ac_vendor_ids]
308	call SysMsgBoardStr	307	call SysMsgBoardStr
309		308
310	mov esi, [codec.chip_ids]	309	mov esi, [codec.chip_ids]
311	call SysMsgBoardStr	310	call SysMsgBoardStr
312	end if	311	end if
313		312
314	call reset_controller	313	call reset_controller
315	call setup_codec	314	call setup_codec
316		315
317	mov esi, msgPrimBuff	316	mov esi, msgPrimBuff
318	call SysMsgBoardStr	317	call SysMsgBoardStr
319		318
320	call create_primary_buff	319	call create_primary_buff
321		320
322	mov eax, VALID_IRQ	321	mov eax, VALID_IRQ
323	mov ebx, [ctrl.int_line]	322	mov ebx, [ctrl.int_line]
324	mov esi, msgInvIRQ	323	mov esi, msgInvIRQ
325	bt eax, ebx	324	bt eax, ebx
326	jnc .fail	325	jnc .fail
327	mov eax, ATTCH_IRQ	-
328	mov esi, msgAttchIRQ	-
329	bt eax, ebx	-
330	jnc .fail	-
331		326
332	stdcall AttachIntHandler, ebx, ac97_irq, dword 0	327	stdcall AttachIntHandler, ebx, ac97_irq, dword 0
333	stdcall RegService, sz_sound_srv, service_proc	328	stdcall RegService, sz_sound_srv, service_proc
334	ret	329	ret
335	.fail:	330	.fail:
336	if DEBUG	331	if DEBUG
337	mov esi, msgFail	332	mov esi, msgFail
338	call SysMsgBoardStr	333	call SysMsgBoardStr
339	end if	334	end if
340	xor eax, eax	335	xor eax, eax
341	ret	336	ret
342	.stop:	337	.stop:
343	call stop	338	call stop
344	xor eax, eax	339	xor eax, eax
345	ret	340	ret
346	endp	341	endp
347		342
348	handle equ IOCTL.handle	343	handle equ IOCTL.handle
349	io_code equ IOCTL.io_code	344	io_code equ IOCTL.io_code
350	input equ IOCTL.input	345	input equ IOCTL.input
351	inp_size equ IOCTL.inp_size	346	inp_size equ IOCTL.inp_size
352	output equ IOCTL.output	347	output equ IOCTL.output
353	out_size equ IOCTL.out_size	348	out_size equ IOCTL.out_size
354		349
355	align 4	350	align 4
356	proc service_proc stdcall, ioctl:dword	351	proc service_proc stdcall, ioctl:dword
357		352
358	mov edi, [ioctl]	353	mov edi, [ioctl]
359	mov eax, [edi+io_code]	354	mov eax, [edi+io_code]
360	cmp eax, DEV_PLAY	355	cmp eax, DEV_PLAY
361	jne @F	356	jne @F
362	if DEBUG	357	if DEBUG
363	mov esi, msgPlay	358	mov esi, msgPlay
364	call SysMsgBoardStr	359	call SysMsgBoardStr
365	end if	360	end if
366	call play	361	call play
367	ret	362	ret
368	@@:	363	@@:
369	cmp eax, DEV_STOP	364	cmp eax, DEV_STOP
370	jne @F	365	jne @F
371	if DEBUG	366	if DEBUG
372	mov esi, msgStop	367	mov esi, msgStop
373	call SysMsgBoardStr	368	call SysMsgBoardStr
374	end if	369	end if
375	call stop	370	call stop
376	ret	371	ret
377	@@:	372	@@:
378	cmp eax, DEV_CALLBACK	373	cmp eax, DEV_CALLBACK
379	jne @F	374	jne @F
380	mov ebx, [edi+input]	375	mov ebx, [edi+input]
381	stdcall set_callback, [ebx]	376	stdcall set_callback, [ebx]
382	ret	377	ret
383	@@:	378	@@:
384	cmp eax, DEV_SET_MASTERVOL	379	cmp eax, DEV_SET_MASTERVOL
385	jne @F	380	jne @F
386	mov eax, [edi+input]	381	mov eax, [edi+input]
387	mov eax, [eax]	382	mov eax, [eax]
388	call set_master_vol ;eax= vol	383	call set_master_vol ;eax= vol
389	ret	384	ret
390	@@:	385	@@:
391	cmp eax, DEV_GET_MASTERVOL	386	cmp eax, DEV_GET_MASTERVOL
392	jne @F	387	jne @F
393	mov ebx, [edi+output]	388	mov ebx, [edi+output]
394	stdcall get_master_vol, ebx	389	stdcall get_master_vol, ebx
395	ret	390	ret
396	;@@:	391	;@@:
397	; cmp eax, DEV_GET_INFO	392	; cmp eax, DEV_GET_INFO
398	; jne @F	393	; jne @F
399	; mov ebx, [edi+output]	394	; mov ebx, [edi+output]
400	; stdcall get_dev_info, ebx	395	; stdcall get_dev_info, ebx
401	; ret	396	; ret
402	@@:	397	@@:
403	.fail:	398	.fail:
404	or eax, -1	399	or eax, -1
405	ret	400	ret
406	endp	401	endp
407		402
408	restore handle	403	restore handle
409	restore io_code	404	restore io_code
410	restore input	405	restore input
411	restore inp_size	406	restore inp_size
412	restore output	407	restore output
413	restore out_size	408	restore out_size
414		409
415		410
416	align 4	411	align 4
417	proc ac97_irq	412	proc ac97_irq
418		413
419	; if DEBUG	414	; if DEBUG
420	; mov esi, msgIRQ	415	; mov esi, msgIRQ
421	; call SysMsgBoardStr	416	; call SysMsgBoardStr
422	; end if	417	; end if
423		418
424		419
425	cmp [ctrl.user_callback], 0	420	cmp [ctrl.user_callback], 0
426	je @f	421	je @f
427		422
428	stdcall [ctrl.user_callback], ebx	423	stdcall [ctrl.user_callback], ebx
429	@@:	424	@@:
430	ret	425	ret
431		426
432	.skip:	427	.skip:
433	mov edx, PCM_OUT_CR_REG	428	mov edx, PCM_OUT_CR_REG
434	mov ax, 0x11 ;0x1D	429	mov ax, 0x11 ;0x1D
435	call [ctrl.ctrl_write8]	430	call [ctrl.ctrl_write8]
436	ret	431	ret
437	endp	432	endp
438		433
439	align 4	434	align 4
440	proc create_primary_buff	435	proc create_primary_buff
441		436
442	stdcall KernelAlloc, 0x10000	437	stdcall KernelAlloc, 0x10000
443	mov [ctrl.buffer], eax	438	mov [ctrl.buffer], eax
444		439
445	mov edi, eax	440	mov edi, eax
446	mov ecx, 0x10000/4	441	mov ecx, 0x10000/4
447	xor eax, eax	442	xor eax, eax
448	cld	443	cld
449	rep stosd	444	rep stosd
450		445
451	mov eax, [ctrl.buffer]	446	mov eax, [ctrl.buffer]
452	call GetPgAddr	447	call GetPgAddr
453		448
454	mov ebx, 0xC0002000	449	mov ebx, 0xC0002000
455	mov ecx, 4	450	mov ecx, 4
456	mov edi, pcmout_bdl	451	mov edi, pcmout_bdl
457	@@:	452	@@:
458	mov [edi], eax	453	mov [edi], eax
459	mov [edi+4], ebx	454	mov [edi+4], ebx
460		455
461	mov [edi+32], eax	456	mov [edi+32], eax
462	mov [edi+4+32], ebx	457	mov [edi+4+32], ebx
463		458
464	mov [edi+64], eax	459	mov [edi+64], eax
465	mov [edi+4+64], ebx	460	mov [edi+4+64], ebx
466		461
467	mov [edi+96], eax	462	mov [edi+96], eax
468	mov [edi+4+96], ebx	463	mov [edi+4+96], ebx
469		464
470	mov [edi+128], eax	465	mov [edi+128], eax
471	mov [edi+4+128], ebx	466	mov [edi+4+128], ebx
472		467
473	mov [edi+160], eax	468	mov [edi+160], eax
474	mov [edi+4+160], ebx	469	mov [edi+4+160], ebx
475		470
476	mov [edi+192], eax	471	mov [edi+192], eax
477	mov [edi+4+192], ebx	472	mov [edi+4+192], ebx
478		473
479	mov [edi+224], eax	474	mov [edi+224], eax
480	mov [edi+4+224], ebx	475	mov [edi+4+224], ebx
481		476
482	add eax, 0x4000	477	add eax, 0x4000
483	add edi, 8	478	add edi, 8
484	loop @B	479	loop @B
485		480
486	mov edi, buff_list	481	mov edi, buff_list
487	mov eax, [ctrl.buffer]	482	mov eax, [ctrl.buffer]
488	mov ecx, 4	483	mov ecx, 4
489	@@:	484	@@:
490	mov [edi], eax	485	mov [edi], eax
491	mov [edi+16], eax	486	mov [edi+16], eax
492	mov [edi+32], eax	487	mov [edi+32], eax
493	mov [edi+48], eax	488	mov [edi+48], eax
494	mov [edi+64], eax	489	mov [edi+64], eax
495	mov [edi+80], eax	490	mov [edi+80], eax
496	mov [edi+96], eax	491	mov [edi+96], eax
497	mov [edi+112], eax	492	mov [edi+112], eax
498		493
499	add eax, 0x4000	494	add eax, 0x4000
500	add edi, 4	495	add edi, 4

Subversion Repositories Kolibri OS

(root)/drivers/unfinished/ensoniq.asm @ 6654 – Rev 5363 → 7585