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

	push	eax esi

	mov	esi, msgVerbQuery

	invoke	SysMsgBoardStr

	mov	eax, ebx

	stdcall fdword2str, 2

	invoke	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

	invoke	SysMsgBoardStr

	mov	eax, edx

	stdcall fdword2str, 2

	invoke	SysMsgBoardStr

	pop	esi eax

.end_debug:

end if

	;call   snd_hda_power_down

	cmp	edx, -1

	jne	.l1

	test	eax, eax

	jz	.l1

	jz	@f

	push	esi

	mov	esi, emsgBusResetFatalComm

	invoke	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

	ret

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

	invoke	SysMsgBoardStr

	mov	eax, [nid]

	stdcall fdword2str, 3

	invoke	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

	invoke	SysMsgBoardStr

	mov	eax, [nid]

	stdcall fdword2str, 1

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, ecx

	stdcall fdword2str, 0

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, [parm]

	stdcall fdword2str, 2

	invoke	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

	invoke	SysMsgBoardStr

	pop	esi

	push	eax

	mov	eax, esi

	stdcall fdword2str, 0

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	pop	eax

	stdcall fdword2str, 2

	invoke	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

	invoke	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

	invoke	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

	;Asper+: try to use another codec if possible [

if DEBUG

	push	esi

	mov	esi, msgNoAFGFound

	invoke	SysMsgBoardStr

	pop	esi

end  if

	push	ecx

	inc	eax

	mov	ecx, [codec.addr]

	shl	eax, cl

	pop	ecx

	cmp	eax, [ctrl.codec_mask]

	jl	.skip_codec

	;Asper+]

	test	eax, eax

	jnz	@f

if DEBUG

	push	esi

	mov	esi, emsgNoAFGorMFGFound

	invoke	SysMsgBoardStr

	pop	esi

end  if

.skip_codec:

	mov	eax, -1

	ret

@@:

	push	ebx

	stdcall read_widget_caps, eax

	jge	@f

if DEBUG

	push	esi

	mov	esi, emsgNoMem

	invoke	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

@@:

	; power up all before initialization

	stdcall snd_hda_set_power_state, ebx, AC_PWRST_D0

	pop	ebx

	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

	invoke	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

	invoke	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

	invoke	SysMsgBoardStr

	movzx	eax, [codec.chip_id]

	stdcall fdword2str, 2

	invoke	SysMsgBoardStr

	pop	esi edi ebx eax

	ret

endp

proc detect_chip stdcall, chip_tab:dword

	push	eax ebx edi esi

	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

	invoke	SysMsgBoardStr

	pop	esi  edi  ebx  eax

	ret

.next:

	add	edi, 8

	jmp	@b

.unknown:

	mov	[codec.chip_ids], chip_unknown

	mov	esi, chip_unknown

	invoke	SysMsgBoardStr

	movzx	eax, [codec.chip_id]

	stdcall fdword2str, 2

	invoke	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

	invoke	SysMsgBoardStr

	mov	eax, ebx

	stdcall fdword2str, 1

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, ecx

	stdcall fdword2str, 3

	invoke	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

	invoke	SysMsgBoardStr

	stdcall fdword2str, 3

	invoke	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

	invoke	SysMsgBoardStr

	mov	eax, ebx

	stdcall fdword2str, 1

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, ecx

	stdcall fdword2str, 3

	invoke	SysMsgBoardStr

	pop	esi eax

end if

	push	esi

	mov	esi, msgWCaps

	invoke	SysMsgBoardStr

	pop	esi

end if

	shl	eax, 2

	push	ebx ecx

	invoke	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

	invoke	Kmalloc

	pop	ecx ebx

	test	eax, eax

	jz	.err_out

	mov	[codec.init_pins], eax

	mov	[codec.num_pins], 0

	mov	edi, eax

	;Asper ]

	push	eax esi

	mov	esi, msgPinCfgs

	invoke	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	[codec.num_pins]

	inc	ebx

	dec	ecx

	jnz	.next_node

	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

	invoke	SysMsgBoardStr

	stdcall fdword2str, 3

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, [stream_tag]

	stdcall fdword2str, 3

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, [channel_id]

	stdcall fdword2str, 3

	invoke	SysMsgBoardStr

	invoke	SysMsgBoardStr

	mov	eax, [format]

	stdcall fdword2str, 3

	invoke	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

	invoke	SysMsgBoardStr

	stdcall fdword2str, 3

	invoke	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