WebSVN – Kolibri OS – Diff – /drivers/audio/sis.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format PE DLL native 0.05
entry START
 
DEBUG           equ 1
 
API_VERSION     equ 0x01000100
DEBUG_IRQ       equ 0
 
USE_COM_IRQ     equ 0    ;make irq 3 and irq 4 available for PCI devices
IRQ_REMAP       equ 0
IRQ_LINE        equ 0
 
 
;irq 0,1,2,8,12,13 недоступны
;                   FEDCBA9876543210
VALID_IRQ       equ 1100111011111000b
ATTCH_IRQ       equ 0000111010100000b
 
if USE_COM_IRQ
ATTCH_IRQ       equ 0000111010111000b
end if
 
CPU_FREQ        equ  2000d
 
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
 
VID_SIS           equ 0x1039
CTRL_SIS          equ 0x7012
 
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  0x18  ; PCM out Status register
PCM_OUT_PIV_REG   equ  0x1a      ; PCM out prefetched index
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 0x18 ; PCM output volume
CODEC_EXT_AUDIO_REG          equ 0x28 ; extended audio
CODEC_EXT_AUDIO_CTRL_REG     equ 0x2a ; extended audio control
CODEC_PCM_FRONT_DACRATE_REG  equ 0x2c ; PCM out sample rate
CODEC_PCM_SURND_DACRATE_REG  equ 0x2e ; surround sound sample rate
CODEC_PCM_LFE_DACRATE_REG    equ 0x30 ; 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
 
SRV_GETVERSION        equ  0
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 ?
}
 
EVENT_NOTIFY          equ 0x00000200
 
section '.flat' code readable writable executable
include '../struct.inc'
include '../macros.inc'
include '../proc32.inc'
include '../peimport.inc'
 
 
proc START c uses ebx esi edi, state:dword, cmdline:dword
 
        cmp     [state], 1
        jne     .stop
 
     if DEBUG
        mov     esi, msgInit
        invoke  SysMsgBoardStr
     end if
 
        call    detect_controller
        test    eax, eax
        jz      .fail
 
     if DEBUG
        mov     esi, [ctrl.vendor_ids]
        invoke  SysMsgBoardStr
        mov     esi, [ctrl.ctrl_ids]
        invoke  SysMsgBoardStr
 
     end if
 
        call    init_controller
        test    eax, eax
        jz      .fail
 
        call    init_codec
        test    eax, eax
        jz      .fail
 
        call    reset_controller
        call    setup_codec
 
        mov     esi, msgPrimBuff
        invoke  SysMsgBoardStr
        call    create_primary_buff
        mov     esi, msgDone
        invoke  SysMsgBoardStr
 
  if IRQ_REMAP
        pushf
        cli
 
        mov     ebx, [ctrl.int_line]
        in      al, 0xA1
        mov     ah, al
        in      al, 0x21
        test    ebx, ebx
        jz      .skip
        bts     ax, bx                     ;mask old line
.skip:
        bts     ax, IRQ_LINE               ;mask new ine
        out     0x21, al
        mov     al, ah
        out     0xA1, al
                                           ;remap IRQ
        invoke  PciWrite8, 0, 0xF8, 0x61, IRQ_LINE
 
        mov     dx, 0x4d0                  ;8259 ELCR1
        in      al, dx
        bts     ax, IRQ_LINE
        out     dx, al                     ;set level-triggered mode
        mov     [ctrl.int_line], IRQ_LINE
        popf
        mov     esi, msgRemap
        invoke  SysMsgBoardStr
  end if
 
        mov     eax, VALID_IRQ
        mov     ebx, [ctrl.int_line]
        mov     esi, msgInvIRQ
        bt      eax, ebx
        jnc     .fail_msg
        mov     eax, ATTCH_IRQ
        mov     esi, msgAttchIRQ
        bt      eax, ebx
        jnc     .fail_msg
 
        invoke  AttachIntHandler, ebx, ac97_irq, 0
.reg:
        invoke  RegService, sz_sound_srv, service_proc
        ret
.fail:
   if DEBUG
        mov     esi, msgFail
        invoke  SysMsgBoardStr
   end if
        xor     eax, eax
        ret
.fail_msg:
        invoke  SysMsgBoardStr
        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, SRV_GETVERSION
        jne     @F
 
        mov     eax, [edi+output]
        cmp     [edi+out_size], 4
        jne     .fail
 
        mov     [eax], dword API_VERSION
        xor     eax, eax
        ret
@@:
        cmp     eax, DEV_PLAY
        jne     @F
     if DEBUG
        mov     esi, msgPlay
        invoke  SysMsgBoardStr
     end if
        call    play
        ret
@@:
        cmp     eax, DEV_STOP
        jne     @F
     if DEBUG
        mov     esi, msgStop
        invoke  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_IRQ
        mov     esi, msgIRQ
        invoke  SysMsgBoardStr
     end if
 
        mov     edx, PCM_OUT_CR_REG
        mov     al, 0x10
        call    [ctrl.ctrl_write8]
 
        mov     ax, 0x1c
        mov     edx, PCM_OUT_SR_REG
        call    [ctrl.ctrl_write16]
 
        mov     edx, PCM_OUT_CIV_REG
        call    [ctrl.ctrl_read8]
 
        and     eax, 0x1F
        cmp     eax, [civ_val]
        je      .skip
 
        mov     [civ_val], eax
        dec     eax
        and     eax, 0x1F
        mov     [ctrl.lvi_reg], eax
 
        mov     edx, PCM_OUT_LVI_REG
        call    [ctrl.ctrl_write8]
 
        mov     edx, PCM_OUT_CR_REG
        mov     ax, 0x11
        call    [ctrl.ctrl_write8]
 
        mov     eax, [civ_val]
        add     eax, 1
        and     eax, 31
        mov     ebx, dword [buff_list+eax*4]
 
        cmp     [ctrl.user_callback], 0
        je      @f
 
        stdcall [ctrl.user_callback], ebx
@@:
        ret
 
.skip:
        mov     edx, PCM_OUT_CR_REG
        mov     ax, 0x11
        call    [ctrl.ctrl_write8]
        ret
endp
 
align 4
proc create_primary_buff
 
        invoke  KernelAlloc, 0x10000
        mov     [ctrl.buffer], eax
 
        mov     edi, eax
        mov     ecx, 0x10000/4
        xor     eax, eax
        cld
        rep stosd
 
        mov     eax, [ctrl.buffer]
        invoke  GetPgAddr
 
        mov     ebx, 0xC0004000
        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
        invoke  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]
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        and     eax, not 0x000000C0
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
 
        ret
endp
 
align 4
proc detect_controller
        push    ebx
        invoke  GetPCIList
        mov     ebx, eax
.next_dev:
        mov     eax, [eax+PCIDEV.fd]
        cmp     eax, ebx
        je      .err
        cmp     [eax+PCIDEV.class], 0x060100  ;pci-isa
        jne     .no_bridge
        movzx   edx, [eax+PCIDEV.bus]
        mov     [brg_bus], edx
        movzx   edx, [eax+PCIDEV.devfn]
        mov     [brg_devfn], edx
.no_bridge:
        mov     edx, [eax+PCIDEV.vendor_device_id]
        mov     esi, devices
@@:
        cmp     dword [esi], 0
        jz      .next_dev
        cmp     dword [esi], edx
        jz      .found
        add     esi, 12
        jmp     @b
.err:
        xor     eax, eax
        pop     ebx
        ret
.found:
        movzx   ebx, [eax+PCIDEV.bus]
        mov     [ctrl.bus], ebx
 
        movzx   ecx, [eax+PCIDEV.devfn]
        mov     [ctrl.devfn], ecx
 
        mov     eax, edx
        and     edx, 0xFFFF
        mov     [ctrl.vendor], edx
        shr     eax, 16
        mov     [ctrl.dev_id], eax
 
        mov     ebx, [esi+4]
        mov     [ctrl.ctrl_ids], ebx
        mov     [ctrl.vendor_ids], msg_SIS
 
        mov     eax, [esi+8]
        mov     [ctrl.ctrl_setup], eax
        pop     ebx
        ret
endp
 
align 4
proc init_controller
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 4
        mov     ebx, eax
        or      al, 5
        invoke  PciWrite16, [ctrl.bus], [ctrl.devfn], 4, eax
        movzx   eax, bx
        mov     [ctrl.pci_cmd], eax
        shr     ebx, 16
        mov     [ctrl.pci_stat], ebx
 
        mov     esi, msgPciCmd
        invoke  SysMsgBoardStr
        call    dword2str
        invoke  SysMsgBoardStr
 
        mov     esi, msgPciStat
        invoke  SysMsgBoardStr
        mov     eax, [ctrl.pci_stat]
        call    dword2str
        invoke  SysMsgBoardStr
 
        mov     esi, msgMixIsaIo
        invoke  SysMsgBoardStr
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 0x10
 
        call    dword2str
        invoke  SysMsgBoardStr
 
        and     eax, 0xFFFE
        mov     [ctrl.codec_io_base], eax
 
        mov     esi, msgCtrlIsaIo
        invoke  SysMsgBoardStr
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 0x14
 
        call    dword2str
        invoke  SysMsgBoardStr
 
        and     eax, 0xFFC0
        mov     [ctrl.ctrl_io_base], eax
 
        mov     esi, msgMixMMIo
        invoke  SysMsgBoardStr
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 0x18
        mov     [ctrl.codec_mem_base], eax
 
        call    dword2str
        invoke  SysMsgBoardStr
 
        mov     esi, msgCtrlMMIo
        invoke  SysMsgBoardStr
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 0x1C
        mov     [ctrl.ctrl_mem_base], eax
 
        call    dword2str
        invoke  SysMsgBoardStr
 
        invoke  PciRead32, [ctrl.bus], [ctrl.devfn], 0x3C
        cmp     al, 0xFF
        jnz     @f
        movzx   eax, ah
        add     eax, 0x40
        invoke  PciWrite8, [brg_bus], [brg_devfn], eax, 5
        invoke  PciWrite8, [ctrl.bus], [ctrl.devfn], 0x3C, 5
        mov     al, 5
@@:
        and     eax, 0xFF
        mov     [ctrl.int_line], eax
 
        invoke  PciRead8, [ctrl.bus], [ctrl.devfn], 0x41
        and     eax, 0xFF
        mov     [ctrl.cfg_reg], eax
 
        call    [ctrl.ctrl_setup]
        xor     eax, eax
        inc     eax
        ret
endp
 
align 4
proc set_SIS
        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
        invoke  SysMsgBoardStr
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        call    dword2str
        invoke  SysMsgBoardStr
 
        mov     esi, msgStatus
        invoke  SysMsgBoardStr
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        push    eax
        call    dword2str
        invoke  SysMsgBoardStr
        pop     eax
        cmp     eax, 0xFFFFFFFF
        je      .err
 
        test    eax, CTRL_ST_CREADY
        jnz     .ready
 
        call    reset_codec
        test    eax, eax
        jz      .err
 
.ready:
        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     eax, 5000  ; wait 5 ms
        call    StallExec
 
        mov     edx, CODEC_REG_POWERDOWN
        call    [ctrl.codec_read16]
        and     eax, 0x0F
        cmp     eax, 0x0F
        je      .done
 
        sub     [counter] , 1
        jnz     .wait
.err:
        xor     eax, eax       ; timeout error
        ret
.done:
        mov     eax, 2     ;force set 16-bit 2-channel PCM
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
        mov     eax, 5000  ; wait 5 ms
        call    StallExec
 
        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
        invoke  SysMsgBoardStr
     end if
        xor     eax, eax    ; timeout error
        ret
.ok:
        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
        invoke  SysMsgBoardStr
     end if
 
        mov     [counter], 10   ; total 10*100 ms = 1s
.wait:
        mov     eax, 100000   ; wait 100 ms
        call    StallExec
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        test    eax, CTRL_ST_CREADY
        jnz     .ok
 
        dec     [counter]
        jnz     .wait
 
     if DEBUG
        mov     esi, msgWRFail
        invoke  SysMsgBoardStr
     end if
.fail:
        stc
        ret
.ok:
        clc
        ret
endp
 
align 4
proc cold_reset
           locals
             counter dd ?
            endl
 
        mov     eax, 0x02
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_write32]
 
     if DEBUG
        mov     esi, msgCold
        invoke  SysMsgBoardStr
     end if
 
        mov     eax, 400000    ; wait 400 ms
        call    StallExec
 
        mov     [counter], 16   ; total 20*100 ms = 2s
.wait:
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        test    eax, CTRL_ST_CREADY
        jnz     .ok
 
        mov     eax, 100000   ; wait 100 ms
        call    StallExec
 
        dec     [counter]
        jnz     .wait
 
     if DEBUG
        mov     esi, msgCRFail
        invoke  SysMsgBoardStr
     end if
 
.fail:
        stc
        ret
.ok:
        mov     esi, msgControl
        invoke  SysMsgBoardStr
 
        mov     edx, GLOB_CTRL
        call    [ctrl.ctrl_read32]
        call    dword2str
        invoke  SysMsgBoardStr
 
        mov     esi, msgStatus
        invoke  SysMsgBoardStr
 
        mov     edx, CTRL_STAT
        call    [ctrl.ctrl_read32]
        push    eax
        call    dword2str
        invoke  SysMsgBoardStr
        pop     eax
 
        test    eax, CTRL_ST_CREADY
        jz      .fail
        clc
        ret
endp
 
align 4
play:
        xor     eax, eax
        mov     [civ_val], eax
        mov     edx, PCM_OUT_CIV_REG
        call    [ctrl.ctrl_write8]
 
        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
        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
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_semaphore
           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
proc codec_io_r16
        push    eax edx
        call    check_semaphore
        test    eax, eax
        pop     edx eax
        jz      .err
        add     edx, [ctrl.codec_io_base]
        in      ax, dx
.err:
        ret
endp
 
align 4
proc codec_io_w16
        push    eax edx
        call    check_semaphore
        test    eax, eax
        pop     edx eax
        jz      .err
        add     edx, [ctrl.codec_io_base]
        out     dx, ax
.err:
        ret
endp
 
align 4
proc ctrl_io_r8
        add     edx, [ctrl.ctrl_io_base]
        in      al, dx
        ret
endp
 
align 4
proc ctrl_io_r16
        add     edx, [ctrl.ctrl_io_base]
        in      ax, dx
        ret
endp
 
align 4
proc ctrl_io_r32
        add     edx, [ctrl.ctrl_io_base]
        in      eax, dx
        ret
endp
 
align 4
proc ctrl_io_w8
        add     edx, [ctrl.ctrl_io_base]
        out     dx, al
        ret
endp
 
align 4
proc ctrl_io_w16
        add     edx, [ctrl.ctrl_io_base]
        out     dx, ax
        ret
endp
 
align 4
proc ctrl_io_w32
        add     edx, [ctrl.ctrl_io_base]
        out     dx, eax
        ret
endp
 
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 (CTRL_SIS  shl 16)+VID_SIS,msg_AC, set_SIS
        dd 0
 
msg_AC       db '7012 AC97 controller',13,10, 0
msg_SIS      db 'Silicon Integrated Systems',13,10, 0
 
sz_sound_srv        db 'SOUND',0
 
msgInit      db 'detect hardware...',13,10,0
msgFail      db 'device not found',13,10,0
msgAttchIRQ  db 'IRQ line not supported', 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 ...',0
msgDone      db 'done',13,10,0
msgRemap     db 'Remap IRQ',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
msgPciStat   db 'PCI status      ',0
msgCtrlIsaIo db 'controller io base   ',0
msgMixIsaIo  db 'codec io base        ',0
msgCtrlMMIo  db 'controller mmio base ',0
msgMixMMIo   db 'codec mmio base      ',0
msgIrqMap    db 'AC97 irq map as      ',0
 
align 4
data fixups
end data
 
align 8
pcmout_bdl       rq 32
buff_list        rd 32
 
codec CODEC
ctrl AC_CNTRL
 
lpc_bus  rd 1
civ_val  rd 1
 
brg_bus   dd ?
brg_devfn dd ?

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

Subversion Repositories Kolibri OS

(root)/drivers/audio/sis.asm – Rev 5077 → 5363