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

Subversion Repositories Kolibri OS

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