WebSVN – Kolibri OS – Diff – /drivers/audio/intel_hda/hda_generic.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Universal Interface for Intel High Definition Audio Codec  ;
;                                                            ;
; Generic widget tree parser                                 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; widget node for parsing
struc HDA_GNODE
{
	.nid		    dw ?    ;NID of this widget
	.nconns 	    dw ?    ;number of input connections
	.conn_list	    dd ?
	.slist		    dw ?    ;temporary list
			    dw ?
 
	.wid_caps	    dd ?    ;widget capabilities
	.type		    db ?    ;widget type
	.pin_ctl	    db ?    ;pin controls
	.checked	    db ?    ;the flag indicates that the node is already parsed
	.pin_caps	    dd ?    ;pin widget capabilities
	.def_cfg	    dd ?    ;default configuration
	.amp_out_caps	    dd ?    ;AMP out capabilities
	.amp_in_caps	    dd ?    ;AMP in capabilities
	.next		    dd ? ;        struct list_head list
	.sizeof:
}
 
virtual at 0
	HDA_GNODE  HDA_GNODE
end virtual
 
struc HDA_GSPEC
{
	.dac_node	    dd ?    ;DAC node
			    dd ?
	.out_pin_node	    dd ?    ;Output pin (Line-Out) node
			    dd ?
 
	.def_amp_in_caps    dd ?
	.def_amp_out_caps   dd ?
 
;        .pcm_rec            dd ?    ;PCM information
	.nid_list	    dd 0    ;list of widgets
}
 
struc VOLUME_CTL
{
	.out_amp_node	    dd 0    ;Asper+ : To get/set volume
	.num_steps	    db ?    ; num_steps=NumSteps+1
	.step_size	    db ?    ; step_size=StepSize+1
	.maxDb		    dd ?    ; Max volume in Db.   maxDb=(num_steps*step_size/4*100)
}
 
; retrieve the default device type from the default config value
 
proc defcfg_type stdcall, node:dword
	push	 edx
	mov	 edx, [node]
	mov	 eax, [edx + HDA_GNODE.def_cfg]
	and	 eax, AC_DEFCFG_DEVICE
	shr	 eax, AC_DEFCFG_DEVICE_SHIFT
	pop	 edx
	ret
endp
 
proc defcfg_location stdcall, node:dword
	push	 edx
	mov	 edx, [node]
	mov	 eax, [edx + HDA_GNODE.def_cfg]
	and	 eax, AC_DEFCFG_LOCATION
	shr	 eax, AC_DEFCFG_LOCATION_SHIFT
	pop	 edx
	ret
endp
 
proc defcfg_port_conn stdcall, node:dword
	push	 edx
	mov	 edx, [node]
	mov	 eax, [edx + HDA_GNODE.def_cfg]
	and	 eax, AC_DEFCFG_PORT_CONN
	shr	 eax, AC_DEFCFG_PORT_CONN_SHIFT
	pop	 edx
	ret
endp
 
proc defcfg_color stdcall, node:dword
	push	 edx
	mov	 edx, [node]
	mov	 eax, [edx + HDA_GNODE.def_cfg]
	and	 eax, AC_DEFCFG_COLOR
	shr	 eax, AC_DEFCFG_COLOR_SHIFT
	pop	 edx
	ret
endp
 
 
; destructor
proc snd_hda_generic_free
	push	eax ebx edx edi
	; free all widgets
	mov	ebx, [spec.nid_list]  ; ebx = 1st node address
	test	ebx, ebx
	jz	.out
	mov	edx, [ebx + HDA_GNODE.next]  ;edx = 2nd node address
 
.next:
	test	edx, edx
	jz	.free_head
 
	mov	eax, [edx + HDA_GNODE.conn_list]
	lea	edi, [edx + HDA_GNODE.slist]
	cmp	eax, edi
	je	@f
	pusha
	invoke	Kfree  ;free conn_list
	popa
@@:
	mov	eax, edx
	mov	edx, [edx + HDA_GNODE.next]
	pusha
	invoke	Kfree  ;free node
	popa
	jmp	.next
.free_head:
	mov	eax, [spec.nid_list]
	pusha
	invoke	Kfree  ;free the very 1st node in the list
	popa
	mov	[spec.nid_list], 0
.out:
	pop	edi edx ebx eax
	ret
endp
 
 
; add a new widget node and read its attributes
proc add_new_node stdcall, nid:dword
	push	ebx ecx edx edi esi
 
	mov	eax, HDA_GNODE.sizeof
	invoke	Kmalloc
	test	eax, eax
	jz	.err_out   ; Not enough memory
 
	mov	edx, eax
;Asper+ [
	mov	edi, edx
	xor	eax, eax
	mov	ecx, HDA_GNODE.sizeof
	rep	stosb
;Asper+ ]
 
	mov	eax, [nid]
	mov	word [edx + HDA_GNODE.nid], ax
	stdcall get_wcaps, eax
	mov	[edx + HDA_GNODE.wid_caps], eax
	mov	ebx, eax
	stdcall get_wcaps_type, eax
	mov	byte [edx + HDA_GNODE.type], al
 
	mov	eax, HDA_MAX_CONNECTIONS*2  ;HDA_MAX_CONNECTIONS * sizeof(word)
	push	ebx ecx edx
	invoke	Kmalloc    ;malloc temporary conn_list
	pop	edx ecx ebx
	mov	edi, eax
 
	test	ebx, AC_WCAP_CONN_LIST
	jz	.no_conn_list
 
	stdcall snd_hda_get_connections, [nid], edi, HDA_MAX_CONNECTIONS
	mov	ecx, eax
	cmp	ecx, 0
	jge	@f
 
	mov	eax, edx
	pusha
	invoke	Kfree	   ;free node
	popa
	mov	eax, ecx
	jmp	.out
.no_conn_list:
 
	xor	ecx, ecx
@@:
	cmp	ecx, 2	   ;nconns <= ARRAY_SIZE(node->slist) ?
	jg	@f
 
	lea	eax, [edx + HDA_GNODE.slist]
	mov	[edx + HDA_GNODE.conn_list], eax
	jmp	.set_conn_list
@@:
	mov	eax, ecx
	shl	ecx, 1
	push	ebx ecx edx edi
	invoke	Kmalloc    ;malloc conn_list
	pop	edi edx ecx ebx
	shr	ecx, 1
	test	eax, eax
	jnz	@f
 
	mov	eax, edi
	pusha
	invoke	Kfree	   ;free temporary conn_list
	popa
	jmp	.err_out
@@:
	mov	[edx + HDA_GNODE.conn_list], eax
.set_conn_list:
	mov	[edx + HDA_GNODE.nconns], cx
	push	edi
	mov	esi, edi
	mov	edi, eax
	rep	movsw
	pop	edi
 
 
	mov	al, byte [edx + HDA_GNODE.type]
	test	al, AC_WID_PIN
	jz	@f
;Asper+ [
	cmp	al, AC_WID_VENDOR
	je	@f
;Asper+ ]
 
 
	stdcall read_pin_cap, [nid]
	mov	[edx + HDA_GNODE.pin_caps], eax
	stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0
	mov	byte [edx + HDA_GNODE.pin_ctl], al
	stdcall snd_hda_codec_get_pincfg, [nid]
	mov	[edx + HDA_GNODE.def_cfg], eax
@@:
 
	xor	eax, eax
	test	ebx, AC_WCAP_OUT_AMP
	jz	.no_out_amp
	test	ebx, AC_WCAP_AMP_OVRD
	jz	@f
	snd_hda_param_read [nid], AC_PAR_AMP_OUT_CAP
@@:
	test	eax, eax
	jnz	@f
	mov	eax, [spec.def_amp_out_caps]
@@:
	mov	[edx + HDA_GNODE.amp_out_caps], eax
.no_out_amp:
 
;;Asper+: Beeper [
;        pusha
;        mov     bl, byte [edx + HDA_GNODE.type]
;        cmp     bl, AC_WID_BEEP
;        jne     .not_beeper
;
;        mov     ebx, [nid]
;        mov     [codec.beeper_nid], bx
;
;        test    eax, eax
;        jz      .no_beeper_amp
;        ;set beep amplifier here
;        stdcall unmute_output, edx
;.no_beeper_amp:
;        ;try to beep here
;        stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax
;if DEBUG
;        push    eax esi
;        mov     esi, msgBeeperNid
;        invoke  SysMsgBoardStr
;        push    eax
;        mov     eax, [nid]
;        stdcall fdword2str, 2
;        invoke  SysMsgBoardStr
;
;        mov     esi, msgBeeperValue
;        invoke  SysMsgBoardStr
;        pop     eax
;        stdcall fdword2str, 2
;        invoke  SysMsgBoardStr
;
;        mov     esi, msgBeepNow
;        invoke  SysMsgBoardStr
;        pop     esi eax
;end if
;        mov     ecx, 256*1
;.next_tone:
;        dec     ecx
;        movzx   ebx, [esi + HDA_GNODE.nid]
;        stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_BEEP_CONTROL, ecx
;        ;mov     eax, 0x8000
;        ;stdcall StallExec
;        test    ecx, ecx
;        jnz     .next_tone
;.end_beep:
;        stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax
;if DEBUG
;        ;push    eax esi
;        mov     esi, msgBeeperValue
;        invoke  SysMsgBoardStr
;        stdcall  fdword2str, 2
;        invoke   SysMsgBoardStr
;        ;pop      esi eax
;end if
;.not_beeper:
;        popa
;;Asper+: Beeper ]
 
	xor	eax, eax
	test	ebx, AC_WCAP_IN_AMP
	jz	.no_in_amp
	test	ebx, AC_WCAP_AMP_OVRD
	jz	@f
	snd_hda_param_read [nid], AC_PAR_AMP_IN_CAP
@@:
	test	eax, eax
	jnz	@f
	mov	eax, [spec.def_amp_in_caps]
@@:
	mov	[edx + HDA_GNODE.amp_in_caps], eax
.no_in_amp:
 
	mov	esi, [spec.nid_list]
	test	esi, esi
	jnz	@f
	mov	[spec.nid_list], edx
	jmp	.out
@@:
 
	;Asper+: Sort pins by DA:Sequence during tree building [
	mov	ecx, esi
	movzx	ebx, byte [edx + HDA_GNODE.def_cfg]
	push	edi
.next_node:
	cmp	[esi + HDA_GNODE.type], AC_WID_PIN
	jne	@f
	cmp	[edx + HDA_GNODE.type], AC_WID_PIN
	je	.pin
 
	mov	edi, [spec.nid_list]
	cmp	[edi + HDA_GNODE.type], AC_WID_PIN
	jne	.not_pin
	mov	[edx + HDA_GNODE.next], edi
.head:						   ;CleverMouse+
	mov	[spec.nid_list], edx
	pop	edi
	jmp	.out
.pin:
	movzx	edi, byte [esi + HDA_GNODE.def_cfg]
	cmp	edi, ebx
	jle	@f
.not_pin:
	mov	[edx + HDA_GNODE.next], esi
	cmp	esi, [spec.nid_list]			;CleverMouse+
	jz	.head					;CleverMouse+
	mov	esi, ecx
	jmp	.insert
@@:
	mov	eax, [esi + HDA_GNODE.next]
	test	eax, eax
	jz	.insert
	mov	ecx, esi
	mov	esi, eax
	jmp	.next_node
.insert:
	mov	[esi + HDA_GNODE.next], edx
	pop	edi
	;Asper+ ]
 
.out:
	mov	eax, edi
	pusha
	invoke	Kfree	  ;free temporary conn_list
	popa
	xor	eax, eax
	pop	esi edi edx ecx ebx
	ret
 
.err_out:
	mov	eax, edx
	pusha
	invoke	Kfree	  ;free node
	popa
	xor	eax, eax
	dec	eax
	pop	esi edi edx ecx ebx
	ret
endp
 
 
 
; build the AFG subtree
proc build_afg_tree
	push	ebx ecx edx
 
	mov	ebx, [codec.afg]
	snd_hda_param_read  ebx, AC_PAR_AMP_OUT_CAP
 
	mov	[spec.def_amp_out_caps], eax
	snd_hda_param_read  ebx, AC_PAR_AMP_IN_CAP
	mov	[spec.def_amp_in_caps], eax
 
	stdcall snd_hda_get_sub_nodes, ebx
	mov	ecx, eax
	and	ecx, 0xFFFF    ;ecx = nodes number
	mov	edx, eax
	shr	edx, 16        ;eax = address of the first nid
 
	test	edx, edx
	jz	@f
	cmp	ecx, 0
	jge	.nid_ok
@@:
if  FDEBUG
	push	esi
	mov	esi, emsgInvalidAFGSubtree
	invoke	SysMsgBoardStr
	pop	esi
end if
	xor	eax, eax
	dec	eax
	jmp	.out
.nid_ok:
 
	; parse all nodes belonging to the AFG
.next_node:
	test	ecx, ecx
	jz	.build_done
 
	stdcall add_new_node, edx
	test	eax, eax
	jnz	.out
	inc	edx
	dec	ecx
	jmp	.next_node
.build_done:
	xor	eax, eax
.out:
	pop	edx ecx ebx
	ret
endp
 
;Asper+[
proc print_afg_tree_nodes
	push	eax esi edi
	mov	esi, msgNodeSeq
	invoke	SysMsgBoardStr
 
	mov	edi, [spec.nid_list]
	test	edi, edi
	jz	.out
.next_node:
	movzx	eax, word [edi + HDA_GNODE.nid]
	mov	esi, msgNID
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
 
	mov	eax, [edi + HDA_GNODE.next]
	test	eax, eax
	jz	.out
 
	mov	edi, eax
	jmp	.next_node
.out:
	pop	edi esi eax
	ret
endp
;Asper+]
 
; look for the node record for the given NID
proc hda_get_node stdcall, nid:dword
	push	ebx edx esi
	movzx	ebx, word [nid]
	mov	esi, [spec.nid_list]
	test	esi, esi
	jz	.out
 
.next_node:
	mov	edx, [esi + HDA_GNODE.next]
	test	edx, edx   ;Asper+
	jz	.not_found ;Asper+
	mov	ax, word [esi + HDA_GNODE.nid]
	cmp	ax, bx
	je	.out
	mov	esi, edx
	jmp	.next_node
 
.not_found: ;Asper+
	xor	esi, esi
.out:
	mov	eax, esi
	pop	esi edx ebx
	ret
endp
 
;Asper+[
proc set_eapd stdcall, node:dword ;nid:dword, on:dword
	push	eax ebx esi
	mov	esi, [node]
	cmp	[esi + HDA_GNODE.type], AC_WID_PIN
	jne	.out
	; eapd capable?
	test	[esi + HDA_GNODE.pin_caps], AC_PINCAP_EAPD
	jz	.out
	;stdcall snd_hda_codec_read, ebx, 0, AC_VERB_GET_EAPD_BTLENABLE, AC_EAPDBTL_EAPD
	;or      eax, AC_EAPDBTL_EAPD
	movzx	ebx, [esi + HDA_GNODE.nid]
	stdcall snd_hda_codec_write, ebx, 0, AC_VERB_SET_EAPD_BTLENABLE, AC_EAPDBTL_EAPD ;eax
if  DEBUG
	push	eax esi
	mov	esi, msgEnableEAPD
	invoke	SysMsgBoardStr
	mov	eax, ebx
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi eax
      end if
.out:
	pop	esi ebx eax
	ret
endp
;Asper+]
 
; unmute (and set max vol) the output amplifier
proc unmute_output stdcall, node:dword
 
	push	ebx ecx edx esi
	mov	esi, [node]
	test	[esi + HDA_GNODE.wid_caps], AC_WCAP_OUT_AMP
	jz	.out
	movzx	eax, word [esi + HDA_GNODE.nid]
if  DEBUG
	push	esi
	mov	esi, msgUnmuteOut
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi
end if
 
	stdcall set_eapd, esi ;Asper+: set EAPD if exist
 
	mov	ebx, eax
	mov	eax, [esi + HDA_GNODE.amp_out_caps]
	mov	ecx, eax
 
	and	eax, AC_AMPCAP_NUM_STEPS
	shr	eax, AC_AMPCAP_NUM_STEPS_SHIFT
 
	stdcall snd_hda_codec_amp_stereo, ebx, HDA_OUTPUT, 0, 0xFF, eax
 
	and	ecx, AC_AMPCAP_STEP_SIZE
	shr	ecx, AC_AMPCAP_STEP_SIZE_SHIFT
 
	test	al, al
	jz	.out
if  DEBUG
	push	eax esi
	mov	esi, msgAmpVal
	invoke	SysMsgBoardStr
	stdcall fdword2str, 1
	invoke	SysMsgBoardStr
 
	mov	esi, strSemicolon
	invoke	SysMsgBoardStr
	mov	eax, ecx
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi eax
end if
	mov	[volume.out_amp_node], esi
 
	mov	[volume.num_steps], al
 
	mov	[volume.step_size], cl
	mul	cl
 
	imul	eax, (100/4)
	mov	[volume.maxDb], eax
 
.out:
	xor	eax, eax
	pop	esi edx ecx ebx
	ret
endp
 
; unmute (and set max vol) the input amplifier
proc unmute_input stdcall, node:dword, index:dword
	push	ecx edx esi
	test	[esi + HDA_GNODE.wid_caps], AC_WCAP_IN_AMP
	jz	.out
	and	[index], 0xF ;Asper+ : Ranger
	mov	esi, [node]
	movzx	eax, word [esi + HDA_GNODE.nid]
if  DEBUG
	push	eax esi
	mov	esi, msgUnmuteIn
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	mov	esi, msgIdx
	invoke	SysMsgBoardStr
	mov	eax, [index]
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi eax
end if
 
	mov	edx, [esi + HDA_GNODE.amp_in_caps]
	mov	ecx, edx
 
	and	edx, AC_AMPCAP_NUM_STEPS
	shr	edx, AC_AMPCAP_NUM_STEPS_SHIFT
 
	stdcall snd_hda_codec_amp_stereo, eax, HDA_INPUT, [index], 0xFF, edx
.out:
	xor	eax, eax
	pop	esi edx ecx
	ret
endp
 
 
; select the input connection of the given node.
proc select_input_connection stdcall, node:dword, index:dword
	push	ebx esi
	mov	esi, [node]
	movzx	eax, word [esi + HDA_GNODE.nid]
	mov	ebx, [index]
if DEBUG
	mov	esi, msgConnect
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
 
	mov	esi, msgIdx
	invoke	SysMsgBoardStr
	push	eax
	mov	eax, ebx
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	eax
end if
	stdcall snd_hda_codec_write, eax, 0, AC_VERB_SET_CONNECT_SEL, ebx
	pop	esi ebx
	ret
endp
 
 
; clear checked flag of each node in the node list
proc clear_check_flags
	push	eax esi
	mov	esi, [spec.nid_list]
	test	esi, esi
	jz	.out
.next_node:
	mov	byte [esi + HDA_GNODE.checked], 0
	mov	eax, [esi + HDA_GNODE.next]
	test	eax, eax
	jz	.out
	mov	esi, eax
	jmp	.next_node
 
.out:
	pop	esi eax
	ret
endp
 
;
; parse the output path recursively until reach to an audio output widget
;
; returns 0 if not found, 1 if found, or a negative error code.
;
proc parse_output_path stdcall, node:dword, dac_idx:dword
	push	ebx ecx edx esi
	mov	esi, [node]
	mov	al, byte [esi + HDA_GNODE.checked]
	test	al, al
	jnz	.ret_zero
 
	mov	byte [esi + HDA_GNODE.checked], 1
 
	mov	al, byte [esi + HDA_GNODE.type]
	cmp	al, AC_WID_AUD_OUT
	jne	.not_wid_aud_out
 
	movzx	eax, word [esi + HDA_GNODE.nid]
	mov	ebx, [esi + HDA_GNODE.wid_caps]
	test	ebx, AC_WCAP_DIGITAL
	jz	@f
if DEBUG
	push	esi
	mov	esi, msgSkipDigitalOutNode
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi
end if
	jmp	.ret_zero
@@:
if DEBUG
	push	eax esi
	mov	esi, msgAudOutFound
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
	pop	esi eax
end if
 
	push	eax
	stdcall unmute_output, esi ;Asper+
	pop	eax
	mov	ecx, [dac_idx]
	shl	ecx, 2
	push	eax
	mov	eax, [spec.dac_node+ecx]
	test	eax, eax
	pop	eax
	jz	@f
	; already DAC node is assigned, just unmute & connect
	cmp	eax, [node]
	je	.ret_one
	jmp	.ret_zero
@@:
	mov	ecx, [dac_idx]
	shl	ecx, 2
	mov	[spec.dac_node+ecx], eax
	jmp	.ret_one   ;found
.not_wid_aud_out:
	movzx	ebx, [esi + HDA_GNODE.nconns]
	xor	ecx, ecx
	mov	edx, [esi + HDA_GNODE.conn_list]
	test	ebx, ebx
	jz	.ret_zero
.next_node:
	stdcall hda_get_node, [edx]
	test	eax, eax
	jz	.continue
 
	stdcall parse_output_path, eax, [dac_idx]
 
	cmp	[esi + HDA_GNODE.nconns], 1
	jle	@f
	stdcall select_input_connection, esi, ecx
@@:
;UNSUPPORTED YET!        stdcall unmute_input, esi, ecx
	stdcall unmute_output, esi
	jmp	.ret_one
 
.continue:
	add	edx, 2
	inc	ecx
	cmp	ecx, ebx
	jl	.next_node
.ret_zero:
	xor	eax, eax
	pop	esi edx ecx ebx
	ret
.ret_one:
	xor	eax, eax
	inc	eax
.ret: ;Asper+
	pop	esi edx ecx ebx
	ret
endp
 
; Look for the output PIN widget with the given jack type
; and parse the output path to that PIN.
;
; Returns the PIN node when the path to DAC is established.
proc parse_output_jack stdcall, jack_type:dword
	push	edx esi
 
	mov	esi, [spec.nid_list]
	test	esi, esi
	jz	.ret_zero
.next_pin:
	cmp	[esi + HDA_GNODE.type], AC_WID_PIN
	jne	.continue
 
	; output capable?
	mov	eax, [esi + HDA_GNODE.pin_caps]
	test	eax, AC_PINCAP_OUT
	jz	.continue
 
	stdcall defcfg_port_conn, esi
	cmp	eax, AC_JACK_PORT_NONE
	je	.continue  ;unconnected
 
	mov	edx, [jack_type]
	cmp	edx, 0
	jl	@f
 
	stdcall defcfg_type, esi
	cmp	edx, eax
	jne	.continue
 
	test	[esi + HDA_GNODE.wid_caps], AC_WCAP_DIGITAL
	jnz	.continue ; skip SPDIF
@@:
	push	eax
	movzx	eax, [esi + HDA_GNODE.nid]
	stdcall snd_hda_enable_pin_sense, eax, eax	;Asper+: enable unsolicited events for the output pin
	pop	eax
 
if DEBUG
	pusha
;        push    esi
;        mov     esi, msgPin_Nid
;        invoke  SysMsgBoardStr
;        pop     esi
	movzx	eax, [esi + HDA_GNODE.nid]
	movzx	ebx, [esi + HDA_GNODE.pin_ctl]
	mov	ecx, [esi + HDA_GNODE.pin_caps]
	mov	edx, [esi + HDA_GNODE.def_cfg]
	mov	edi, [esi + HDA_GNODE.amp_out_caps]
	mov	esi, msgPin_Nid
	invoke	SysMsgBoardStr
	stdcall fdword2str, 3
	invoke	SysMsgBoardStr
 
	mov	esi, msgPin_Ctl
	invoke	SysMsgBoardStr
	mov	eax, ebx
	stdcall fdword2str, 2
	invoke	SysMsgBoardStr
 
	mov	esi, msgPin_Caps
	invoke	SysMsgBoardStr
	mov	eax, ecx
	stdcall fdword2str, 2
	invoke	SysMsgBoardStr
 
	mov	esi, msgDef_Cfg
	invoke	SysMsgBoardStr
	mov    eax, edx
	stdcall fdword2str, 2
	invoke	SysMsgBoardStr
 
	mov    esi, msgAmp_Out_Caps
 
	invoke	SysMsgBoardStr
	mov    eax, edi
	stdcall fdword2str, 2
	invoke	SysMsgBoardStr
	popa
end if
	; output as default?
;        test    [esi + HDA_GNODE.pin_ctl], AC_PINCTL_OUT_EN
;        jz      .continue
.use_dac0:
	cmp	[spec.dac_node], 0
	jne	.use_dac1
 
	stdcall clear_check_flags
	stdcall parse_output_path, esi, 0
 
	test	eax, eax
	jnz	@f
	mov	edx, [spec.out_pin_node]
	test	edx, edx
	jz	@f
.use_dac1:
	stdcall clear_check_flags
	stdcall parse_output_path, esi, 1
@@:
	cmp	eax, 0
	jle	.l1
 
	; unmute the PIN output
	stdcall unmute_output, esi
	; set PIN-Out enable
	xor	edx, edx
	test	[esi + HDA_GNODE.pin_caps], AC_PINCAP_HP_DRV
	jz	@f
	mov	edx, AC_PINCTL_HP_EN
@@:
	or	edx, AC_PINCTL_OUT_EN
	movzx	eax, [esi + HDA_GNODE.nid]
	stdcall snd_hda_codec_write, eax, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, edx
	mov	eax, esi
	jmp	.out
.l1:
.continue:
	mov	edx, [esi + HDA_GNODE.next]
	test	edx, edx
	jz	.ret_zero
	mov	esi, edx
	jmp	.next_pin
.ret_zero:
	xor	eax, eax
.out:
	pop	esi edx
	ret
endp
 
 
; parse outputs
proc parse_output
	push	edx
	; Look for the output PIN widget
	;
	; first, look for the line-out pin
	stdcall parse_output_jack, AC_JACK_LINE_OUT
	test	eax, eax
	jz	@f
	mov	[spec.out_pin_node], eax   ; found, remember the PIN node
	jmp	.l1
@@:
	; if no line-out is found, try speaker out
	stdcall parse_output_jack, AC_JACK_SPEAKER
	test	eax, eax
	jz	.l1
	mov	[spec.out_pin_node], eax   ; found, remember the PIN node
.l1:
	; look for the HP-out pin
	stdcall parse_output_jack, AC_JACK_HP_OUT
	test	eax, eax
	jz	.l2
 
	mov	edx, [spec.out_pin_node]
	test	edx, edx
	jnz	@f
	mov	[spec.out_pin_node], eax
	jmp	.l2
@@:
	mov	[spec.out_pin_node+4], eax
.l2:
	mov	edx, [spec.out_pin_node]
	test	edx, edx
	jnz	@f
	; no line-out or HP pins found,
	; then choose for the first output pin
	stdcall parse_output_jack, -1
 
	mov	[spec.out_pin_node], eax
	test	eax, eax
	jnz	@f
if DEBUG
	push	esi
	mov	esi, emsgNoProperOutputPathFound
	invoke	SysMsgBoardStr
	pop	esi
end if
@@:
	pop	edx
	xor	eax, eax
	ret
endp
 
 
;(...)  Skip functions for the input (capture is not supported).
 
; the generic parser
proc snd_hda_parse_generic_codec
	mov	eax, [codec.afg]
	test	eax, eax
	jz	.out
 
	stdcall build_afg_tree
	cmp	eax, 0
	jl	.error
 
if  FDEBUG
	stdcall print_afg_tree_nodes ;Asper+
end if
 
	stdcall parse_output
	xor	eax, eax
.out:
	ret
.error:
	stdcall snd_hda_generic_free
	ret
endp
 
 
; some data
spec HDA_GSPEC
volume VOLUME_CTL

Rev 3083	Rev 5048
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	; Universal Interface for Intel High Definition Audio Codec ;	2	; Universal Interface for Intel High Definition Audio Codec ;
3	; ;	3	; ;
4	; Generic widget tree parser ;	4	; Generic widget tree parser ;
5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6		6
7	; widget node for parsing	7	; widget node for parsing
8	struc HDA_GNODE	8	struc HDA_GNODE
9	{	9	{
10	.nid dw ? ;NID of this widget	10	.nid dw ? ;NID of this widget
11	.nconns dw ? ;number of input connections	11	.nconns dw ? ;number of input connections
12	.conn_list dd ?	12	.conn_list dd ?
13	.slist dw ? ;temporary list	13	.slist dw ? ;temporary list
14	dw ?	14	dw ?
15		15
16	.wid_caps dd ? ;widget capabilities	16	.wid_caps dd ? ;widget capabilities
17	.type db ? ;widget type	17	.type db ? ;widget type
18	.pin_ctl db ? ;pin controls	18	.pin_ctl db ? ;pin controls
19	.checked db ? ;the flag indicates that the node is already parsed	19	.checked db ? ;the flag indicates that the node is already parsed
20	.pin_caps dd ? ;pin widget capabilities	20	.pin_caps dd ? ;pin widget capabilities
21	.def_cfg dd ? ;default configuration	21	.def_cfg dd ? ;default configuration
22	.amp_out_caps dd ? ;AMP out capabilities	22	.amp_out_caps dd ? ;AMP out capabilities
23	.amp_in_caps dd ? ;AMP in capabilities	23	.amp_in_caps dd ? ;AMP in capabilities
24	.next dd ? ; struct list_head list	24	.next dd ? ; struct list_head list
25	.sizeof:	25	.sizeof:
26	}	26	}
27		27
28	virtual at 0	28	virtual at 0
29	HDA_GNODE HDA_GNODE	29	HDA_GNODE HDA_GNODE
30	end virtual	30	end virtual
31		31
32	struc HDA_GSPEC	32	struc HDA_GSPEC
33	{	33	{
34	.dac_node dd ? ;DAC node	34	.dac_node dd ? ;DAC node
35	dd ?	35	dd ?
36	.out_pin_node dd ? ;Output pin (Line-Out) node	36	.out_pin_node dd ? ;Output pin (Line-Out) node
37	dd ?	37	dd ?
38		38
39	.def_amp_in_caps dd ?	39	.def_amp_in_caps dd ?
40	.def_amp_out_caps dd ?	40	.def_amp_out_caps dd ?
41		41
42	; .pcm_rec dd ? ;PCM information	42	; .pcm_rec dd ? ;PCM information
43	.nid_list dd 0 ;list of widgets	43	.nid_list dd 0 ;list of widgets
44	}	44	}
45		45
46	struc VOLUME_CTL	46	struc VOLUME_CTL
47	{	47	{
48	.out_amp_node dd 0 ;Asper+ : To get/set volume	48	.out_amp_node dd 0 ;Asper+ : To get/set volume
49	.num_steps db ? ; num_steps=NumSteps+1	49	.num_steps db ? ; num_steps=NumSteps+1
50	.step_size db ? ; step_size=StepSize+1	50	.step_size db ? ; step_size=StepSize+1
51	.maxDb dd ? ; Max volume in Db. maxDb=(num_stepsstep_size/4100)	51	.maxDb dd ? ; Max volume in Db. maxDb=(num_stepsstep_size/4100)
52	}	52	}
53		53
54	; retrieve the default device type from the default config value	54	; retrieve the default device type from the default config value
55		-
56	proc defcfg_type stdcall, node:dword	55	proc defcfg_type stdcall, node:dword
57	push edx	56	push edx
58	mov edx, [node]	57	mov edx, [node]
59	mov eax, [edx + HDA_GNODE.def_cfg]	58	mov eax, [edx + HDA_GNODE.def_cfg]
60	and eax, AC_DEFCFG_DEVICE	59	and eax, AC_DEFCFG_DEVICE
61	shr eax, AC_DEFCFG_DEVICE_SHIFT	60	shr eax, AC_DEFCFG_DEVICE_SHIFT
62	pop edx	61	pop edx
63	ret	62	ret
64	endp	63	endp
65		64
66	proc defcfg_location stdcall, node:dword	65	proc defcfg_location stdcall, node:dword
67	push edx	66	push edx
68	mov edx, [node]	67	mov edx, [node]
69	mov eax, [edx + HDA_GNODE.def_cfg]	68	mov eax, [edx + HDA_GNODE.def_cfg]
70	and eax, AC_DEFCFG_LOCATION	69	and eax, AC_DEFCFG_LOCATION
71	shr eax, AC_DEFCFG_LOCATION_SHIFT	70	shr eax, AC_DEFCFG_LOCATION_SHIFT
72	pop edx	71	pop edx
73	ret	72	ret
74	endp	73	endp
75		74
76	proc defcfg_port_conn stdcall, node:dword	75	proc defcfg_port_conn stdcall, node:dword
77	push edx	76	push edx
78	mov edx, [node]	77	mov edx, [node]
79	mov eax, [edx + HDA_GNODE.def_cfg]	78	mov eax, [edx + HDA_GNODE.def_cfg]
80	and eax, AC_DEFCFG_PORT_CONN	79	and eax, AC_DEFCFG_PORT_CONN
81	shr eax, AC_DEFCFG_PORT_CONN_SHIFT	80	shr eax, AC_DEFCFG_PORT_CONN_SHIFT
82	pop edx	81	pop edx
83	ret	82	ret
84	endp	83	endp
85		84
86	proc defcfg_color stdcall, node:dword	85	proc defcfg_color stdcall, node:dword
87	push edx	86	push edx
88	mov edx, [node]	87	mov edx, [node]
89	mov eax, [edx + HDA_GNODE.def_cfg]	88	mov eax, [edx + HDA_GNODE.def_cfg]
90	and eax, AC_DEFCFG_COLOR	89	and eax, AC_DEFCFG_COLOR
91	shr eax, AC_DEFCFG_COLOR_SHIFT	90	shr eax, AC_DEFCFG_COLOR_SHIFT
92	pop edx	91	pop edx
93	ret	92	ret
94	endp	93	endp
95		-
96		94
97	; destructor	95	; destructor
98	proc snd_hda_generic_free	96	proc snd_hda_generic_free
99	push eax ebx edx edi	97	push eax ebx edx edi
100	; free all widgets	98	; free all widgets
101	mov ebx, [spec.nid_list] ; ebx = 1st node address	99	mov ebx, [spec.nid_list] ; ebx = 1st node address
102	test ebx, ebx	100	test ebx, ebx
103	jz .out	101	jz .out
104	mov edx, [ebx + HDA_GNODE.next] ;edx = 2nd node address	102	mov edx, [ebx + HDA_GNODE.next] ;edx = 2nd node address
105		103
106	.next:	104	.next:
107	test edx, edx	105	test edx, edx
108	jz .free_head	106	jz .free_head
109		107
110	mov eax, [edx + HDA_GNODE.conn_list]	108	mov eax, [edx + HDA_GNODE.conn_list]
111	lea edi, [edx + HDA_GNODE.slist]	109	lea edi, [edx + HDA_GNODE.slist]
112	cmp eax, edi	110	cmp eax, edi
113	je @f	111	je @f
114	pusha	112	pusha
115	call Kfree ;free conn_list	113	invoke Kfree ;free conn_list
116	popa	114	popa
117	@@:	115	@@:
118	mov eax, edx	116	mov eax, edx
119	mov edx, [edx + HDA_GNODE.next]	117	mov edx, [edx + HDA_GNODE.next]
120	pusha	118	pusha
121	call Kfree ;free node	119	invoke Kfree ;free node
122	popa	120	popa
123	jmp .next	121	jmp .next
124	.free_head:	122	.free_head:
125	mov eax, [spec.nid_list]	123	mov eax, [spec.nid_list]
126	pusha	124	pusha
127	call Kfree ;free the very 1st node in the list	125	invoke Kfree ;free the very 1st node in the list
128	popa	126	popa
129	mov [spec.nid_list], 0	127	mov [spec.nid_list], 0
130	.out:	128	.out:
131	pop edi edx ebx eax	129	pop edi edx ebx eax
132	ret	130	ret
133	endp	131	endp
134		132
135		133
136	; add a new widget node and read its attributes	134	; add a new widget node and read its attributes
137	proc add_new_node stdcall, nid:dword	135	proc add_new_node stdcall, nid:dword
138	push ebx ecx edx edi esi	136	push ebx ecx edx edi esi
139		137
140	mov eax, HDA_GNODE.sizeof	138	mov eax, HDA_GNODE.sizeof
141	call Kmalloc	139	invoke Kmalloc
142	test eax, eax	140	test eax, eax
143	jz .err_out ; Not enough memory	141	jz .err_out ; Not enough memory
144		142
145	mov edx, eax	143	mov edx, eax
146	;Asper+ [	144	;Asper+ [
147	mov edi, edx	145	mov edi, edx
148	xor eax, eax	146	xor eax, eax
149	mov ecx, HDA_GNODE.sizeof	147	mov ecx, HDA_GNODE.sizeof
150	rep stosb	148	rep stosb
151	;Asper+ ]	149	;Asper+ ]
152		150
153	mov eax, [nid]	151	mov eax, [nid]
154	mov word [edx + HDA_GNODE.nid], ax	152	mov word [edx + HDA_GNODE.nid], ax
155	stdcall get_wcaps, eax	153	stdcall get_wcaps, eax
156	mov [edx + HDA_GNODE.wid_caps], eax	154	mov [edx + HDA_GNODE.wid_caps], eax
157	mov ebx, eax	155	mov ebx, eax
158	stdcall get_wcaps_type, eax	156	stdcall get_wcaps_type, eax
159	mov byte [edx + HDA_GNODE.type], al	157	mov byte [edx + HDA_GNODE.type], al
160		158
161	mov eax, HDA_MAX_CONNECTIONS2 ;HDA_MAX_CONNECTIONS sizeof(word)	159	mov eax, HDA_MAX_CONNECTIONS2 ;HDA_MAX_CONNECTIONS sizeof(word)
162	push ebx ecx edx	160	push ebx ecx edx
163	call Kmalloc ;malloc temporary conn_list	161	invoke Kmalloc ;malloc temporary conn_list
164	pop edx ecx ebx	162	pop edx ecx ebx
165	mov edi, eax	163	mov edi, eax
166		164
167	test ebx, AC_WCAP_CONN_LIST	165	test ebx, AC_WCAP_CONN_LIST
168	jz .no_conn_list	166	jz .no_conn_list
169		167
170	stdcall snd_hda_get_connections, [nid], edi, HDA_MAX_CONNECTIONS	168	stdcall snd_hda_get_connections, [nid], edi, HDA_MAX_CONNECTIONS
171	mov ecx, eax	169	mov ecx, eax
172	cmp ecx, 0	170	cmp ecx, 0
173	jge @f	171	jge @f
174		172
175	mov eax, edx	173	mov eax, edx
176	pusha	174	pusha
177	call Kfree ;free node	175	invoke Kfree ;free node
178	popa	176	popa
179	mov eax, ecx	177	mov eax, ecx
180	jmp .out	178	jmp .out
181	.no_conn_list:	179	.no_conn_list:
182		180
183	xor ecx, ecx	181	xor ecx, ecx
184	@@:	182	@@:
185	cmp ecx, 2 ;nconns <= ARRAY_SIZE(node->slist) ?	183	cmp ecx, 2 ;nconns <= ARRAY_SIZE(node->slist) ?
186	jg @f	184	jg @f
187		185
188	lea eax, [edx + HDA_GNODE.slist]	186	lea eax, [edx + HDA_GNODE.slist]
189	mov [edx + HDA_GNODE.conn_list], eax	187	mov [edx + HDA_GNODE.conn_list], eax
190	jmp .set_conn_list	188	jmp .set_conn_list
191	@@:	189	@@:
192	mov eax, ecx	190	mov eax, ecx
193	shl ecx, 1	191	shl ecx, 1
194	push ebx ecx edx edi	192	push ebx ecx edx edi
195	call Kmalloc ;malloc conn_list	193	invoke Kmalloc ;malloc conn_list
196	pop edi edx ecx ebx	194	pop edi edx ecx ebx
197	shr ecx, 1	195	shr ecx, 1
198	test eax, eax	196	test eax, eax
199	jnz @f	197	jnz @f
200		198
201	mov eax, edi	199	mov eax, edi
202	pusha	200	pusha
203	call Kfree ;free temporary conn_list	201	invoke Kfree ;free temporary conn_list
204	popa	202	popa
205	jmp .err_out	203	jmp .err_out
206	@@:	204	@@:
207	mov [edx + HDA_GNODE.conn_list], eax	205	mov [edx + HDA_GNODE.conn_list], eax
208	.set_conn_list:	206	.set_conn_list:
209	mov [edx + HDA_GNODE.nconns], cx	207	mov [edx + HDA_GNODE.nconns], cx
210	push edi	208	push edi
211	mov esi, edi	209	mov esi, edi
212	mov edi, eax	210	mov edi, eax
213	rep movsw	211	rep movsw
214	pop edi	212	pop edi
215		213
216		214
217	mov al, byte [edx + HDA_GNODE.type]	215	mov al, byte [edx + HDA_GNODE.type]
218	test al, AC_WID_PIN	216	test al, AC_WID_PIN
219	jz @f	217	jz @f
220	;Asper+ [	218	;Asper+ [
221	cmp al, AC_WID_VENDOR	219	cmp al, AC_WID_VENDOR
222	je @f	220	je @f
223	;Asper+ ]	221	;Asper+ ]
224		222
225		223
226	stdcall read_pin_cap, [nid]	224	stdcall read_pin_cap, [nid]
227	mov [edx + HDA_GNODE.pin_caps], eax	225	mov [edx + HDA_GNODE.pin_caps], eax
228	stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0	226	stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0
229	mov byte [edx + HDA_GNODE.pin_ctl], al	227	mov byte [edx + HDA_GNODE.pin_ctl], al
230	stdcall snd_hda_codec_get_pincfg, [nid]	228	stdcall snd_hda_codec_get_pincfg, [nid]
231	mov [edx + HDA_GNODE.def_cfg], eax	229	mov [edx + HDA_GNODE.def_cfg], eax
232	@@:	230	@@:
233		231
234	xor eax, eax	232	xor eax, eax
235	test ebx, AC_WCAP_OUT_AMP	233	test ebx, AC_WCAP_OUT_AMP
236	jz .no_out_amp	234	jz .no_out_amp
237	test ebx, AC_WCAP_AMP_OVRD	235	test ebx, AC_WCAP_AMP_OVRD
238	jz @f	236	jz @f
239	snd_hda_param_read [nid], AC_PAR_AMP_OUT_CAP	237	snd_hda_param_read [nid], AC_PAR_AMP_OUT_CAP
240	@@:	238	@@:
241	test eax, eax	239	test eax, eax
242	jnz @f	240	jnz @f
243	mov eax, [spec.def_amp_out_caps]	241	mov eax, [spec.def_amp_out_caps]
244	@@:	242	@@:
245	mov [edx + HDA_GNODE.amp_out_caps], eax	243	mov [edx + HDA_GNODE.amp_out_caps], eax
246	.no_out_amp:	244	.no_out_amp:
247		245
248	;;Asper+: Beeper [	246	;;Asper+: Beeper [
249	; pusha	247	; pusha
250	; mov bl, byte [edx + HDA_GNODE.type]	248	; mov bl, byte [edx + HDA_GNODE.type]
251	; cmp bl, AC_WID_BEEP	249	; cmp bl, AC_WID_BEEP
252	; jne .not_beeper	250	; jne .not_beeper
253	;	251	;
254	; mov ebx, [nid]	252	; mov ebx, [nid]
255	; mov [codec.beeper_nid], bx	253	; mov [codec.beeper_nid], bx
256	;	254	;
257	; test eax, eax	255	; test eax, eax
258	; jz .no_beeper_amp	256	; jz .no_beeper_amp
259	; ;set beep amplifier here	257	; ;set beep amplifier here
260	; stdcall unmute_output, edx	258	; stdcall unmute_output, edx
261	; .no_beeper_amp:	259	;.no_beeper_amp:
262	; ;try to beep here	260	; ;try to beep here
263	; stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax	261	; stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax
264	; if DEBUG	262	;if DEBUG
265	; push eax esi	263	; push eax esi
266	; mov esi, msgBeeperNid	264	; mov esi, msgBeeperNid
267	; call SysMsgBoardStr	265	; invoke SysMsgBoardStr
268	; push eax	266	; push eax
269	; mov eax, [nid]	267	; mov eax, [nid]
270	; stdcall fdword2str, 2	268	; stdcall fdword2str, 2
271	; call SysMsgBoardStr	269	; invoke SysMsgBoardStr
272	;	270	;
273	; mov esi, msgBeeperValue	271	; mov esi, msgBeeperValue
274	; call SysMsgBoardStr	272	; invoke SysMsgBoardStr
275	; pop eax	273	; pop eax
276	; stdcall fdword2str, 2	274	; stdcall fdword2str, 2
277	; call SysMsgBoardStr	275	; invoke SysMsgBoardStr
278	;	276	;
279	; mov esi, msgBeepNow	277	; mov esi, msgBeepNow
280	; call SysMsgBoardStr	278	; invoke SysMsgBoardStr
281	; pop esi eax	279	; pop esi eax
282	; end if	280	;end if
283	; mov ecx, 256*1	281	; mov ecx, 256*1
284	; .next_tone:	282	;.next_tone:
285	; dec ecx	283	; dec ecx
286	; movzx ebx, [esi + HDA_GNODE.nid]	284	; movzx ebx, [esi + HDA_GNODE.nid]
287	; stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_BEEP_CONTROL, ecx	285	; stdcall snd_hda_codec_write, [nid], 0, AC_VERB_SET_BEEP_CONTROL, ecx
288	; ;mov eax, 0x8000	286	; ;mov eax, 0x8000
289	; ;stdcall StallExec	287	; ;stdcall StallExec
290	; test ecx, ecx	288	; test ecx, ecx
291	; jnz .next_tone	289	; jnz .next_tone
292	; .end_beep:	290	;.end_beep:
293	; stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax	291	; stdcall snd_hda_codec_read, [nid], 0, AC_VERB_GET_BEEP_CONTROL, 0 ;eax
294	; if DEBUG	292	;if DEBUG
295	; ;push eax esi	293	; ;push eax esi
296	; mov esi, msgBeeperValue	294	; mov esi, msgBeeperValue
297	; call SysMsgBoardStr	295	; invoke SysMsgBoardStr
298	; stdcall fdword2str, 2	296	; stdcall fdword2str, 2
299	; call SysMsgBoardStr	297	; invoke SysMsgBoardStr
300	; ;pop esi eax	298	; ;pop esi eax
301	; end if	299	;end if
302	; .not_beeper:	300	;.not_beeper:
303	; popa	301	; popa
304	;;Asper+: Beeper ]	302	;;Asper+: Beeper ]
305		303
306	xor eax, eax	304	xor eax, eax
307	test ebx, AC_WCAP_IN_AMP	305	test ebx, AC_WCAP_IN_AMP
308	jz .no_in_amp	306	jz .no_in_amp
309	test ebx, AC_WCAP_AMP_OVRD	307	test ebx, AC_WCAP_AMP_OVRD
310	jz @f	308	jz @f
311	snd_hda_param_read [nid], AC_PAR_AMP_IN_CAP	309	snd_hda_param_read [nid], AC_PAR_AMP_IN_CAP
312	@@:	310	@@:
313	test eax, eax	311	test eax, eax
314	jnz @f	312	jnz @f
315	mov eax, [spec.def_amp_in_caps]	313	mov eax, [spec.def_amp_in_caps]
316	@@:	314	@@:
317	mov [edx + HDA_GNODE.amp_in_caps], eax	315	mov [edx + HDA_GNODE.amp_in_caps], eax
318	.no_in_amp:	316	.no_in_amp:
319		317
320	mov esi, [spec.nid_list]	318	mov esi, [spec.nid_list]
321	test esi, esi	319	test esi, esi
322	jnz @f	320	jnz @f
323	mov [spec.nid_list], edx	321	mov [spec.nid_list], edx
324	jmp .out	322	jmp .out
325	@@:	323	@@:
326		324
327	;Asper+: Sort pins by DA:Sequence during tree building [	325	;Asper+: Sort pins by DA:Sequence during tree building [
328	mov ecx, esi	326	mov ecx, esi
329	movzx ebx, byte [edx + HDA_GNODE.def_cfg]	327	movzx ebx, byte [edx + HDA_GNODE.def_cfg]
330	push edi	328	push edi
331	.next_node:	329	.next_node:
332	cmp [esi + HDA_GNODE.type], AC_WID_PIN	330	cmp [esi + HDA_GNODE.type], AC_WID_PIN
333	jne @f	331	jne @f
334	cmp [edx + HDA_GNODE.type], AC_WID_PIN	332	cmp [edx + HDA_GNODE.type], AC_WID_PIN
335	je .pin	333	je .pin
336		334
337	mov edi, [spec.nid_list]	335	mov edi, [spec.nid_list]
338	cmp [edi + HDA_GNODE.type], AC_WID_PIN	336	cmp [edi + HDA_GNODE.type], AC_WID_PIN
339	jne .not_pin	337	jne .not_pin
340	mov [edx + HDA_GNODE.next], edi	338	mov [edx + HDA_GNODE.next], edi
341	.head: ;CleverMouse+	339	.head: ;CleverMouse+
342	mov [spec.nid_list], edx	340	mov [spec.nid_list], edx
343	pop edi	341	pop edi
344	jmp .out	342	jmp .out
345	.pin:	343	.pin:
346	movzx edi, byte [esi + HDA_GNODE.def_cfg]	344	movzx edi, byte [esi + HDA_GNODE.def_cfg]
347	cmp edi, ebx	345	cmp edi, ebx
348	jle @f	346	jle @f
349	.not_pin:	347	.not_pin:
350	mov [edx + HDA_GNODE.next], esi	348	mov [edx + HDA_GNODE.next], esi
351	cmp esi, [spec.nid_list] ;CleverMouse+	349	cmp esi, [spec.nid_list] ;CleverMouse+
352	jz .head ;CleverMouse+	350	jz .head ;CleverMouse+
353	mov esi, ecx	351	mov esi, ecx
354	jmp .insert	352	jmp .insert
355	@@:	353	@@:
356	mov eax, [esi + HDA_GNODE.next]	354	mov eax, [esi + HDA_GNODE.next]
357	test eax, eax	355	test eax, eax
358	jz .insert	356	jz .insert
359	mov ecx, esi	357	mov ecx, esi
360	mov esi, eax	358	mov esi, eax
361	jmp .next_node	359	jmp .next_node
362	.insert:	360	.insert:
363	mov [esi + HDA_GNODE.next], edx	361	mov [esi + HDA_GNODE.next], edx
364	pop edi	362	pop edi
365	;Asper+ ]	363	;Asper+ ]
366		364
367	.out:	365	.out:
368	mov eax, edi	366	mov eax, edi
369	pusha	367	pusha
370	call Kfree ;free temporary conn_list	368	invoke Kfree ;free temporary conn_list
371	popa	369	popa
372	xor eax, eax	370	xor eax, eax
373	pop esi edi edx ecx ebx	371	pop esi edi edx ecx ebx
374	ret	372	ret
375		373
376	.err_out:	374	.err_out:
377	mov eax, edx	375	mov eax, edx
378	pusha	376	pusha
379	call Kfree ;free node	377	invoke Kfree ;free node
380	popa	378	popa
381	xor eax, eax	379	xor eax, eax
382	dec eax	380	dec eax
383	pop esi edi edx ecx ebx	381	pop esi edi edx ecx ebx
384	ret	382	ret
385	endp	383	endp
386		384
387		385
388		386
389	; build the AFG subtree	387	; build the AFG subtree
390	proc build_afg_tree	388	proc build_afg_tree
391	push ebx ecx edx	389	push ebx ecx edx
392		390
393	mov ebx, [codec.afg]	391	mov ebx, [codec.afg]
394	snd_hda_param_read ebx, AC_PAR_AMP_OUT_CAP	392	snd_hda_param_read ebx, AC_PAR_AMP_OUT_CAP
395		393
396	mov [spec.def_amp_out_caps], eax	394	mov [spec.def_amp_out_caps], eax
397	snd_hda_param_read ebx, AC_PAR_AMP_IN_CAP	395	snd_hda_param_read ebx, AC_PAR_AMP_IN_CAP
398	mov [spec.def_amp_in_caps], eax	396	mov [spec.def_amp_in_caps], eax
399		397
400	stdcall snd_hda_get_sub_nodes, ebx	398	stdcall snd_hda_get_sub_nodes, ebx
401	mov ecx, eax	399	mov ecx, eax
402	and ecx, 0xFFFF ;ecx = nodes number	400	and ecx, 0xFFFF ;ecx = nodes number
403	mov edx, eax	401	mov edx, eax
404	shr edx, 16 ;eax = address of the first nid	402	shr edx, 16 ;eax = address of the first nid
405		403
406	test edx, edx	404	test edx, edx
407	jz @f	405	jz @f
408	cmp ecx, 0	406	cmp ecx, 0
409	jge .nid_ok	407	jge .nid_ok
410	@@:	408	@@:
411	if FDEBUG	409	if FDEBUG
412	push esi	410	push esi
413	mov esi, emsgInvalidAFGSubtree	411	mov esi, emsgInvalidAFGSubtree
414	call SysMsgBoardStr	412	invoke SysMsgBoardStr
415	pop esi	413	pop esi
416	end if	414	end if
417	xor eax, eax	415	xor eax, eax
418	dec eax	416	dec eax
419	jmp .out	417	jmp .out
420	.nid_ok:	418	.nid_ok:
421		419
422	; parse all nodes belonging to the AFG	420	; parse all nodes belonging to the AFG
423	.next_node:	421	.next_node:
424	test ecx, ecx	422	test ecx, ecx
425	jz .build_done	423	jz .build_done
426		424
427	stdcall add_new_node, edx	425	stdcall add_new_node, edx
428	test eax, eax	426	test eax, eax
429	jnz .out	427	jnz .out
430	inc edx	428	inc edx
431	dec ecx	429	dec ecx
432	jmp .next_node	430	jmp .next_node
433	.build_done:	431	.build_done:
434	xor eax, eax	432	xor eax, eax
435	.out:	433	.out:
436	pop edx ecx ebx	434	pop edx ecx ebx
437	ret	435	ret
438	endp	436	endp
-		437
-		438	;Asper+[
-		439	proc print_afg_tree_nodes
-		440	push eax esi edi
-		441	mov esi, msgNodeSeq
-		442	invoke SysMsgBoardStr
-		443
-		444	mov edi, [spec.nid_list]
-		445	test edi, edi
-		446	jz .out
-		447	.next_node:
-		448	movzx eax, word [edi + HDA_GNODE.nid]
-		449	mov esi, msgNID
-		450	invoke SysMsgBoardStr
-		451	stdcall fdword2str, 3
-		452	invoke SysMsgBoardStr
-		453
-		454	mov eax, [edi + HDA_GNODE.next]
-		455	test eax, eax
-		456	jz .out
-		457
-		458	mov edi, eax
-		459	jmp .next_node
-		460	.out:
-		461	pop edi esi eax
-		462	ret
-		463	endp
439		464	;Asper+]
440		465
441	; look for the node record for the given NID	466	; look for the node record for the given NID
442	proc hda_get_node stdcall, nid:dword	467	proc hda_get_node stdcall, nid:dword
443	push ebx edx esi	468	push ebx edx esi
444	movzx ebx, word [nid]	469	movzx ebx, word [nid]
445	mov esi, [spec.nid_list]	470	mov esi, [spec.nid_list]
446	test esi, esi	471	test esi, esi
447	jz .out	472	jz .out
448		473
449	.next_node:	474	.next_node:
450	mov edx, [esi + HDA_GNODE.next]	475	mov edx, [esi + HDA_GNODE.next]
451	test edx, edx ;Asper+	476	test edx, edx ;Asper+
452	jz .not_found ;Asper+	477	jz .not_found ;Asper+
453	mov ax, word [esi + HDA_GNODE.nid]	478	mov ax, word [esi + HDA_GNODE.nid]
454	cmp ax, bx	479	cmp ax, bx
455	je .out	480	je .out
456	mov esi, edx	481	mov esi, edx
457	jmp .next_node	482	jmp .next_node
458		483
459	.not_found: ;Asper+	484	.not_found: ;Asper+
460	xor esi, esi	485	xor esi, esi
461	.out:	486	.out:
462	mov eax, esi	487	mov eax, esi
463	pop esi edx ebx	488	pop esi edx ebx
464	ret	489	ret
465	endp	490	endp
466		491
467	;Asper+[	492	;Asper+[
468	proc set_eapd stdcall, node:dword ;nid:dword, on:dword	493	proc set_eapd stdcall, node:dword ;nid:dword, on:dword
469	push eax ebx esi	494	push eax ebx esi
470	mov esi, [node]	495	mov esi, [node]
471	cmp [esi + HDA_GNODE.type], AC_WID_PIN	496	cmp [esi + HDA_GNODE.type], AC_WID_PIN
472	jne .out	497	jne .out
473	; eapd capable?	498	; eapd capable?

Subversion Repositories Kolibri OS

(root)/drivers/audio/intel_hda/hda_generic.inc @ 6944 – Rev 3083 → 5048