Subversion Repositories Kolibri OS

proc make_codec_cmd stdcall, nid:dword, direct:dword, verb:dword, parm:dword

    push   ebx

    and    dword [direct], 1

    and    dword [nid], 0x7F

    and    dword [verb], 0xFFF

    and    dword [parm], 0xFFFF

    shl    eax, 28

    mov    ebx, [direct]

    shl    ebx, 27

    or	   eax, ebx

    mov    ebx, [nid]

    shl    ebx, 20

    or	   eax, ebx

    mov    ebx, [verb]

    shl    ebx, 8

     or     eax, ebx

    mov    ebx, [parm]

    or	   eax, ebx

    pop    ebx

    ret

 .err:

    pop    ebx

    mov    eax, -1

    ret

endp

proc  codec_exec_verb stdcall, cmd:dword;, res:dword <- returned in eax

    push   ebx	edx

    mov    ebx, [cmd]

    cmp    ebx, -1

    jne    @f

    pop    edx	ebx

    mov    eax, -1

    ret

  @@:

  if  FDEBUG   ;YAHOO

    push   eax esi

    mov    esi, msgVerbQuery

    call   SysMsgBoardStr

    mov    eax, ebx

    stdcall fdword2str, 2

    call   SysMsgBoardStr

    pop    esi eax

  end if

  .again:

    ; call   snd_hda_power_up

    stdcall  azx_send_cmd, ebx

    mov    ebx, eax

    test   ebx, ebx

    jnz    @f

    call  azx_get_response

    mov    edx, eax

  if  FDEBUG

    test   edx, edx

    jz	   .end_debug

    push   eax esi

    mov    esi, msgVerbAnswer

    call   SysMsgBoardStr

    mov    eax, edx

    stdcall fdword2str, 2

    call   SysMsgBoardStr

    pop    esi eax

   .end_debug:

  end if

    cmp    edx, -1

    jne    .l1

    test   eax, eax

    jz	   .l1

    jz	   @f

    push   esi

    mov    esi, emsgBusResetFatalComm

    call   SysMsgBoardStr

    pop    esi

  end if

    call   azx_bus_reset

  @@:

  .l1:

    ;; clear reset-flag when the communication gets recovered

    test   ebx, ebx

    jnz    @f

    mov    [ctrl.response_reset], 0

  @@:

    mov    eax, edx

    ret

endp

;; snd_hda_codec_read - send a command and get the response

;; @nid: NID to send the command

;; @direct: direct flag

;; @verb: the verb to send

;; @parm: the parameter for the verb

;;

;; Send a single command and read the corresponding response.

;;

;; Returns the obtained response value, or -1 for an error.

;;

proc  snd_hda_codec_read stdcall, nid:dword, direct:dword, verb:dword, parm:dword

    stdcall  make_codec_cmd, [nid], [direct], [verb], [parm]

    stdcall  codec_exec_verb, eax

    ret

endp

;; snd_hda_codec_write - send a single command without waiting for response

;; @nid: NID to send the command

;; @direct: direct flag

;; @verb: the verb to send

;; @parm: the parameter for the verb

;;

;; Send a single command without waiting for response.

;;

;; Returns 0 if successful, or a negative error code.

;;

proc  snd_hda_codec_write stdcall, nid:dword, direct:dword, verb:dword, parm:dword

    ; Do we need to support a sync write?

    stdcall  make_codec_cmd, [nid], [direct], [verb], [parm]

    stdcall  codec_exec_verb, eax

    ret

endp

;; snd_hda_sequence_write - sequence writes

;; @seq: VERB array to send

;;

;; Send the commands sequentially from the given array.

;; The array must be terminated with NID=0.

;;

proc  snd_hda_sequence_write stdcall, seq:dword

    push     eax  ebx  ecx  esi

    mov      esi, [seq]

  @@:

    ;mov      ecx, [esi + hda_verb.nid]

    ;mov      ebx, [esi + hda_verb.verb]

    ;mov      eax, [esi + hda_verb.param]

    ;stdcall  snd_hda_codec_write, ecx, 0, ebx, eax

    ;add      esi, hda_verb.sizeof

    ;test     ecx, ecx

    ;jnz      @b

    ;______________________________________

    cmp      dword [esi], 0

    je	     .out

    movzx    ecx, word [esi] ; NID

    movzx    ebx, word [esi+2] ; verb

    and      bx, 0x0FFF

    movzx    eax, word [esi + 4] ; sizeof(param) = 4 bytes

    stdcall  snd_hda_codec_write, ecx, 0, ebx, eax

    add      esi, 6

    jmp      @b

 .out:

    pop      esi  ecx  ebx  eax

    ret

endp

{

    stdcall  snd_hda_codec_read, nid, 0, AC_VERB_PARAMETERS, param

}

;; snd_hda_get_sub_nodes - get the range of sub nodes

;; @codec: the HDA codec

;; @nid: NID to parse

;; @start_id: the pointer to store the start NID

;;

;; Parse the NID and store the start NID of its sub-nodes.

;; Returns the number of sub-nodes.

;;

proc  snd_hda_get_sub_nodes stdcall, nid:dword;, start_id:dword  <- returned in upper word of eax

    snd_hda_param_read	[nid], AC_PAR_NODE_COUNT

    jne      @f

    inc      eax

  @@:

    and      eax, 0x7FFF7FFF

endp

;; snd_hda_get_connections - get connection list

;; @codec: the HDA codec

;; @nid: NID to parse

;; @conn_list: connection list array

;; @max_conns: max. number of connections to store

;;

;; Parses the connection list of the given widget and stores the list

;; of NIDs.

;;

;; Returns the number of connections, or a negative error code.

;;

proc  snd_hda_get_connections stdcall, nid:dword, conn_list:dword, max_conns:dword   ;Asper: Complete translation!

    locals

       parm	     dd ?

       conn_len      dd ?

       conns	     dd 0

       shift	     db 8

       num_elements  dd 4

       mask	     dd 0x7F

       wcaps	     dd ?

       prev_nid      dw 1 ;Asper: Hmm.. Probably ALSA bug that it isn't initialized. I suppose to init it with 1.

    endl

    mov      edi, [conn_list]

    test     edi, edi

    jz	     .err_out

    mov      ecx, [max_conns]

    cmp      ecx, 0

    jle      .err_out

    mov      ebx, eax

    mov      [wcaps], eax

    stdcall  get_wcaps_type, ebx

    cmp      eax, AC_WID_VOL_KNB

    je	     .conn_list_ok

    test     ebx, AC_WCAP_CONN_LIST

    jnz      .conn_list_ok

  if DEBUG

    mov      esi, emsgConnListNotAvailable

    call     SysMsgBoardStr

    mov      eax, [nid]

    stdcall fdword2str, 3

    call     SysMsgBoardStr

  end if

    xor      eax, eax

    dec      eax

    jmp      .out

  .conn_list_ok:

    mov      [parm], eax

    jz	     @f

    ; long form

    mov      [shift], 16

    mov      [num_elements], 2

    mov      [mask], 0x7FFF ;Asper+

  @@:

    and      eax, AC_CLIST_LENGTH

    test     eax, eax

    jz	     .out ; no connection

    cmp      eax, 1

    jne      .multi_conns

    ; single connection

    stdcall  snd_hda_codec_read, [nid], 0, AC_VERB_GET_CONNECT_LIST, 0

    mov      [parm], eax

    cmp      [parm], -1

    jne      @f

    cmp      [ctrl.rirb_error], 0

    jne      @f

    xor      eax, eax

    dec      eax

    jmp      .out

  @@:

    and      eax, [mask]

    stosd

    xor      eax, eax

    inc      eax

    jmp      .out

  .multi_conns:

    xor      ecx, ecx

    mov      edx, [num_elements]

  .next_conn:

    mov      eax, ecx

  .mod:

    cmp      eax, edx

    jl	     .mod_counted

    sub      eax, edx

    jmp      .mod

  .mod_counted:

    jnz      .l1

    stdcall  snd_hda_codec_read, [nid], 0, AC_VERB_GET_CONNECT_LIST, ecx

    mov      [parm], eax

    jne      .l1

    cmp      [ctrl.rirb_error], 0

    jne      .err_out

  .l1:

    push     ecx

    mov      cl, [shift]

    dec      cl

    shl      eax, cl

    and      eax, [parm]

    pop      ecx

    mov      ebx, eax  ;ranges

    and      eax, [mask] ;val

    jnz      @f

 if DEBUG

    push     eax esi

    mov      esi, emsgInvConnList

    call     SysMsgBoardStr

    mov      eax, [nid]

    stdcall  fdword2str, 1

    call     SysMsgBoardStr

    call     SysMsgBoardStr

    mov      eax, ecx

    stdcall  fdword2str, 0

    call     SysMsgBoardStr

    call     SysMsgBoardStr

    mov      eax, [parm]

    stdcall  fdword2str, 2

    call     SysMsgBoardStr

    pop      esi eax

 end if

    xor      eax, eax

    jmp      .out

  @@:

    push     ecx

    mov      cl, [shift]

    shr      [parm], cl

    pop      ecx

    jz	     .range_zero

    ; ranges between the previous and this one

    movzx    esi, word [prev_nid]

    test     esi, esi

    jz	     .l2

    cmp      esi, eax

    jl	     @f

  .l2:

 if DEBUG

    push     eax esi

    push     esi

    mov      esi, emsgInvDepRangeVal

    call     SysMsgBoardStr

    pop      esi

    push     eax

    mov      eax, esi

    stdcall  fdword2str, 0

    call     SysMsgBoardStr

    call     SysMsgBoardStr

    pop      eax

    stdcall  fdword2str, 2

    call     SysMsgBoardStr

    pop      esi eax

 end if

    jmp      .continue

  @@:

    push     ecx

    mov      ecx, esi

    inc      ecx

    mov      ebx, [conns]

  .next_conn2:

    cmp      ebx, [max_conns]

    jl	     @f

 if DEBUG

    push     esi

    mov      esi, emsgTooManyConns

    call     SysMsgBoardStr

    pop      esi

 end if

    pop      ecx

    jmp      .err_out

  @@:

    shl      ebx, 1

    push     edi

    add      edi, ebx

    mov      word [edi], cx

    pop      edi

    shr      ebx, 1

    inc      ebx

    inc      ecx

    cmp      ecx, eax

    jle      .next_conn2

    pop      ecx

    jmp      .end_range_test

  .range_zero:

    cmp      ebx, [max_conns]

    jl	     @f

 if DEBUG

    push     esi

    mov      esi, emsgTooManyConns

    call     SysMsgBoardStr

    pop      esi

 end if

    jmp      .err_out

  @@:

    shl      ebx, 1

    push     edi

    add      edi, ebx

    mov      word [edi], ax

    pop      edi

    shr      ebx, 1

    inc      ebx

    mov      [conns], ebx

  .end_range_test:

    mov      [prev_nid], ax

  .continue:

    inc      ecx

    cmp      ecx, [conn_len]

    jl	     .next_conn

  .out:

     pop     esi edi edx ecx ebx

     ret

  .err_out:

     pop     esi edi edx ecx ebx

     mov     eax, -1

     ret

endp

;proc  snd_hda_queue_unsol_events stdcall, res:dword, res_ex:dword

;    push     ebx  edi  esi

;    ...

;    pop      esi  edi  ebx

;    ret

;endp

;proc  process_unsol_events stdcall, work:dword

;proc  init_usol_queue stdcall, bus:dword

;; snd_hda_bus_new - create a HDA bus

;; @card: the card entry

;; @temp: the template for hda_bus information

;; @busp: the pointer to store the created bus instance

;;

;; Returns 0 if successful, or a negative error code.

;;

;proc  snd_hda_bus_new

    ; if we want to support unsolicited events, we have to solve this

    ;    bus->workq = create_singlethread_workqueue(bus->workq_name);

    ; (...)

;    xor   eax, eax

;    ret

;endp

;; snd_hda_codec_init - initialize a HDA codec

;;

;; Returns 0 if successful, or a negative error code.

;;

proc  snd_hda_codec_init    ; We use just one codec (the first found)

     snd_hda_param_read  AC_NODE_ROOT, AC_PAR_VENDOR_ID

     cmp     eax, -1

     jne     @f

     snd_hda_param_read  AC_NODE_ROOT, AC_PAR_VENDOR_ID

  @@:

     mov     [codec.chip_id], ax

     shr     eax, 16

     mov     [codec.vendor_id], ax

     mov     [codec.subsystem_id], eax

     mov     [codec.revision_id], eax

     test    eax, eax

     jnz     @f

     test    eax, eax

     jnz     @f

  if DEBUG

     push    esi

     mov     esi, emsgNoAFGorMFGFound

     call    SysMsgBoardStr

     pop     esi

  end  if

     mov     eax, -1

     ret

  @@:

     push    ebx

     stdcall read_widget_caps, eax

     jge     @f

  if DEBUG

     push    esi

     mov     esi, emsgNoMem

     call    SysMsgBoardStr

     pop     esi

  end  if

     pop     ebx

     mov     eax, -1

     ret

  @@:

     jge     @f

     pop     ebx

     mov     eax, -1

     ret

  @@:

     mov     eax, [codec.subsystem_id]

     test    eax, eax

     jnz     @f

     stdcall snd_hda_codec_read, ebx, 0, AC_VERB_GET_SUBSYSTEM_ID, 0

     stdcall snd_hda_set_power_state, ebx, AC_PWRST_D0

     ret

endp

;; snd_hda_codec_configure - (Re-)configure the HD-audio codec

;;

;; Start parsing of the given codec tree and (re-)initialize the whole

;; patch instance.

;;

;; Returns 0 if successful or a negative error code.

;;

proc  snd_hda_codec_configure

     call    get_codec_name

  @@:

     ; call the default parser

     stdcall snd_hda_parse_generic_codec  ;entry point to generic tree parser!!!

     jz      @f

  if DEBUG

     push    esi

     mov     esi, emsgNoParserAvailable

     call    SysMsgBoardStr

     pop     esi

  end if

  @@:

  .out:

     ret

endp

proc  get_codec_name

     push    eax  ebx  edi  esi

     mov     eax, [codec.ac_vendor_ids]

     test    eax, eax

     jnz     .get_chip_name

     mov     ax, [codec.vendor_id]

     mov     edi, hda_vendor_ids

     mov     ebx, [edi]

     test    ebx, ebx

     jz      .unknown

     jne     .next

     mov     eax, [edi+4]

     mov     [codec.ac_vendor_ids], eax

     mov     esi, eax

     call    SysMsgBoardStr

  .get_chip_name:

     stdcall detect_chip, [edi+8]

     pop     esi  edi  ebx  eax

     ret

  .next:

     add     edi, 12

     jmp     @b

  .unknown:

     mov     [codec.ac_vendor_ids], ac_unknown

     mov     [codec.chip_ids], chip_unknown

     call    SysMsgBoardStr

     movzx   eax, [codec.chip_id]

     stdcall fdword2str, 2

     call    SysMsgBoardStr

     pop     esi  edi  ebx  eax

     ret

endp

proc detect_chip stdcall, chip_tab:dword

     mov     ax, [codec.chip_id]

@@:

     mov     ebx, [edi]

     cmp     ebx, 0xFF

     je      .unknown

     jne     .next

     mov     eax, [edi+4]

     mov     [codec.chip_ids], eax

     mov     esi, eax

     call    SysMsgBoardStr

     pop     esi  edi  ebx  eax

     ret

.next:

     add     edi, 8

     jmp     @b

.unknown:

     mov     [codec.chip_ids], chip_unknown

     mov     esi, chip_unknown

     call    SysMsgBoardStr

     movzx   eax, [codec.chip_id]

     stdcall fdword2str, 2

     call    SysMsgBoardStr

     pop     esi  edi  ebx  eax

     ret

endp

proc setup_fg_nodes

     push    eax  ebx  ecx

     stdcall snd_hda_get_sub_nodes, AC_NODE_ROOT

     mov     ecx, eax

     and     ecx, 0x7FFF ; total_nodes

     mov     ebx, eax

     shr     ebx, 16

     and     ebx, 0x7FFF ; nid

     push    eax esi

     mov     esi, msgSETUP_FG_NODES

     call    SysMsgBoardStr

     mov     eax, ebx

     stdcall fdword2str, 1

     call    SysMsgBoardStr

     call    SysMsgBoardStr

     mov     eax, ecx

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     pop     esi eax

end if

     test    ecx, ecx

     jz      .l1

     snd_hda_param_read  ebx, AC_PAR_FUNCTION_TYPE

     and     eax, 0xFF

     push    eax esi

     mov     esi, msgFG_TYPE

     call    SysMsgBoardStr

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     pop     esi eax

end if

     jne     @f

     mov     [codec.function_id], eax

     jmp     .continue

  @@:

     cmp     eax, AC_GRP_MODEM_FUNCTION

     jne     @f

     mov     [codec.function_id], eax

     jmp     .continue

  @@:

  .continue:

     inc     ebx

     dec     ecx

     jnz     .next

  .l1:

     pop     ecx  ebx  eax

     ret

endp

; read widget caps for each widget and store in cache

proc  read_widget_caps stdcall, fg_node:dword

     push    ebx ecx edx edi

     mov     ecx, eax

     and     ecx, 0x7FFF ; total_nodes

     mov     [codec.num_nodes], cx

     mov     ebx, eax

     shr     ebx, 16

     and     ebx, 0x7FFF ; nid

     mov     [codec.start_nid], bx

     push    eax esi

     mov     esi, msgSETUP_FG_NODES

     call    SysMsgBoardStr

     mov     eax, ebx

     stdcall fdword2str, 1

     call    SysMsgBoardStr

     call    SysMsgBoardStr

     mov     eax, ecx

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     pop     esi eax

end if

     push    esi

     mov     esi, msgWCaps

     call    SysMsgBoardStr

     pop     esi

end if

     shl     eax, 2

     push    ebx ecx

     call    Kmalloc

     pop     ecx ebx

     test    eax, eax

     jz      .err_out

     mov     [codec.wcaps], eax

  .next_node:

     stosd

     inc     ebx

     dec     ecx

     jnz     .next_node

     pop     edi edx ecx ebx

     xor     eax, eax

     ret

  .err_out:

     pop     edi edx ecx ebx

     xor     eax, eax

     dec     eax

     ret

endp

proc  read_pin_defaults

     push    ebx ecx edx edi

     movzx   ecx, [codec.num_nodes]

     mov     eax, HDA_PINCFG.sizeof

     mul     cl

     push    ebx ecx

     call    Kmalloc

     pop     ecx ebx

     test    eax, eax

     jz      .err_out

     mov     [codec.init_pins], eax

     mov     edi, eax

     ;Asper ]

   push   eax esi

   mov	  esi, msgPinCfgs

   call   SysMsgBoardStr

   pop	  esi eax

end if

     stdcall get_wcaps, ebx

     and  eax, AC_WCAP_TYPE

     shr  eax, AC_WCAP_TYPE_SHIFT

     jne     .continue

     stdcall snd_hda_codec_read, ebx, 0, AC_VERB_GET_CONFIG_DEFAULT, 0

     mov     [edi + HDA_PINCFG.cfg], eax

     add     edi, HDA_PINCFG.sizeof

     inc     ebx

     dec     ecx

     jnz     .next_node

     and     ebx, 0xFFFF

     sub     bx, [codec.start_nid]

     mov     [codec.num_pins], ebx

;Asper ]

     xor     eax, eax

     ret

  .err_out:

     pop     edi edx ecx ebx

     xor     eax, eax

     dec     eax

     ret

endp

proc  look_up_pincfg stdcall, array:dword, nid:dword

     push    ebx ecx edx

     mov     ecx, [codec.num_pins]

     mov     eax, [array]

     mov     ebx, [nid]

  .next_pin:

     mov     dx,  [eax + HDA_PINCFG.nid]

     cmp     dx,  bx

     je      .out

  .continue:

     add     eax, HDA_PINCFG.sizeof

     dec     ecx

     jnz     .next_pin

  .out:

     pop     edx ecx ebx

     ret

endp

proc  set_pincfg stdcall, nid:dword, cfg:dword

     push    eax  ebx  ecx  edx

     mov     eax, [cfg]

     xor     ebx, ebx

     mov     edx, AC_VERB_SET_CONFIG_DEFAULT_BYTES_0

     mov     ecx, 4

  @@:

     mov     bl,  al

     stdcall snd_hda_codec_write, [nid], 0, edx, ebx

     shr     eax, 8

     inc     edx

     dec     ecx

     jnz     @b

  .l1:

     pop     edx  ecx  ebx  eax

     ret

endp

;; snd_hda_codec_get_pincfg - Obtain a pin-default configuration

;; @codec: the HDA codec

;; @nid: NID to get the pin config

;;

;; Get the current pin config value of the given pin NID.

;; If the pincfg value is cached or overridden via sysfs or driver,

;; returns the cached value.

;;

proc  snd_hda_codec_get_pincfg stdcall, nid:dword

     push    edi

     stdcall look_up_pincfg, [codec.init_pins], [nid]

     test    eax, eax

     jz      @f

     mov     edi, eax

     mov     eax, [edi + HDA_PINCFG.cfg]

  @@:

     pop     edi

     ret

endp

;; snd_hda_codec_setup_stream - set up the codec for streaming

;; @nid: the NID to set up

;; @stream_tag: stream tag to pass, it's between 0x1 and 0xf.

;; @channel_id: channel id to pass, zero based.

;; @format: stream format.

;;

proc hda_codec_setup_stream stdcall, nid:dword, stream_tag:dword, channel_id:dword, format:dword

     push    eax

     mov     eax, [nid]

     test    eax, eax

     jnz     @f

     pop     eax

     ret

  @@:

  if DEBUG

     push    esi

     mov     esi, msgHDACodecSetupStream

     call    SysMsgBoardStr

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     call    SysMsgBoardStr

     mov     eax, [stream_tag]

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     call    SysMsgBoardStr

     mov     eax, [channel_id]

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     call    SysMsgBoardStr

     mov     eax, [format]

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     pop     esi

  end if

     mov     eax, [stream_tag]

     shl     eax, 4

     or      eax, [channel_id]

     stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_CHANNEL_STREAMID, eax

     call    StallExec

     pop     eax

     ret

endp

     push    eax

     mov     eax, [nid]

     test    eax, eax

     jz      @f

     pop     eax

     ret

  @@:

  if DEBUG

     push    esi

     mov     esi, msgHDACodecCleanupStream

     call    SysMsgBoardStr

     stdcall fdword2str, 3

     call    SysMsgBoardStr

     pop     esi

  end if

     stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_CHANNEL_STREAMID, 0

  if 0	; keep the format

     mov     eax, 1000000  ; wait 100 ms

     call    StallExec

     stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_STREAM_FORMAT, 0

  end if

     pop     eax

     ret

endp

     snd_hda_param_read  [nid], AC_PAR_PIN_CAP

     ret

endp

proc get_volume_mute stdcall, nid:dword, ch:dword, direction:dword, index:dword

     push    ebx

     mov     ebx, AC_AMP_GET_LEFT

     mov     eax, [ch]

     test    eax, eax

     jz      @f

     mov     ebx, AC_AMP_GET_RIGHT

  @@:

     mov     eax, [direction]

     cmp     eax, HDA_OUTPUT

     jne     @f

     or      ebx, AC_AMP_GET_OUTPUT

     jmp     .l1

  @@:

     or      ebx, AC_AMP_GET_INPUT

  .l1:

     or      ebx, [index]

     stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_AMP_GAIN_MUTE, ebx

     and     eax, 0xFF

     pop     ebx

     ret

endp

proc put_volume_mute stdcall, nid:dword, ch:dword, direction:dword, index:dword, val:dword

     push    eax  ebx

     mov     ebx, AC_AMP_SET_LEFT

     mov     eax, [ch]

     test    eax, eax

     jz      @f

     mov     ebx, AC_AMP_SET_RIGHT

  @@:

     mov     eax, [direction]

     cmp     eax, HDA_OUTPUT

     jne     @f

     or      ebx, AC_AMP_SET_OUTPUT

     jmp     .l1

  @@:

     or      ebx, AC_AMP_SET_INPUT

  .l1:

     mov     eax, [index]

     shl     eax, AC_AMP_SET_INDEX_SHIFT

     or      ebx, eax

     or      ebx, [val]

     stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_AMP_GAIN_MUTE, ebx

     pop     ebx  eax

     ret

endp

;; snd_hda_codec_amp_update - update the AMP value

;; @nid: NID to read the AMP value

;; @ch: channel (left=0 or right=1)

;; @direction: #HDA_INPUT or #HDA_OUTPUT

;; @idx: the index value (only for input direction)

;; @mask: bit mask to set

;; @val: the bits value to set

;;

;; Update the AMP value with a bit mask.

;; Returns 0 if the value is unchanged, 1 if changed.

;;

;-proc snd_hda_codec_amp_update stdcall, nid:dword, ch:dword, direction:dword, idx:dword, mask:dword, val:dword

;-     push    ebx  edx

;-     mov     eax, [mask]

;-     mov     ebx, [val]

;-     and     ebx, eax

;-     xor     eax, -1

;-     mov     edx, eax

;-     stdcall get_volume_mute, [nid], [ch], [direction], [idx]

;-     and     eax, edx

;-     or      ebx, eax

;-

;-     stdcall put_volume_mute, [nid], [ch], [direction], [idx], ebx

;-     xor     eax, eax

;-     inc     eax

;-     pop     edx  ebx

;-     ret

;-endp

;; snd_hda_codec_amp_stereo - update the AMP stereo values

;; @nid: NID to read the AMP value

;; @direction: #HDA_INPUT or #HDA_OUTPUT

;; @idx: the index value (only for input direction)

;; @mask: bit mask to set

;; @val: the bits value to set

;;

;; Update the AMP values like snd_hda_codec_amp_update(), but for a

;; stereo widget with the same mask and value.

;;

proc snd_hda_codec_amp_stereo stdcall, nid:dword, direction:dword, idx:dword, mask:dword, val:dword

     push    ebx edx

     mov     ebx, [val]

     mov     edx, [mask]

     and     ebx, edx

     stdcall put_volume_mute, [nid], 0, [direction], [idx], ebx

     stdcall put_volume_mute, [nid], 1, [direction], [idx], ebx

     pop     edx  ebx

     ret

endp

proc snd_hda_set_power_state stdcall, fg:dword, power_state:dword

     push    eax ebx ecx edx

     ; this delay seems necessary to avoid click noise at power down

     mov     ebx, [power_state]

     cmp     ebx, AC_PWRST_D3