DevHdaCodec.cpp@ 88503

最後變更在這個檔案從88503是 88503,由 vboxsync 提交於 4 年前
DevHda: Just use the ring-3 task (hCorbDmaTask) when ring-0 needs to do CORB DMA stuff. The codec is not yet suitable from ring-0, nor does it see sufficient action to warrant putting it in ring-0, and this approach should unload the EMT a tiny bit more. bugref:9890
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 109.5 KB

行
1	/* $Id: DevHdaCodec.cpp 88503 2021-04-14 11:43:28Z vboxsync $ */
2	/** @file
3	* Intel HD Audio Controller Emulation - Codec, Sigmatel/IDT STAC9220.
4	*
5	* Implemented based on the Intel HD Audio specification and the
6	* Sigmatel/IDT STAC9220 datasheet.
7	*/
8
9	/*
10	* Copyright (C) 2006-2020 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.alldomusa.eu.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*/
20
21
22	/*********************************************************************************************************************************
23	* Header Files *
24	*********************************************************************************************************************************/
25	#define LOG_GROUP LOG_GROUP_DEV_HDA_CODEC
26	#include <VBox/log.h>
27
28	#include <VBox/AssertGuest.h>
29	#include <VBox/vmm/pdmdev.h>
30	#include <VBox/vmm/pdmaudioifs.h>
31	#include <VBox/vmm/pdmaudioinline.h>
32
33	#include <iprt/assert.h>
34	#include <iprt/uuid.h>
35	#include <iprt/string.h>
36	#include <iprt/mem.h>
37	#include <iprt/asm.h>
38	#include <iprt/cpp/utils.h>
39
40	#include "VBoxDD.h"
41	#include "AudioMixer.h"
42	#include "DevHdaCodec.h"
43	#include "DevHdaCommon.h"
44
45
46	/*********************************************************************************************************************************
47	* Defined Constants And Macros *
48	*********************************************************************************************************************************/
49
50
51	#define AMPLIFIER_IN 0
52	#define AMPLIFIER_OUT 1
53	#define AMPLIFIER_LEFT 1
54	#define AMPLIFIER_RIGHT 0
55	#define AMPLIFIER_REGISTER(amp, inout, side, index) ((amp)[30(inout) + 15(side) + (index)])
56
57
58	/*********************************************************************************************************************************
59	* Global Variables *
60	*********************************************************************************************************************************/
61	/* STAC9220 - Nodes IDs / names. */
62	#define STAC9220_NID_ROOT 0x0 /* Root node */
63	#define STAC9220_NID_AFG 0x1 /* Audio Configuration Group */
64	#define STAC9220_NID_DAC0 0x2 /* Out */
65	#define STAC9220_NID_DAC1 0x3 /* Out */
66	#define STAC9220_NID_DAC2 0x4 /* Out */
67	#define STAC9220_NID_DAC3 0x5 /* Out */
68	#define STAC9220_NID_ADC0 0x6 /* In */
69	#define STAC9220_NID_ADC1 0x7 /* In */
70	#define STAC9220_NID_SPDIF_OUT 0x8 /* Out */
71	#define STAC9220_NID_SPDIF_IN 0x9 /* In */
72	/** Also known as PIN_A. */
73	#define STAC9220_NID_PIN_HEADPHONE0 0xA /* In, Out */
74	#define STAC9220_NID_PIN_B 0xB /* In, Out */
75	#define STAC9220_NID_PIN_C 0xC /* In, Out */
76	/** Also known as PIN D. */
77	#define STAC9220_NID_PIN_HEADPHONE1 0xD /* In, Out */
78	#define STAC9220_NID_PIN_E 0xE /* In */
79	#define STAC9220_NID_PIN_F 0xF /* In, Out */
80	/** Also known as DIGOUT0. */
81	#define STAC9220_NID_PIN_SPDIF_OUT 0x10 /* Out */
82	/** Also known as DIGIN. */
83	#define STAC9220_NID_PIN_SPDIF_IN 0x11 /* In */
84	#define STAC9220_NID_ADC0_MUX 0x12 /* In */
85	#define STAC9220_NID_ADC1_MUX 0x13 /* In */
86	#define STAC9220_NID_PCBEEP 0x14 /* Out */
87	#define STAC9220_NID_PIN_CD 0x15 /* In */
88	#define STAC9220_NID_VOL_KNOB 0x16
89	#define STAC9220_NID_AMP_ADC0 0x17 /* In */
90	#define STAC9220_NID_AMP_ADC1 0x18 /* In */
91	/* Only for STAC9221. */
92	#define STAC9221_NID_ADAT_OUT 0x19 /* Out */
93	#define STAC9221_NID_I2S_OUT 0x1A /* Out */
94	#define STAC9221_NID_PIN_I2S_OUT 0x1B /* Out */
95
96	/** Number of total nodes emulated. */
97	#define STAC9221_NUM_NODES 0x1C
98
99
100	/*********************************************************************************************************************************
101	* Global Variables *
102	*********************************************************************************************************************************/
103	#ifdef IN_RING3
104
105	/* STAC9220 - Referenced through STAC9220WIDGET in the constructor below. */
106	static uint8_t const g_abStac9220Ports[] = { STAC9220_NID_PIN_HEADPHONE0, STAC9220_NID_PIN_B, STAC9220_NID_PIN_C, STAC9220_NID_PIN_HEADPHONE1, STAC9220_NID_PIN_E, STAC9220_NID_PIN_F, 0 };
107	static uint8_t const g_abStac9220Dacs[] = { STAC9220_NID_DAC0, STAC9220_NID_DAC1, STAC9220_NID_DAC2, STAC9220_NID_DAC3, 0 };
108	static uint8_t const g_abStac9220Adcs[] = { STAC9220_NID_ADC0, STAC9220_NID_ADC1, 0 };
109	static uint8_t const g_abStac9220SpdifOuts[] = { STAC9220_NID_SPDIF_OUT, 0 };
110	static uint8_t const g_abStac9220SpdifIns[] = { STAC9220_NID_SPDIF_IN, 0 };
111	static uint8_t const g_abStac9220DigOutPins[] = { STAC9220_NID_PIN_SPDIF_OUT, 0 };
112	static uint8_t const g_abStac9220DigInPins[] = { STAC9220_NID_PIN_SPDIF_IN, 0 };
113	static uint8_t const g_abStac9220AdcVols[] = { STAC9220_NID_AMP_ADC0, STAC9220_NID_AMP_ADC1, 0 };
114	static uint8_t const g_abStac9220AdcMuxs[] = { STAC9220_NID_ADC0_MUX, STAC9220_NID_ADC1_MUX, 0 };
115	static uint8_t const g_abStac9220Pcbeeps[] = { STAC9220_NID_PCBEEP, 0 };
116	static uint8_t const g_abStac9220Cds[] = { STAC9220_NID_PIN_CD, 0 };
117	static uint8_t const g_abStac9220VolKnobs[] = { STAC9220_NID_VOL_KNOB, 0 };
118	/* STAC 9221. */
119	/** @todo Is STAC9220_NID_SPDIF_IN really correct for reserved nodes? */
120	static uint8_t const g_abStac9220Reserveds[] = { STAC9220_NID_SPDIF_IN, STAC9221_NID_ADAT_OUT, STAC9221_NID_I2S_OUT, STAC9221_NID_PIN_I2S_OUT, 0 };
121
122	/** SSM description of CODECCOMMONNODE. */
123	static SSMFIELD const g_aCodecNodeFields[] =
124	{
125	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.uID),
126	SSMFIELD_ENTRY_PAD_HC_AUTO(3, 3),
127	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.au32F00_param),
128	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.au32F02_param),
129	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, au32Params),
130	SSMFIELD_ENTRY_TERM()
131	};
132
133	/** Backward compatibility with v1 of CODECCOMMONNODE. */
134	static SSMFIELD const g_aCodecNodeFieldsV1[] =
135	{
136	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.uID),
137	SSMFIELD_ENTRY_PAD_HC_AUTO(3, 7),
138	SSMFIELD_ENTRY_OLD_HCPTR(Core.name),
139	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.au32F00_param),
140	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, Core.au32F02_param),
141	SSMFIELD_ENTRY( CODECSAVEDSTATENODE, au32Params),
142	SSMFIELD_ENTRY_TERM()
143	};
144
145	#endif /* IN_RING3 */
146
147
148
149	#if 0 /* unused */
150	static DECLCALLBACK(void) stac9220DbgNodes(PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs)
151	{
152	RT_NOREF(pszArgs);
153	for (uint8_t i = 1; i < pThis->cTotalNodes; i++)
154	{
155	PCODECNODE pNode = &pThis->aNodes[i];
156	AMPLIFIER *pAmp = &pNode->dac.B_params;
157
158	uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) & 0x7f;
159	uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) & 0x7f;
160
161	pHlp->pfnPrintf(pHlp, "0x%x: lVol=%RU8, rVol=%RU8\n", i, lVol, rVol);
162	}
163	}
164	#endif
165
166
167	/**
168	* Resets a single node of the codec.
169	*
170	* @param pThis HDA codec of node to reset.
171	* @param uNID Node ID to set node to.
172	* @param pNode Node to reset.
173	*/
174	static void stac9220NodeReset(PHDACODEC pThis, uint8_t uNID, PCODECNODE pNode)
175	{
176	LogFlowFunc(("NID=0x%x (%RU8)\n", uNID, uNID));
177
178	if ( !pThis->fInReset
179	&& ( uNID != STAC9220_NID_ROOT
180	&& uNID != STAC9220_NID_AFG)
181	)
182	{
183	RT_ZERO(pNode->node);
184	}
185
186	/* Set common parameters across all nodes. */
187	pNode->node.uID = uNID;
188	pNode->node.uSD = 0;
189
190	switch (uNID)
191	{
192	/* Root node. */
193	case STAC9220_NID_ROOT:
194	{
195	/* Set the revision ID. */
196	pNode->root.node.au32F00_param[0x02] = CODEC_MAKE_F00_02(0x1, 0x0, 0x3, 0x4, 0x0, 0x1);
197	break;
198	}
199
200	/*
201	* AFG (Audio Function Group).
202	*/
203	case STAC9220_NID_AFG:
204	{
205	pNode->afg.node.au32F00_param[0x08] = CODEC_MAKE_F00_08(1, 0xd, 0xd);
206	/* We set the AFG's PCM capabitilies fixed to 16kHz, 22.5kHz + 44.1kHz, 16-bit signed. */
207	pNode->afg.node.au32F00_param[0x0A] = CODEC_F00_0A_44_1KHZ /* 44.1 kHz */
208	\| CODEC_F00_0A_44_1KHZ_1_2X /* Messed up way of saying 22.05 kHz */
209	\| CODEC_F00_0A_48KHZ_1_3X /* Messed up way of saying 16 kHz. */
210	\| CODEC_F00_0A_16_BIT; /* 16-bit signed */
211	/* Note! We do not set CODEC_F00_0A_48KHZ here because we end up with
212	S/PDIF output showing up in windows and it trying to configure
213	streams other than 0 and 4 and stuff going sideways in the
214	stream setup/removal area. */
215	pNode->afg.node.au32F00_param[0x0B] = CODEC_F00_0B_PCM;
216	pNode->afg.node.au32F00_param[0x0C] = CODEC_MAKE_F00_0C(0x17)
217	\| CODEC_F00_0C_CAP_BALANCED_IO
218	\| CODEC_F00_0C_CAP_INPUT
219	\| CODEC_F00_0C_CAP_OUTPUT
220	\| CODEC_F00_0C_CAP_PRESENCE_DETECT
221	\| CODEC_F00_0C_CAP_TRIGGER_REQUIRED
222	\| CODEC_F00_0C_CAP_IMPENDANCE_SENSE;
223
224	/* Default input amplifier capabilities. */
225	pNode->node.au32F00_param[0x0D] = CODEC_MAKE_F00_0D(CODEC_AMP_CAP_MUTE,
226	CODEC_AMP_STEP_SIZE,
227	CODEC_AMP_NUM_STEPS,
228	CODEC_AMP_OFF_INITIAL);
229	/* Default output amplifier capabilities. */
230	pNode->node.au32F00_param[0x12] = CODEC_MAKE_F00_12(CODEC_AMP_CAP_MUTE,
231	CODEC_AMP_STEP_SIZE,
232	CODEC_AMP_NUM_STEPS,
233	CODEC_AMP_OFF_INITIAL);
234
235	pNode->afg.node.au32F00_param[0x11] = CODEC_MAKE_F00_11(1, 1, 0, 0, 4);
236	pNode->afg.node.au32F00_param[0x0F] = CODEC_F00_0F_D3
237	\| CODEC_F00_0F_D2
238	\| CODEC_F00_0F_D1
239	\| CODEC_F00_0F_D0;
240
241	pNode->afg.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D2, CODEC_F05_D2); /* PS-Act: D2, PS->Set D2. */
242	pNode->afg.u32F08_param = 0;
243	pNode->afg.u32F17_param = 0;
244	break;
245	}
246
247	/*
248	* DACs.
249	*/
250	case STAC9220_NID_DAC0: /* DAC0: Headphones 0 + 1 */
251	case STAC9220_NID_DAC1: /* DAC1: PIN C */
252	case STAC9220_NID_DAC2: /* DAC2: PIN B */
253	case STAC9220_NID_DAC3: /* DAC3: PIN F */
254	{
255	pNode->dac.u32A_param = CODEC_MAKE_A(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
256	HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_2X, HDA_SDFMT_16_BIT,
257	HDA_SDFMT_CHAN_STEREO);
258
259	/* 7.3.4.6: Audio widget capabilities. */
260	pNode->dac.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 13, 0)
261	\| CODEC_F00_09_CAP_L_R_SWAP
262	\| CODEC_F00_09_CAP_POWER_CTRL
263	\| CODEC_F00_09_CAP_OUT_AMP_PRESENT
264	\| CODEC_F00_09_CAP_STEREO;
265
266	/* Connection list; must be 0 if the only connection for the widget is
267	* to the High Definition Audio Link. */
268	pNode->dac.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 0 /* Entries */);
269
270	pNode->dac.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3);
271
272	RT_ZERO(pNode->dac.B_params);
273	AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) = 0x7F \| RT_BIT(7);
274	AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) = 0x7F \| RT_BIT(7);
275	break;
276	}
277
278	/*
279	* ADCs.
280	*/
281	case STAC9220_NID_ADC0: /* Analog input. */
282	{
283	pNode->node.au32F02_param[0] = STAC9220_NID_AMP_ADC0;
284	goto adc_init;
285	}
286
287	case STAC9220_NID_ADC1: /* Analog input (CD). */
288	{
289	pNode->node.au32F02_param[0] = STAC9220_NID_AMP_ADC1;
290
291	/* Fall through is intentional. */
292	adc_init:
293
294	pNode->adc.u32A_param = CODEC_MAKE_A(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
295	HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_2X, HDA_SDFMT_16_BIT,
296	HDA_SDFMT_CHAN_STEREO);
297
298	pNode->adc.u32F03_param = RT_BIT(0);
299	pNode->adc.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3); /* PS-Act: D3 Set: D3 */
300
301	pNode->adc.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 0xD, 0)
302	\| CODEC_F00_09_CAP_POWER_CTRL
303	\| CODEC_F00_09_CAP_CONNECTION_LIST
304	\| CODEC_F00_09_CAP_PROC_WIDGET
305	\| CODEC_F00_09_CAP_STEREO;
306	/* Connection list entries. */
307	pNode->adc.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
308	break;
309	}
310
311	/*
312	* SP/DIF In/Out.
313	*/
314	case STAC9220_NID_SPDIF_OUT:
315	{
316	pNode->spdifout.u32A_param = CODEC_MAKE_A(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
317	HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_2X, HDA_SDFMT_16_BIT,
318	HDA_SDFMT_CHAN_STEREO);
319	pNode->spdifout.u32F06_param = 0;
320	pNode->spdifout.u32F0d_param = 0;
321
322	pNode->spdifout.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 4, 0)
323	\| CODEC_F00_09_CAP_DIGITAL
324	\| CODEC_F00_09_CAP_FMT_OVERRIDE
325	\| CODEC_F00_09_CAP_STEREO;
326
327	/* Use a fixed format from AFG. */
328	pNode->spdifout.node.au32F00_param[0xA] = pThis->aNodes[STAC9220_NID_AFG].node.au32F00_param[0xA];
329	pNode->spdifout.node.au32F00_param[0xB] = CODEC_F00_0B_PCM;
330	break;
331	}
332
333	case STAC9220_NID_SPDIF_IN:
334	{
335	pNode->spdifin.u32A_param = CODEC_MAKE_A(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
336	HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_2X, HDA_SDFMT_16_BIT,
337	HDA_SDFMT_CHAN_STEREO);
338
339	pNode->spdifin.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 4, 0)
340	\| CODEC_F00_09_CAP_DIGITAL
341	\| CODEC_F00_09_CAP_CONNECTION_LIST
342	\| CODEC_F00_09_CAP_FMT_OVERRIDE
343	\| CODEC_F00_09_CAP_STEREO;
344
345	/* Use a fixed format from AFG. */
346	pNode->spdifin.node.au32F00_param[0xA] = pThis->aNodes[STAC9220_NID_AFG].node.au32F00_param[0xA];
347	pNode->spdifin.node.au32F00_param[0xB] = CODEC_F00_0B_PCM;
348
349	/* Connection list entries. */
350	pNode->spdifin.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
351	pNode->spdifin.node.au32F02_param[0] = 0x11;
352	break;
353	}
354
355	/*
356	* PINs / Ports.
357	*/
358	case STAC9220_NID_PIN_HEADPHONE0: /* Port A: Headphone in/out (front). */
359	{
360	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(0 /fPresent/, CODEC_F09_ANALOG_NA);
361
362	pNode->port.node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
363	\| CODEC_F00_0C_CAP_INPUT
364	\| CODEC_F00_0C_CAP_OUTPUT
365	\| CODEC_F00_0C_CAP_HEADPHONE_AMP
366	\| CODEC_F00_0C_CAP_PRESENCE_DETECT
367	\| CODEC_F00_0C_CAP_TRIGGER_REQUIRED;
368
369	/* Connection list entry 0: Goes to DAC0. */
370	pNode->port.node.au32F02_param[0] = STAC9220_NID_DAC0;
371
372	if (!pThis->fInReset)
373	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
374	CODEC_F1C_LOCATION_FRONT,
375	CODEC_F1C_DEVICE_HP,
376	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
377	CODEC_F1C_COLOR_GREEN,
378	CODEC_F1C_MISC_NONE,
379	CODEC_F1C_ASSOCIATION_GROUP_1, 0x0 /* Seq */);
380	goto port_init;
381	}
382
383	case STAC9220_NID_PIN_B: /* Port B: Rear CLFE (Center / Subwoofer). */
384	{
385	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(1 /fPresent/, CODEC_F09_ANALOG_NA);
386
387	pNode->port.node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
388	\| CODEC_F00_0C_CAP_INPUT
389	\| CODEC_F00_0C_CAP_OUTPUT
390	\| CODEC_F00_0C_CAP_PRESENCE_DETECT
391	\| CODEC_F00_0C_CAP_TRIGGER_REQUIRED;
392
393	/* Connection list entry 0: Goes to DAC2. */
394	pNode->port.node.au32F02_param[0] = STAC9220_NID_DAC2;
395
396	if (!pThis->fInReset)
397	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
398	CODEC_F1C_LOCATION_REAR,
399	CODEC_F1C_DEVICE_SPEAKER,
400	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
401	CODEC_F1C_COLOR_BLACK,
402	CODEC_F1C_MISC_NONE,
403	CODEC_F1C_ASSOCIATION_GROUP_0, 0x1 /* Seq */);
404	goto port_init;
405	}
406
407	case STAC9220_NID_PIN_C: /* Rear Speaker. */
408	{
409	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(1 /fPresent/, CODEC_F09_ANALOG_NA);
410
411	pNode->port.node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
412	\| CODEC_F00_0C_CAP_INPUT
413	\| CODEC_F00_0C_CAP_OUTPUT
414	\| CODEC_F00_0C_CAP_PRESENCE_DETECT
415	\| CODEC_F00_0C_CAP_TRIGGER_REQUIRED;
416
417	/* Connection list entry 0: Goes to DAC1. */
418	pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC1;
419
420	if (!pThis->fInReset)
421	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
422	CODEC_F1C_LOCATION_REAR,
423	CODEC_F1C_DEVICE_SPEAKER,
424	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
425	CODEC_F1C_COLOR_GREEN,
426	CODEC_F1C_MISC_NONE,
427	CODEC_F1C_ASSOCIATION_GROUP_0, 0x0 /* Seq */);
428	goto port_init;
429	}
430
431	case STAC9220_NID_PIN_HEADPHONE1: /* Also known as PIN_D. */
432	{
433	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(1 /fPresent/, CODEC_F09_ANALOG_NA);
434
435	pNode->port.node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
436	\| CODEC_F00_0C_CAP_INPUT
437	\| CODEC_F00_0C_CAP_OUTPUT
438	\| CODEC_F00_0C_CAP_HEADPHONE_AMP
439	\| CODEC_F00_0C_CAP_PRESENCE_DETECT
440	\| CODEC_F00_0C_CAP_TRIGGER_REQUIRED;
441
442	/* Connection list entry 0: Goes to DAC1. */
443	pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC0;
444
445	if (!pThis->fInReset)
446	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
447	CODEC_F1C_LOCATION_FRONT,
448	CODEC_F1C_DEVICE_MIC,
449	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
450	CODEC_F1C_COLOR_PINK,
451	CODEC_F1C_MISC_NONE,
452	CODEC_F1C_ASSOCIATION_GROUP_15, 0x0 /* Ignored */);
453	/* Fall through is intentional. */
454
455	port_init:
456
457	pNode->port.u32F07_param = CODEC_F07_IN_ENABLE
458	\| CODEC_F07_OUT_ENABLE;
459	pNode->port.u32F08_param = 0;
460
461	pNode->port.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
462	\| CODEC_F00_09_CAP_CONNECTION_LIST
463	\| CODEC_F00_09_CAP_UNSOL
464	\| CODEC_F00_09_CAP_STEREO;
465	/* Connection list entries. */
466	pNode->port.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
467	break;
468	}
469
470	case STAC9220_NID_PIN_E:
471	{
472	pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
473	pNode->port.u32F08_param = 0;
474	/* If Line in is reported as enabled, OS X sees no speakers! Windows does
475	* not care either way, although Linux does.
476	*/
477	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(0 /* fPresent */, 0);
478
479	pNode->port.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
480	\| CODEC_F00_09_CAP_UNSOL
481	\| CODEC_F00_09_CAP_STEREO;
482
483	pNode->port.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
484	\| CODEC_F00_0C_CAP_PRESENCE_DETECT;
485
486	if (!pThis->fInReset)
487	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
488	CODEC_F1C_LOCATION_REAR,
489	CODEC_F1C_DEVICE_LINE_IN,
490	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
491	CODEC_F1C_COLOR_BLUE,
492	CODEC_F1C_MISC_NONE,
493	CODEC_F1C_ASSOCIATION_GROUP_4, 0x1 /* Seq */);
494	break;
495	}
496
497	case STAC9220_NID_PIN_F:
498	{
499	pNode->port.u32F07_param = CODEC_F07_IN_ENABLE \| CODEC_F07_OUT_ENABLE;
500	pNode->port.u32F08_param = 0;
501	pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(1 /* fPresent */, CODEC_F09_ANALOG_NA);
502
503	pNode->port.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
504	\| CODEC_F00_09_CAP_CONNECTION_LIST
505	\| CODEC_F00_09_CAP_UNSOL
506	\| CODEC_F00_09_CAP_OUT_AMP_PRESENT
507	\| CODEC_F00_09_CAP_STEREO;
508
509	pNode->port.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
510	\| CODEC_F00_0C_CAP_OUTPUT;
511
512	/* Connection list entry 0: Goes to DAC3. */
513	pNode->port.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
514	pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC3;
515
516	if (!pThis->fInReset)
517	pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
518	CODEC_F1C_LOCATION_INTERNAL,
519	CODEC_F1C_DEVICE_SPEAKER,
520	CODEC_F1C_CONNECTION_TYPE_1_8INCHES,
521	CODEC_F1C_COLOR_ORANGE,
522	CODEC_F1C_MISC_NONE,
523	CODEC_F1C_ASSOCIATION_GROUP_0, 0x2 /* Seq */);
524	break;
525	}
526
527	case STAC9220_NID_PIN_SPDIF_OUT: /* Rear SPDIF Out. */
528	{
529	pNode->digout.u32F07_param = CODEC_F07_OUT_ENABLE;
530	pNode->digout.u32F09_param = 0;
531
532	pNode->digout.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
533	\| CODEC_F00_09_CAP_DIGITAL
534	\| CODEC_F00_09_CAP_CONNECTION_LIST
535	\| CODEC_F00_09_CAP_STEREO;
536	pNode->digout.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_OUTPUT;
537
538	/* Connection list entries. */
539	pNode->digout.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 3 /* Entries */);
540	pNode->digout.node.au32F02_param[0x0] = RT_MAKE_U32_FROM_U8(STAC9220_NID_SPDIF_OUT,
541	STAC9220_NID_AMP_ADC0, STAC9221_NID_ADAT_OUT, 0);
542	if (!pThis->fInReset)
543	pNode->digout.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
544	CODEC_F1C_LOCATION_REAR,
545	CODEC_F1C_DEVICE_SPDIF_OUT,
546	CODEC_F1C_CONNECTION_TYPE_DIN,
547	CODEC_F1C_COLOR_BLACK,
548	CODEC_F1C_MISC_NONE,
549	CODEC_F1C_ASSOCIATION_GROUP_2, 0x0 /* Seq */);
550	break;
551	}
552
553	case STAC9220_NID_PIN_SPDIF_IN:
554	{
555	pNode->digin.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3); /* PS-Act: D3 -> D3 */
556	pNode->digin.u32F07_param = CODEC_F07_IN_ENABLE;
557	pNode->digin.u32F08_param = 0;
558	pNode->digin.u32F09_param = CODEC_MAKE_F09_DIGITAL(0, 0);
559	pNode->digin.u32F0c_param = 0;
560
561	pNode->digin.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 3, 0)
562	\| CODEC_F00_09_CAP_POWER_CTRL
563	\| CODEC_F00_09_CAP_DIGITAL
564	\| CODEC_F00_09_CAP_UNSOL
565	\| CODEC_F00_09_CAP_STEREO;
566
567	pNode->digin.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_EAPD
568	\| CODEC_F00_0C_CAP_INPUT
569	\| CODEC_F00_0C_CAP_PRESENCE_DETECT;
570	if (!pThis->fInReset)
571	pNode->digin.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
572	CODEC_F1C_LOCATION_REAR,
573	CODEC_F1C_DEVICE_SPDIF_IN,
574	CODEC_F1C_CONNECTION_TYPE_OTHER_DIGITAL,
575	CODEC_F1C_COLOR_BLACK,
576	CODEC_F1C_MISC_NONE,
577	CODEC_F1C_ASSOCIATION_GROUP_5, 0x0 /* Seq */);
578	break;
579	}
580
581	case STAC9220_NID_ADC0_MUX:
582	{
583	pNode->adcmux.u32F01_param = 0; /* Connection select control index (STAC9220_NID_PIN_E). */
584	goto adcmux_init;
585	}
586
587	case STAC9220_NID_ADC1_MUX:
588	{
589	pNode->adcmux.u32F01_param = 1; /* Connection select control index (STAC9220_NID_PIN_CD). */
590	/* Fall through is intentional. */
591
592	adcmux_init:
593
594	pNode->adcmux.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0, 0)
595	\| CODEC_F00_09_CAP_CONNECTION_LIST
596	\| CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
597	\| CODEC_F00_09_CAP_OUT_AMP_PRESENT
598	\| CODEC_F00_09_CAP_STEREO;
599
600	pNode->adcmux.node.au32F00_param[0xD] = CODEC_MAKE_F00_0D(0, 27, 4, 0);
601
602	/* Connection list entries. */
603	pNode->adcmux.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 7 /* Entries */);
604	pNode->adcmux.node.au32F02_param[0x0] = RT_MAKE_U32_FROM_U8(STAC9220_NID_PIN_E,
605	STAC9220_NID_PIN_CD,
606	STAC9220_NID_PIN_F,
607	STAC9220_NID_PIN_B);
608	pNode->adcmux.node.au32F02_param[0x4] = RT_MAKE_U32_FROM_U8(STAC9220_NID_PIN_C,
609	STAC9220_NID_PIN_HEADPHONE1,
610	STAC9220_NID_PIN_HEADPHONE0,
611	0x0 /* Unused */);
612
613	/* STAC 9220 v10 6.21-22.{4,5} both(left and right) out amplifiers initialized with 0. */
614	RT_ZERO(pNode->adcmux.B_params);
615	break;
616	}
617
618	case STAC9220_NID_PCBEEP:
619	{
620	pNode->pcbeep.u32F0a_param = 0;
621
622	pNode->pcbeep.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_BEEP_GEN, 0, 0)
623	\| CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
624	\| CODEC_F00_09_CAP_OUT_AMP_PRESENT;
625	pNode->pcbeep.node.au32F00_param[0xD] = CODEC_MAKE_F00_0D(0, 17, 3, 3);
626
627	RT_ZERO(pNode->pcbeep.B_params);
628	break;
629	}
630
631	case STAC9220_NID_PIN_CD:
632	{
633	pNode->cdnode.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
634	\| CODEC_F00_09_CAP_STEREO;
635	pNode->cdnode.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT;
636
637	if (!pThis->fInReset)
638	pNode->cdnode.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_FIXED,
639	CODEC_F1C_LOCATION_INTERNAL,
640	CODEC_F1C_DEVICE_CD,
641	CODEC_F1C_CONNECTION_TYPE_ATAPI,
642	CODEC_F1C_COLOR_UNKNOWN,
643	CODEC_F1C_MISC_NONE,
644	CODEC_F1C_ASSOCIATION_GROUP_4, 0x2 /* Seq */);
645	break;
646	}
647
648	case STAC9220_NID_VOL_KNOB:
649	{
650	pNode->volumeKnob.u32F08_param = 0;
651	pNode->volumeKnob.u32F0f_param = 0x7f;
652
653	pNode->volumeKnob.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_VOLUME_KNOB, 0, 0);
654	pNode->volumeKnob.node.au32F00_param[0xD] = RT_BIT(7) \| 0x7F;
655
656	/* Connection list entries. */
657	pNode->volumeKnob.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 4 /* Entries */);
658	pNode->volumeKnob.node.au32F02_param[0x0] = RT_MAKE_U32_FROM_U8(STAC9220_NID_DAC0,
659	STAC9220_NID_DAC1,
660	STAC9220_NID_DAC2,
661	STAC9220_NID_DAC3);
662	break;
663	}
664
665	case STAC9220_NID_AMP_ADC0: /* ADC0Vol */
666	{
667	pNode->adcvol.node.au32F02_param[0] = STAC9220_NID_ADC0_MUX;
668	goto adcvol_init;
669	}
670
671	case STAC9220_NID_AMP_ADC1: /* ADC1Vol */
672	{
673	pNode->adcvol.node.au32F02_param[0] = STAC9220_NID_ADC1_MUX;
674	/* Fall through is intentional. */
675
676	adcvol_init:
677
678	pNode->adcvol.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0, 0)
679	\| CODEC_F00_09_CAP_L_R_SWAP
680	\| CODEC_F00_09_CAP_CONNECTION_LIST
681	\| CODEC_F00_09_CAP_IN_AMP_PRESENT
682	\| CODEC_F00_09_CAP_STEREO;
683
684
685	pNode->adcvol.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
686
687	RT_ZERO(pNode->adcvol.B_params);
688	AMPLIFIER_REGISTER(pNode->adcvol.B_params, AMPLIFIER_IN, AMPLIFIER_LEFT, 0) = RT_BIT(7);
689	AMPLIFIER_REGISTER(pNode->adcvol.B_params, AMPLIFIER_IN, AMPLIFIER_RIGHT, 0) = RT_BIT(7);
690	break;
691	}
692
693	/*
694	* STAC9221 nodes.
695	*/
696
697	case STAC9221_NID_ADAT_OUT:
698	{
699	pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_VENDOR_DEFINED, 3, 0)
700	\| CODEC_F00_09_CAP_DIGITAL
701	\| CODEC_F00_09_CAP_STEREO;
702	break;
703	}
704
705	case STAC9221_NID_I2S_OUT:
706	{
707	pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 3, 0)
708	\| CODEC_F00_09_CAP_DIGITAL
709	\| CODEC_F00_09_CAP_STEREO;
710	break;
711	}
712
713	case STAC9221_NID_PIN_I2S_OUT:
714	{
715	pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
716	\| CODEC_F00_09_CAP_DIGITAL
717	\| CODEC_F00_09_CAP_CONNECTION_LIST
718	\| CODEC_F00_09_CAP_STEREO;
719
720	pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_OUTPUT;
721
722	/* Connection list entries. */
723	pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
724	pNode->node.au32F02_param[0] = STAC9221_NID_I2S_OUT;
725
726	if (!pThis->fInReset)
727	pNode->reserved.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_NO_PHYS,
728	CODEC_F1C_LOCATION_NA,
729	CODEC_F1C_DEVICE_LINE_OUT,
730	CODEC_F1C_CONNECTION_TYPE_UNKNOWN,
731	CODEC_F1C_COLOR_UNKNOWN,
732	CODEC_F1C_MISC_NONE,
733	CODEC_F1C_ASSOCIATION_GROUP_15, 0x0 /* Ignored */);
734	break;
735	}
736
737	default:
738	AssertMsgFailed(("Node %RU8 not implemented\n", uNID));
739	break;
740	}
741	}
742
743	/**
744	* Resets the codec with all its connected nodes.
745	*
746	* @param pThis HDA codec to reset.
747	*/
748	static DECLCALLBACK(void) stac9220Reset(PHDACODEC pThis)
749	{
750	AssertPtrReturnVoid(pThis->aNodes);
751
752	LogRel(("HDA: Codec reset\n"));
753
754	pThis->fInReset = true;
755
756	for (uint8_t i = 0; i < pThis->cTotalNodes; i++)
757	stac9220NodeReset(pThis, i, &pThis->aNodes[i]);
758
759	pThis->fInReset = false;
760	}
761
762	#ifdef IN_RING3
763
764	static int stac9220Construct(PHDACODEC pThis)
765	{
766	pThis->u16VendorId = 0x8384; /* SigmaTel */
767	/*
768	* Note: The Linux kernel uses "patch_stac922x" for the fixups,
769	* which in turn uses "ref922x_pin_configs" for the configuration
770	* defaults tweaking in sound/pci/hda/patch_sigmatel.c.
771	*/
772	pThis->u16DeviceId = 0x7680; /* STAC9221 A1 */
773	pThis->u8BSKU = 0x76;
774	pThis->u8AssemblyId = 0x80;
775
776	pThis->fInReset = false;
777
778	#define STAC9220WIDGET(type) memcpy(&pThis->au8##type##s, &g_abStac9220##type##s, sizeof(uint8_t) * RT_ELEMENTS(g_abStac9220##type##s));
779	STAC9220WIDGET(Port);
780	STAC9220WIDGET(Dac);
781	STAC9220WIDGET(Adc);
782	STAC9220WIDGET(AdcVol);
783	STAC9220WIDGET(AdcMux);
784	STAC9220WIDGET(Pcbeep);
785	STAC9220WIDGET(SpdifIn);
786	STAC9220WIDGET(SpdifOut);
787	STAC9220WIDGET(DigInPin);
788	STAC9220WIDGET(DigOutPin);
789	STAC9220WIDGET(Cd);
790	STAC9220WIDGET(VolKnob);
791	STAC9220WIDGET(Reserved);
792	#undef STAC9220WIDGET
793
794	pThis->cTotalNodes = STAC9221_NUM_NODES;
795	Assert(pThis->cTotalNodes <= CODEC_NODES_MAX);
796
797	pThis->u8AdcVolsLineIn = STAC9220_NID_AMP_ADC0;
798	pThis->u8DacLineOut = STAC9220_NID_DAC1;
799
800	/*
801	* Initialize all codec nodes.
802	* This is specific to the codec, so do this here.
803	*
804	* Note: Do not call stac9220Reset() here, as this would not
805	* initialize the node default configuration values then!
806	*/
807	for (uint8_t i = 0; i < pThis->cTotalNodes; i++)
808	stac9220NodeReset(pThis, i, &pThis->aNodes[i]);
809
810	/* Common root node initializers. */
811	pThis->aNodes[STAC9220_NID_ROOT].root.node.au32F00_param[0] = CODEC_MAKE_F00_00(pThis->u16VendorId, pThis->u16DeviceId);
812	pThis->aNodes[STAC9220_NID_ROOT].root.node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
813
814	/* Common AFG node initializers. */
815	pThis->aNodes[STAC9220_NID_AFG].afg.node.au32F00_param[0x4] = CODEC_MAKE_F00_04(0x2, pThis->cTotalNodes - 2);
816	pThis->aNodes[STAC9220_NID_AFG].afg.node.au32F00_param[0x5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
817	pThis->aNodes[STAC9220_NID_AFG].afg.node.au32F00_param[0xA] = CODEC_F00_0A_44_1KHZ \| CODEC_F00_0A_16_BIT;
818	pThis->aNodes[STAC9220_NID_AFG].afg.u32F20_param = CODEC_MAKE_F20(pThis->u16VendorId, pThis->u8BSKU, pThis->u8AssemblyId);
819
820	return VINF_SUCCESS;
821	}
822
823	#endif /* IN_RING3 */
824
825	/*
826	* Some generic predicate functions.
827	*/
828
829	#define DECLISNODEOFTYPE(type) \
830	DECLINLINE(bool) hdaCodecIs##type##Node(PHDACODEC pThis, uint8_t cNode) \
831	{ \
832	Assert(pThis->au8##type##s); \
833	for (int i = 0; pThis->au8##type##s[i] != 0; ++i) \
834	if (pThis->au8##type##s[i] == cNode) \
835	return true; \
836	return false; \
837	}
838	/* hdaCodecIsPortNode */
839	DECLISNODEOFTYPE(Port)
840	/* hdaCodecIsDacNode */
841	DECLISNODEOFTYPE(Dac)
842	/* hdaCodecIsAdcVolNode */
843	DECLISNODEOFTYPE(AdcVol)
844	/* hdaCodecIsAdcNode */
845	DECLISNODEOFTYPE(Adc)
846	/* hdaCodecIsAdcMuxNode */
847	DECLISNODEOFTYPE(AdcMux)
848	/* hdaCodecIsPcbeepNode */
849	DECLISNODEOFTYPE(Pcbeep)
850	/* hdaCodecIsSpdifOutNode */
851	DECLISNODEOFTYPE(SpdifOut)
852	/* hdaCodecIsSpdifInNode */
853	DECLISNODEOFTYPE(SpdifIn)
854	/* hdaCodecIsDigInPinNode */
855	DECLISNODEOFTYPE(DigInPin)
856	/* hdaCodecIsDigOutPinNode */
857	DECLISNODEOFTYPE(DigOutPin)
858	/* hdaCodecIsCdNode */
859	DECLISNODEOFTYPE(Cd)
860	/* hdaCodecIsVolKnobNode */
861	DECLISNODEOFTYPE(VolKnob)
862	/* hdaCodecIsReservedNode */
863	DECLISNODEOFTYPE(Reserved)
864
865	#ifdef IN_RING3
866
867	/*
868	* Misc helpers.
869	*/
870	static int hdaR3CodecToAudVolume(PHDACODECR3 pThisCC, PCODECNODE pNode, AMPLIFIER *pAmp, PDMAUDIOMIXERCTL enmMixerCtl)
871	{
872	RT_NOREF(pNode);
873
874	uint8_t iDir;
875	switch (enmMixerCtl)
876	{
877	case PDMAUDIOMIXERCTL_VOLUME_MASTER:
878	case PDMAUDIOMIXERCTL_FRONT:
879	iDir = AMPLIFIER_OUT;
880	break;
881	case PDMAUDIOMIXERCTL_LINE_IN:
882	case PDMAUDIOMIXERCTL_MIC_IN:
883	iDir = AMPLIFIER_IN;
884	break;
885	default:
886	AssertMsgFailedReturn(("Invalid mixer control %RU32\n", enmMixerCtl), VERR_INVALID_PARAMETER);
887	break;
888	}
889
890	int iMute;
891	iMute = AMPLIFIER_REGISTER(*pAmp, iDir, AMPLIFIER_LEFT, 0) & RT_BIT(7);
892	iMute \|= AMPLIFIER_REGISTER(*pAmp, iDir, AMPLIFIER_RIGHT, 0) & RT_BIT(7);
893	iMute >>=7;
894	iMute &= 0x1;
895
896	uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, iDir, AMPLIFIER_LEFT, 0) & 0x7f;
897	uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, iDir, AMPLIFIER_RIGHT, 0) & 0x7f;
898
899	/*
900	* The STAC9220 volume controls have 0 to -96dB attenuation range in 128 steps.
901	* We have 0 to -96dB range in 256 steps. HDA volume setting of 127 must map
902	* to 255 internally (0dB), while HDA volume setting of 0 (-96dB) should map
903	* to 1 (rather than zero) internally.
904	*/
905	lVol = (lVol + 1) * (2 * 255) / 256;
906	rVol = (rVol + 1) * (2 * 255) / 256;
907
908	PDMAUDIOVOLUME Vol = { RT_BOOL(iMute), lVol, rVol };
909
910	LogFunc(("[NID0x%02x] %RU8/%RU8 (%s)\n",
911	pNode->node.uID, lVol, rVol, RT_BOOL(iMute) ? "Muted" : "Unmuted"));
912
913	LogRel2(("HDA: Setting volume for mixer control '%s' to %RU8/%RU8 (%s)\n",
914	PDMAudioMixerCtlGetName(enmMixerCtl), lVol, rVol, RT_BOOL(iMute) ? "Muted" : "Unmuted"));
915
916	return pThisCC->pfnCbMixerSetVolume(pThisCC->pDevIns, enmMixerCtl, &Vol);
917	}
918
919	#endif /* IN_RING3 */
920
921	DECLINLINE(void) hdaCodecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
922	{
923	Assert((pu32Reg && u8Offset < 32));
924	*pu32Reg &= ~(mask << u8Offset);
925	*pu32Reg \|= (u32Cmd & mask) << u8Offset;
926	}
927
928	DECLINLINE(void) hdaCodecSetRegisterU8(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
929	{
930	hdaCodecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_8BIT_DATA);
931	}
932
933	DECLINLINE(void) hdaCodecSetRegisterU16(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
934	{
935	hdaCodecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_16BIT_DATA);
936	}
937
938
939	/*
940	* Verb processor functions.
941	*/
942	#if 0 /* unused */
943
944	static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
945	{
946	RT_NOREF(pThis, pThisCC, cmd);
947	LogFlowFunc(("cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
948	CODEC_CAD(cmd), CODEC_DIRECT(cmd) ? 'N' : 'Y', CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
949	*pResp = 0;
950	return VINF_SUCCESS;
951	}
952
953	static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
954	{
955	int rc;
956	rc = vrbProcUnimplemented(pThis, pThisCC, cmd, pResp);
957	*pResp \|= CODEC_RESPONSE_UNSOLICITED;
958	return rc;
959	}
960
961	#endif /* unused */
962
963
964	/* B-- */
965	static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
966	{
967	RT_NOREF(pThisCC);
968	*pResp = 0;
969
970	/* HDA spec 7.3.3.7 Note A */
971	/** @todo If index out of range response should be 0. */
972	uint8_t u8Index = CODEC_GET_AMP_DIRECTION(cmd) == AMPLIFIER_OUT ? 0 : CODEC_GET_AMP_INDEX(cmd);
973
974	PCODECNODE pNode = &pThis->aNodes[CODEC_NID(cmd)];
975	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
976	*pResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
977	CODEC_GET_AMP_DIRECTION(cmd),
978	CODEC_GET_AMP_SIDE(cmd),
979	u8Index);
980	else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
981	*pResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
982	CODEC_GET_AMP_DIRECTION(cmd),
983	CODEC_GET_AMP_SIDE(cmd),
984	u8Index);
985	else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
986	*pResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
987	CODEC_GET_AMP_DIRECTION(cmd),
988	CODEC_GET_AMP_SIDE(cmd),
989	u8Index);
990	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
991	*pResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
992	CODEC_GET_AMP_DIRECTION(cmd),
993	CODEC_GET_AMP_SIDE(cmd),
994	u8Index);
995	else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
996	*pResp = AMPLIFIER_REGISTER(pNode->port.B_params,
997	CODEC_GET_AMP_DIRECTION(cmd),
998	CODEC_GET_AMP_SIDE(cmd),
999	u8Index);
1000	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1001	*pResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
1002	CODEC_GET_AMP_DIRECTION(cmd),
1003	CODEC_GET_AMP_SIDE(cmd),
1004	u8Index);
1005	else
1006	LogRel2(("HDA: Warning: Unhandled get amplifier command: 0x%x (NID=0x%x [%RU8])\n", cmd, CODEC_NID(cmd), CODEC_NID(cmd)));
1007
1008	return VINF_SUCCESS;
1009	}
1010
1011	static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1012	{
1013	RT_NOREF(pThisCC);
1014	Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
1015	if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
1016	{
1017	*pResp = 0;
1018
1019	LogFlowFunc(("invalid F00 parameter %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
1020	return VINF_SUCCESS;
1021	}
1022
1023	*pResp = pThis->aNodes[CODEC_NID(cmd)].node.au32F00_param[cmd & CODEC_VERB_8BIT_DATA];
1024	return VINF_SUCCESS;
1025	}
1026
1027	/* F01 */
1028	static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1029	{
1030	RT_NOREF(pThisCC);
1031	*pResp = 0;
1032
1033	if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1034	*pResp = pThis->aNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
1035	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1036	*pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F01_param;
1037	else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1038	*pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F01_param;
1039	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1040	*pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F01_param;
1041	else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1042	*pResp = pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
1043	else
1044	LogRel2(("HDA: Warning: Unhandled get connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1045
1046	return VINF_SUCCESS;
1047	}
1048
1049	/* 701 */
1050	static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1051	{
1052	RT_NOREF(pThisCC);
1053	*pResp = 0;
1054
1055	uint32_t *pu32Reg = NULL;
1056	if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1057	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
1058	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1059	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F01_param;
1060	else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1061	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F01_param;
1062	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1063	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F01_param;
1064	else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1065	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
1066	else
1067	LogRel2(("HDA: Warning: Unhandled set connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1068
1069	if (pu32Reg)
1070	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1071
1072	return VINF_SUCCESS;
1073	}
1074
1075	/* F07 */
1076	static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1077	{
1078	RT_NOREF(pThisCC);
1079	*pResp = 0;
1080
1081	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1082	*pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F07_param;
1083	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1084	*pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F07_param;
1085	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1086	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F07_param;
1087	else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1088	*pResp = pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
1089	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1090	*pResp = pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
1091	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1092	*pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F07_param;
1093	else
1094	LogRel2(("HDA: Warning: Unhandled get pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1095
1096	return VINF_SUCCESS;
1097	}
1098
1099	/* 707 */
1100	static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1101	{
1102	RT_NOREF(pThisCC);
1103	*pResp = 0;
1104
1105	uint32_t *pu32Reg = NULL;
1106	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1107	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F07_param;
1108	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1109	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F07_param;
1110	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1111	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F07_param;
1112	else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1113	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
1114	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1115	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
1116	else if ( hdaCodecIsReservedNode(pThis, CODEC_NID(cmd))
1117	&& CODEC_NID(cmd) == 0x1b)
1118	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F07_param;
1119	else
1120	LogRel2(("HDA: Warning: Unhandled set pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1121
1122	if (pu32Reg)
1123	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1124
1125	return VINF_SUCCESS;
1126	}
1127
1128	/* F08 */
1129	static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1130	{
1131	RT_NOREF(pThisCC);
1132	*pResp = 0;
1133
1134	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1135	*pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F08_param;
1136	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1137	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
1138	else if ((cmd) == STAC9220_NID_AFG)
1139	*pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F08_param;
1140	else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1141	*pResp = pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
1142	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1143	*pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F08_param;
1144	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1145	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
1146	else
1147	LogRel2(("HDA: Warning: Unhandled get unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1148
1149	return VINF_SUCCESS;
1150	}
1151
1152	/* 708 */
1153	static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1154	{
1155	RT_NOREF(pThisCC);
1156	*pResp = 0;
1157
1158	uint32_t *pu32Reg = NULL;
1159	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1160	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F08_param;
1161	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1162	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
1163	else if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1164	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F08_param;
1165	else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1166	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
1167	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1168	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
1169	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1170	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F08_param;
1171	else
1172	LogRel2(("HDA: Warning: Unhandled set unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1173
1174	if (pu32Reg)
1175	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1176
1177	return VINF_SUCCESS;
1178	}
1179
1180	/* F09 */
1181	static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1182	{
1183	RT_NOREF(pThisCC);
1184	*pResp = 0;
1185
1186	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1187	*pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F09_param;
1188	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1189	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F09_param;
1190	else
1191	{
1192	AssertFailed();
1193	LogRel2(("HDA: Warning: Unhandled get pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1194	}
1195
1196	return VINF_SUCCESS;
1197	}
1198
1199	/* 709 */
1200	static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1201	{
1202	RT_NOREF(pThisCC);
1203	*pResp = 0;
1204
1205	uint32_t *pu32Reg = NULL;
1206	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1207	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F09_param;
1208	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1209	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F09_param;
1210	else
1211	LogRel2(("HDA: Warning: Unhandled set pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1212
1213	if (pu32Reg)
1214	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1215
1216	return VINF_SUCCESS;
1217	}
1218
1219	static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1220	{
1221	RT_NOREF(pThisCC);
1222	*pResp = 0;
1223
1224	Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F02_PARAM_LENGTH);
1225	if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F02_PARAM_LENGTH)
1226	{
1227	LogFlowFunc(("access to invalid F02 index %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
1228	return VINF_SUCCESS;
1229	}
1230	*pResp = pThis->aNodes[CODEC_NID(cmd)].node.au32F02_param[cmd & CODEC_VERB_8BIT_DATA];
1231	return VINF_SUCCESS;
1232	}
1233
1234	/* F03 */
1235	static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1236	{
1237	RT_NOREF(pThisCC);
1238	*pResp = 0;
1239
1240	if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1241	*pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F03_param;
1242
1243	return VINF_SUCCESS;
1244	}
1245
1246	/* 703 */
1247	static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1248	{
1249	RT_NOREF(pThisCC);
1250	*pResp = 0;
1251
1252	if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1253	hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
1254	return VINF_SUCCESS;
1255	}
1256
1257	/* F0D */
1258	static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1259	{
1260	RT_NOREF(pThisCC);
1261	*pResp = 0;
1262
1263	if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1264	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
1265	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1266	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
1267
1268	return VINF_SUCCESS;
1269	}
1270
1271	static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
1272	{
1273	*pResp = 0;
1274
1275	if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1276	hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
1277	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1278	hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
1279	return VINF_SUCCESS;
1280	}
1281
1282	/* 70D */
1283	static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1284	{
1285	RT_NOREF(pThisCC);
1286	return codecSetDigitalConverter(pThis, cmd, 0, pResp);
1287	}
1288
1289	/* 70E */
1290	static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1291	{
1292	RT_NOREF(pThisCC);
1293	return codecSetDigitalConverter(pThis, cmd, 8, pResp);
1294	}
1295
1296	/* F20 */
1297	static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1298	{
1299	RT_NOREF(pThisCC);
1300	Assert(CODEC_CAD(cmd) == pThis->id);
1301	Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1302	if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1303	{
1304	LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1305	return VINF_SUCCESS;
1306	}
1307	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1308	*pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F20_param;
1309	else
1310	*pResp = 0;
1311	return VINF_SUCCESS;
1312	}
1313
1314	static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
1315	{
1316	Assert(CODEC_CAD(cmd) == pThis->id);
1317	Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1318	if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1319	{
1320	LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1321	return VINF_SUCCESS;
1322	}
1323	uint32_t *pu32Reg;
1324	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1325	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F20_param;
1326	else
1327	AssertFailedReturn(VINF_SUCCESS);
1328	hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
1329	return VINF_SUCCESS;
1330	}
1331
1332	/* 720 */
1333	static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1334	{
1335	RT_NOREF(pThisCC);
1336	*pResp = 0;
1337	return codecSetSubIdX(pThis, cmd, 0);
1338	}
1339
1340	/* 721 */
1341	static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1342	{
1343	RT_NOREF(pThisCC);
1344	*pResp = 0;
1345	return codecSetSubIdX(pThis, cmd, 8);
1346	}
1347
1348	/* 722 */
1349	static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1350	{
1351	RT_NOREF(pThisCC);
1352	*pResp = 0;
1353	return codecSetSubIdX(pThis, cmd, 16);
1354	}
1355
1356	/* 723 */
1357	static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1358	{
1359	RT_NOREF(pThisCC);
1360	*pResp = 0;
1361	return codecSetSubIdX(pThis, cmd, 24);
1362	}
1363
1364	static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1365	{
1366	RT_NOREF(pThisCC);
1367	Assert(CODEC_CAD(cmd) == pThis->id);
1368
1369	if (pThis->enmType == CODEC_TYPE_STAC9220)
1370	{
1371	Assert(CODEC_NID(cmd) == STAC9220_NID_AFG);
1372
1373	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1374	stac9220Reset(pThis);
1375	}
1376	else
1377	AssertFailedReturn(VERR_NOT_IMPLEMENTED);
1378
1379	*pResp = 0;
1380	return VINF_SUCCESS;
1381	}
1382
1383	/* F05 */
1384	static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1385	{
1386	RT_NOREF(pThisCC);
1387	*pResp = 0;
1388
1389	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1390	*pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
1391	else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1392	*pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
1393	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1394	*pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
1395	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1396	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
1397	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1398	*pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F05_param;
1399	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1400	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
1401	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1402	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
1403	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1404	*pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
1405	else
1406	LogRel2(("HDA: Warning: Unhandled get power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1407
1408	LogFunc(("[NID0x%02x]: fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
1409	CODEC_NID(cmd), CODEC_F05_IS_RESET(pResp), CODEC_F05_IS_STOPOK(pResp), CODEC_F05_ACT(pResp), CODEC_F05_SET(pResp)));
1410	return VINF_SUCCESS;
1411	}
1412
1413	/* 705 */
1414	#if 1
1415	static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1416	{
1417	RT_NOREF(pThisCC);
1418	*pResp = 0;
1419
1420	uint32_t *pu32Reg = NULL;
1421	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1422	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
1423	else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1424	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
1425	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1426	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
1427	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1428	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F05_param;
1429	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1430	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
1431	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1432	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
1433	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1434	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
1435	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1436	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
1437	else
1438	{
1439	LogRel2(("HDA: Warning: Unhandled set power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1440	}
1441
1442	if (!pu32Reg)
1443	return VINF_SUCCESS;
1444
1445	uint8_t uPwrCmd = CODEC_F05_SET (cmd);
1446	bool fReset = CODEC_F05_IS_RESET (*pu32Reg);
1447	bool fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
1448	#ifdef LOG_ENABLED
1449	bool fError = CODEC_F05_IS_ERROR (*pu32Reg);
1450	uint8_t uPwrAct = CODEC_F05_ACT (*pu32Reg);
1451	uint8_t uPwrSet = CODEC_F05_SET (*pu32Reg);
1452	LogFunc(("[NID0x%02x] Cmd=D%RU8, fReset=%RTbool, fStopOk=%RTbool, fError=%RTbool, uPwrAct=D%RU8, uPwrSet=D%RU8\n",
1453	CODEC_NID(cmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
1454	LogFunc(("AFG: Act=D%RU8, Set=D%RU8\n",
1455	CODEC_F05_ACT(pThis->aNodes[STAC9220_NID_AFG].afg.u32F05_param),
1456	CODEC_F05_SET(pThis->aNodes[STAC9220_NID_AFG].afg.u32F05_param)));
1457	#endif
1458
1459	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1460	pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uPwrCmd / PS-Act /, uPwrCmd / PS-Set */);
1461
1462	const uint8_t uAFGPwrAct = CODEC_F05_ACT(pThis->aNodes[STAC9220_NID_AFG].afg.u32F05_param);
1463	if (uAFGPwrAct == CODEC_F05_D0) /* Only propagate power state if AFG is on (D0). */
1464	{
1465	/* Propagate to all other nodes under this AFG. */
1466	LogFunc(("Propagating Act=D%RU8 (AFG), Set=D%RU8 to all AFG child nodes ...\n", uAFGPwrAct, uPwrCmd));
1467
1468	#define PROPAGATE_PWR_STATE(_aList, _aMember) \
1469	{ \
1470	const uint8_t *pu8NodeIndex = &_aList[0]; \
1471	while (*(++pu8NodeIndex)) \
1472	{ \
1473	pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param = \
1474	CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd); \
1475	LogFunc(("\t[NID0x%02x]: Act=D%RU8, Set=D%RU8\n", *pu8NodeIndex, \
1476	CODEC_F05_ACT(pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param), \
1477	CODEC_F05_SET(pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param))); \
1478	} \
1479	}
1480
1481	PROPAGATE_PWR_STATE(pThis->au8Dacs, dac);
1482	PROPAGATE_PWR_STATE(pThis->au8Adcs, adc);
1483	PROPAGATE_PWR_STATE(pThis->au8DigInPins, digin);
1484	PROPAGATE_PWR_STATE(pThis->au8DigOutPins, digout);
1485	PROPAGATE_PWR_STATE(pThis->au8SpdifIns, spdifin);
1486	PROPAGATE_PWR_STATE(pThis->au8SpdifOuts, spdifout);
1487	PROPAGATE_PWR_STATE(pThis->au8Reserveds, reserved);
1488
1489	#undef PROPAGATE_PWR_STATE
1490	}
1491	/*
1492	* If this node is a reqular node (not the AFG one), adopt PS-Set of the AFG node
1493	* as PS-Set of this node. PS-Act always is one level under PS-Set here.
1494	*/
1495	else
1496	{
1497	*pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd);
1498	}
1499
1500	LogFunc(("[NID0x%02x] fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
1501	CODEC_NID(cmd),
1502	CODEC_F05_IS_RESET(pu32Reg), CODEC_F05_IS_STOPOK(pu32Reg), CODEC_F05_ACT(pu32Reg), CODEC_F05_SET(pu32Reg)));
1503
1504	return VINF_SUCCESS;
1505	}
1506	#else
1507	DECLINLINE(void) codecPropogatePowerState(uint32_t *pu32F05_param)
1508	{
1509	Assert(pu32F05_param);
1510	if (!pu32F05_param)
1511	return;
1512	bool fReset = CODEC_F05_IS_RESET(*pu32F05_param);
1513	bool fStopOk = CODEC_F05_IS_STOPOK(*pu32F05_param);
1514	uint8_t u8SetPowerState = CODEC_F05_SET(*pu32F05_param);
1515	*pu32F05_param = CODEC_MAKE_F05(fReset, fStopOk, 0, u8SetPowerState, u8SetPowerState);
1516	}
1517
1518	static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1519	{
1520	RT_NOREF(pThisCC);
1521	Assert(CODEC_CAD(cmd) == pThis->id);
1522	Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1523	if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1524	{
1525	LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1526	return VINF_SUCCESS;
1527	}
1528	*pResp = 0;
1529	uint32_t *pu32Reg;
1530	if (CODEC_NID(cmd) == 1 /* AFG */)
1531	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
1532	else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1533	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
1534	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1535	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
1536	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1537	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
1538	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1539	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
1540	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1541	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
1542	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1543	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
1544	else
1545	AssertFailedReturn(VINF_SUCCESS);
1546
1547	bool fReset = CODEC_F05_IS_RESET(*pu32Reg);
1548	bool fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
1549
1550	if (CODEC_NID(cmd) != 1 /* AFG */)
1551	{
1552	/*
1553	* We shouldn't propogate actual power state, which actual for AFG
1554	*/
1555	*pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0,
1556	CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param),
1557	CODEC_F05_SET(cmd));
1558	}
1559
1560	/* Propagate next power state only if AFG is on or verb modifies AFG power state */
1561	if ( CODEC_NID(cmd) == 1 /* AFG */
1562	\|\| !CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param))
1563	{
1564	*pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(cmd), CODEC_F05_SET(cmd));
1565	if ( CODEC_NID(cmd) == 1 /* AFG */
1566	&& (CODEC_F05_SET(cmd)) == CODEC_F05_D0)
1567	{
1568	/* now we're powered on AFG and may propogate power states on nodes */
1569	const uint8_t *pu8NodeIndex = &pThis->au8Dacs[0];
1570	while (*(++pu8NodeIndex))
1571	codecPropogatePowerState(&pThis->aNodes[*pu8NodeIndex].dac.u32F05_param);
1572
1573	pu8NodeIndex = &pThis->au8Adcs[0];
1574	while (*(++pu8NodeIndex))
1575	codecPropogatePowerState(&pThis->aNodes[*pu8NodeIndex].adc.u32F05_param);
1576
1577	pu8NodeIndex = &pThis->au8DigInPins[0];
1578	while (*(++pu8NodeIndex))
1579	codecPropogatePowerState(&pThis->aNodes[*pu8NodeIndex].digin.u32F05_param);
1580	}
1581	}
1582	return VINF_SUCCESS;
1583	}
1584	#endif
1585
1586	/* F06 */
1587	static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1588	{
1589	RT_NOREF(pThisCC);
1590	*pResp = 0;
1591
1592	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1593	*pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F06_param;
1594	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1595	*pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F06_param;
1596	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1597	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
1598	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1599	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
1600	else if (CODEC_NID(cmd) == STAC9221_NID_I2S_OUT)
1601	*pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F06_param;
1602	else
1603	LogRel2(("HDA: Warning: Unhandled get stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1604
1605	LogFlowFunc(("[NID0x%02x] Stream ID=%RU8, channel=%RU8\n",
1606	CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(cmd), CODEC_F00_06_GET_CHANNEL_ID(cmd)));
1607
1608	return VINF_SUCCESS;
1609	}
1610
1611	/* A0 */
1612	static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1613	{
1614	RT_NOREF(pThisCC);
1615	*pResp = 0;
1616
1617	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1618	*pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32A_param;
1619	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1620	*pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32A_param;
1621	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1622	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32A_param;
1623	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1624	*pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32A_param;
1625	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1626	*pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32A_param;
1627	else
1628	LogRel2(("HDA: Warning: Unhandled get converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1629
1630	return VINF_SUCCESS;
1631	}
1632
1633	/* Also see section 3.7.1. */
1634	static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1635	{
1636	RT_NOREF(pThisCC);
1637	*pResp = 0;
1638
1639	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1640	hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
1641	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1642	hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
1643	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1644	hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
1645	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1646	hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
1647	else
1648	LogRel2(("HDA: Warning: Unhandled set converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1649
1650	return VINF_SUCCESS;
1651	}
1652
1653	/* F0C */
1654	static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1655	{
1656	RT_NOREF(pThisCC);
1657	*pResp = 0;
1658
1659	if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1660	*pResp = pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
1661	else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1662	*pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F0c_param;
1663	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1664	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F0c_param;
1665	else
1666	LogRel2(("HDA: Warning: Unhandled get EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1667
1668	return VINF_SUCCESS;
1669	}
1670
1671	/* 70C */
1672	static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1673	{
1674	RT_NOREF(pThisCC);
1675	*pResp = 0;
1676
1677	uint32_t *pu32Reg = NULL;
1678	if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1679	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
1680	else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1681	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F0c_param;
1682	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1683	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F0c_param;
1684	else
1685	LogRel2(("HDA: Warning: Unhandled set EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1686
1687	if (pu32Reg)
1688	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1689
1690	return VINF_SUCCESS;
1691	}
1692
1693	/* F0F */
1694	static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1695	{
1696	RT_NOREF(pThisCC);
1697	*pResp = 0;
1698
1699	if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1700	*pResp = pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
1701	else
1702	LogRel2(("HDA: Warning: Unhandled get volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1703
1704	return VINF_SUCCESS;
1705	}
1706
1707	/* 70F */
1708	static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1709	{
1710	RT_NOREF(pThisCC);
1711	*pResp = 0;
1712
1713	uint32_t *pu32Reg = NULL;
1714	if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1715	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
1716	else
1717	LogRel2(("HDA: Warning: Unhandled set volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1718
1719	if (pu32Reg)
1720	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1721
1722	return VINF_SUCCESS;
1723	}
1724
1725	/* F15 */
1726	static DECLCALLBACK(int) vrbProcGetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1727	{
1728	RT_NOREF(pThis, pThisCC, cmd);
1729	*pResp = 0;
1730	return VINF_SUCCESS;
1731	}
1732
1733	/* 715 */
1734	static DECLCALLBACK(int) vrbProcSetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1735	{
1736	RT_NOREF(pThis, pThisCC, cmd);
1737	*pResp = 0;
1738	return VINF_SUCCESS;
1739	}
1740
1741	/* F16 */
1742	static DECLCALLBACK(int) vrbProcGetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1743	{
1744	RT_NOREF(pThis, pThisCC, cmd);
1745	*pResp = 0;
1746	return VINF_SUCCESS;
1747	}
1748
1749	/* 716 */
1750	static DECLCALLBACK(int) vrbProcSetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1751	{
1752	RT_NOREF(pThis, pThisCC, cmd);
1753	*pResp = 0;
1754	return VINF_SUCCESS;
1755	}
1756
1757	/* F17 */
1758	static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1759	{
1760	RT_NOREF(pThisCC);
1761	*pResp = 0;
1762
1763	/* Note: this is true for ALC885. */
1764	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1765	*pResp = pThis->aNodes[1].afg.u32F17_param;
1766	else
1767	LogRel2(("HDA: Warning: Unhandled get GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1768
1769	return VINF_SUCCESS;
1770	}
1771
1772	/* 717 */
1773	static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1774	{
1775	RT_NOREF(pThisCC);
1776	*pResp = 0;
1777
1778	uint32_t *pu32Reg = NULL;
1779	if (CODEC_NID(cmd) == STAC9220_NID_AFG)
1780	pu32Reg = &pThis->aNodes[1].afg.u32F17_param;
1781	else
1782	LogRel2(("HDA: Warning: Unhandled set GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1783
1784	if (pu32Reg)
1785	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1786
1787	return VINF_SUCCESS;
1788	}
1789
1790	/* F1C */
1791	static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1792	{
1793	RT_NOREF(pThisCC);
1794	*pResp = 0;
1795
1796	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1797	*pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F1c_param;
1798	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1799	*pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F1c_param;
1800	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1801	*pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F1c_param;
1802	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1803	*pResp = pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
1804	else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1805	*pResp = pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
1806	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1807	*pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
1808	else
1809	LogRel2(("HDA: Warning: Unhandled get config command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1810
1811	return VINF_SUCCESS;
1812	}
1813
1814	static int codecSetConfigX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
1815	{
1816	uint32_t *pu32Reg = NULL;
1817	if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1818	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F1c_param;
1819	else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1820	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F1c_param;
1821	else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1822	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F1c_param;
1823	else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1824	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
1825	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1826	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
1827	else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1828	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
1829	else
1830	LogRel2(("HDA: Warning: Unhandled set config command (%RU8) for NID0x%02x: 0x%x\n", u8Offset, CODEC_NID(cmd), cmd));
1831
1832	if (pu32Reg)
1833	hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
1834
1835	return VINF_SUCCESS;
1836	}
1837
1838	/* 71C */
1839	static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1840	{
1841	RT_NOREF(pThisCC);
1842	*pResp = 0;
1843	return codecSetConfigX(pThis, cmd, 0);
1844	}
1845
1846	/* 71D */
1847	static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1848	{
1849	RT_NOREF(pThisCC);
1850	*pResp = 0;
1851	return codecSetConfigX(pThis, cmd, 8);
1852	}
1853
1854	/* 71E */
1855	static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1856	{
1857	RT_NOREF(pThisCC);
1858	*pResp = 0;
1859	return codecSetConfigX(pThis, cmd, 16);
1860	}
1861
1862	/* 71E */
1863	static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1864	{
1865	RT_NOREF(pThisCC);
1866	*pResp = 0;
1867	return codecSetConfigX(pThis, cmd, 24);
1868	}
1869
1870	/* F04 */
1871	static DECLCALLBACK(int) vrbProcGetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1872	{
1873	RT_NOREF(pThisCC);
1874	*pResp = 0;
1875
1876	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1877	*pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F04_param;
1878	else
1879	LogRel2(("HDA: Warning: Unhandled get SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1880
1881	return VINF_SUCCESS;
1882	}
1883
1884	/* 704 */
1885	static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1886	{
1887	RT_NOREF(pThisCC);
1888	*pResp = 0;
1889
1890	uint32_t *pu32Reg = NULL;
1891	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1892	pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F04_param;
1893	else
1894	LogRel2(("HDA: Warning: Unhandled set SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
1895
1896	if (pu32Reg)
1897	hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1898
1899	return VINF_SUCCESS;
1900	}
1901
1902	#ifdef IN_RING3
1903
1904	/* 3-- */
1905	static DECLCALLBACK(int) vrbProcR3SetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1906	{
1907	*pResp = 0;
1908
1909	PCODECNODE pNode = &pThis->aNodes[CODEC_NID(cmd)];
1910	AMPLIFIER *pAmplifier = NULL;
1911	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1912	pAmplifier = &pNode->dac.B_params;
1913	else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1914	pAmplifier = &pNode->adcvol.B_params;
1915	else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1916	pAmplifier = &pNode->adcmux.B_params;
1917	else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1918	pAmplifier = &pNode->pcbeep.B_params;
1919	else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1920	pAmplifier = &pNode->port.B_params;
1921	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1922	pAmplifier = &pNode->adc.B_params;
1923	else
1924	LogRel2(("HDA: Warning: Unhandled set amplifier command: 0x%x (Payload=%RU16, NID=0x%x [%RU8])\n",
1925	cmd, CODEC_VERB_PAYLOAD16(cmd), CODEC_NID(cmd), CODEC_NID(cmd)));
1926
1927	if (!pAmplifier)
1928	return VINF_SUCCESS;
1929
1930	bool fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
1931	bool fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
1932	bool fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
1933	bool fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
1934	uint8_t u8Index = CODEC_SET_AMP_INDEX(cmd);
1935
1936	if ( (!fIsLeft && !fIsRight)
1937	\|\| (!fIsOut && !fIsIn))
1938	return VINF_SUCCESS;
1939
1940	LogFunc(("[NID0x%02x] fIsOut=%RTbool, fIsIn=%RTbool, fIsLeft=%RTbool, fIsRight=%RTbool, Idx=%RU8\n",
1941	CODEC_NID(cmd), fIsOut, fIsIn, fIsLeft, fIsRight, u8Index));
1942
1943	if (fIsIn)
1944	{
1945	if (fIsLeft)
1946	hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
1947	if (fIsRight)
1948	hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
1949
1950	// if (CODEC_NID(cmd) == pThis->u8AdcVolsLineIn)
1951	// {
1952	hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_LINE_IN);
1953	// }
1954	}
1955	if (fIsOut)
1956	{
1957	if (fIsLeft)
1958	hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
1959	if (fIsRight)
1960	hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
1961
1962	if (CODEC_NID(cmd) == pThis->u8DacLineOut)
1963	hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_FRONT);
1964	}
1965
1966	return VINF_SUCCESS;
1967	}
1968
1969	/* 706 */
1970	static DECLCALLBACK(int) vrbProcR3SetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
1971	{
1972	*pResp = 0;
1973
1974	uint8_t uSD = CODEC_F00_06_GET_STREAM_ID(cmd);
1975	uint8_t uChannel = CODEC_F00_06_GET_CHANNEL_ID(cmd);
1976
1977	LogFlowFunc(("[NID0x%02x] Setting to stream ID=%RU8, channel=%RU8\n",
1978	CODEC_NID(cmd), uSD, uChannel));
1979
1980	ASSERT_GUEST_LOGREL_MSG_RETURN(uSD < HDA_MAX_STREAMS,
1981	("Setting stream ID #%RU8 is invalid\n", uSD), VERR_INVALID_PARAMETER);
1982
1983	PDMAUDIODIR enmDir;
1984	uint32_t *pu32Addr;
1985	if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1986	{
1987	pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F06_param;
1988	enmDir = PDMAUDIODIR_OUT;
1989	}
1990	else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1991	{
1992	pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F06_param;
1993	enmDir = PDMAUDIODIR_IN;
1994	}
1995	else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1996	{
1997	pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
1998	enmDir = PDMAUDIODIR_OUT;
1999	}
2000	else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
2001	{
2002	pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
2003	enmDir = PDMAUDIODIR_IN;
2004	}
2005	else
2006	{
2007	enmDir = PDMAUDIODIR_UNKNOWN;
2008	LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
2009	return VINF_SUCCESS;
2010	}
2011
2012	/* Do we (re-)assign our input/output SDn (SDI/SDO) IDs? */
2013	pThis->aNodes[CODEC_NID(cmd)].node.uSD = uSD;
2014	pThis->aNodes[CODEC_NID(cmd)].node.uChannel = uChannel;
2015
2016	if (enmDir == PDMAUDIODIR_OUT)
2017	{
2018	/** @todo Check if non-interleaved streams need a different channel / SDn? */
2019
2020	/* Propagate to the controller. */
2021	pThisCC->pfnCbMixerControl(pThisCC->pDevIns, PDMAUDIOMIXERCTL_FRONT, uSD, uChannel);
2022	# ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
2023	pThisCC->pfnCbMixerControl(pThisCC->pDevIns, PDMAUDIOMIXERCTL_CENTER_LFE, uSD, uChannel);
2024	pThisCC->pfnCbMixerControl(pThisCC->pDevIns, PDMAUDIOMIXERCTL_REAR, uSD, uChannel);
2025	# endif
2026	}
2027	else if (enmDir == PDMAUDIODIR_IN)
2028	{
2029	pThisCC->pfnCbMixerControl(pThisCC->pDevIns, PDMAUDIOMIXERCTL_LINE_IN, uSD, uChannel);
2030	# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
2031	pThisCC->pfnCbMixerControl(pThisCC->pDevIns, PDMAUDIOMIXERCTL_MIC_IN, uSD, uChannel);
2032	# endif
2033	}
2034
2035	hdaCodecSetRegisterU8(pu32Addr, cmd, 0);
2036
2037	return VINF_SUCCESS;
2038	}
2039
2040	#endif /* IN_RING3 */
2041
2042
2043	/**
2044	* HDA codec verb descriptors.
2045	*
2046	* @todo Any reason not to use binary search here?
2047	* bird: because you'd need to sort the entries first...
2048	*/
2049	static const CODECVERB g_aCodecVerbs[] =
2050	{
2051	/* Verb Verb mask Callback Name
2052	---------- --------------------- ------------------------------------------------------------------- */
2053	{ 0x000F0000, CODEC_VERB_8BIT_CMD , vrbProcGetParameter , "GetParameter " },
2054	{ 0x000F0100, CODEC_VERB_8BIT_CMD , vrbProcGetConSelectCtrl , "GetConSelectCtrl " },
2055	{ 0x00070100, CODEC_VERB_8BIT_CMD , vrbProcSetConSelectCtrl , "SetConSelectCtrl " },
2056	{ 0x000F0600, CODEC_VERB_8BIT_CMD , vrbProcGetStreamId , "GetStreamId " },
2057	{ 0x00070600, CODEC_VERB_8BIT_CMD , CTX_EXPR(vrbProcR3SetStreamId,NULL,NULL) , "SetStreamId " },
2058	{ 0x000F0700, CODEC_VERB_8BIT_CMD , vrbProcGetPinCtrl , "GetPinCtrl " },
2059	{ 0x00070700, CODEC_VERB_8BIT_CMD , vrbProcSetPinCtrl , "SetPinCtrl " },
2060	{ 0x000F0800, CODEC_VERB_8BIT_CMD , vrbProcGetUnsolicitedEnabled , "GetUnsolicitedEnabled " },
2061	{ 0x00070800, CODEC_VERB_8BIT_CMD , vrbProcSetUnsolicitedEnabled , "SetUnsolicitedEnabled " },
2062	{ 0x000F0900, CODEC_VERB_8BIT_CMD , vrbProcGetPinSense , "GetPinSense " },
2063	{ 0x00070900, CODEC_VERB_8BIT_CMD , vrbProcSetPinSense , "SetPinSense " },
2064	{ 0x000F0200, CODEC_VERB_8BIT_CMD , vrbProcGetConnectionListEntry , "GetConnectionListEntry" },
2065	{ 0x000F0300, CODEC_VERB_8BIT_CMD , vrbProcGetProcessingState , "GetProcessingState " },
2066	{ 0x00070300, CODEC_VERB_8BIT_CMD , vrbProcSetProcessingState , "SetProcessingState " },
2067	{ 0x000F0D00, CODEC_VERB_8BIT_CMD , vrbProcGetDigitalConverter , "GetDigitalConverter " },
2068	{ 0x00070D00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter1 , "SetDigitalConverter1 " },
2069	{ 0x00070E00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter2 , "SetDigitalConverter2 " },
2070	{ 0x000F2000, CODEC_VERB_8BIT_CMD , vrbProcGetSubId , "GetSubId " },
2071	{ 0x00072000, CODEC_VERB_8BIT_CMD , vrbProcSetSubId0 , "SetSubId0 " },
2072	{ 0x00072100, CODEC_VERB_8BIT_CMD , vrbProcSetSubId1 , "SetSubId1 " },
2073	{ 0x00072200, CODEC_VERB_8BIT_CMD , vrbProcSetSubId2 , "SetSubId2 " },
2074	{ 0x00072300, CODEC_VERB_8BIT_CMD , vrbProcSetSubId3 , "SetSubId3 " },
2075	{ 0x0007FF00, CODEC_VERB_8BIT_CMD , vrbProcReset , "Reset " },
2076	{ 0x000F0500, CODEC_VERB_8BIT_CMD , vrbProcGetPowerState , "GetPowerState " },
2077	{ 0x00070500, CODEC_VERB_8BIT_CMD , vrbProcSetPowerState , "SetPowerState " },
2078	{ 0x000F0C00, CODEC_VERB_8BIT_CMD , vrbProcGetEAPD_BTLEnabled , "GetEAPD_BTLEnabled " },
2079	{ 0x00070C00, CODEC_VERB_8BIT_CMD , vrbProcSetEAPD_BTLEnabled , "SetEAPD_BTLEnabled " },
2080	{ 0x000F0F00, CODEC_VERB_8BIT_CMD , vrbProcGetVolumeKnobCtrl , "GetVolumeKnobCtrl " },
2081	{ 0x00070F00, CODEC_VERB_8BIT_CMD , vrbProcSetVolumeKnobCtrl , "SetVolumeKnobCtrl " },
2082	{ 0x000F1500, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOData , "GetGPIOData " },
2083	{ 0x00071500, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOData , "SetGPIOData " },
2084	{ 0x000F1600, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOEnableMask , "GetGPIOEnableMask " },
2085	{ 0x00071600, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOEnableMask , "SetGPIOEnableMask " },
2086	{ 0x000F1700, CODEC_VERB_8BIT_CMD , vrbProcGetGPIODirection , "GetGPIODirection " },
2087	{ 0x00071700, CODEC_VERB_8BIT_CMD , vrbProcSetGPIODirection , "SetGPIODirection " },
2088	{ 0x000F1C00, CODEC_VERB_8BIT_CMD , vrbProcGetConfig , "GetConfig " },
2089	{ 0x00071C00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig0 , "SetConfig0 " },
2090	{ 0x00071D00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig1 , "SetConfig1 " },
2091	{ 0x00071E00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig2 , "SetConfig2 " },
2092	{ 0x00071F00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig3 , "SetConfig3 " },
2093	{ 0x000A0000, CODEC_VERB_16BIT_CMD, vrbProcGetConverterFormat , "GetConverterFormat " },
2094	{ 0x00020000, CODEC_VERB_16BIT_CMD, vrbProcSetConverterFormat , "SetConverterFormat " },
2095	{ 0x000B0000, CODEC_VERB_16BIT_CMD, vrbProcGetAmplifier , "GetAmplifier " },
2096	{ 0x00030000, CODEC_VERB_16BIT_CMD, CTX_EXPR(vrbProcR3SetAmplifier,NULL,NULL), "SetAmplifier " },
2097	{ 0x000F0400, CODEC_VERB_8BIT_CMD , vrbProcGetSDISelect , "GetSDISelect " },
2098	{ 0x00070400, CODEC_VERB_8BIT_CMD , vrbProcSetSDISelect , "SetSDISelect " },
2099	/** @todo Implement 0x7e7: IDT Set GPIO (STAC922x only). */
2100	};
2101
2102
2103	#ifdef IN_RING3
2104
2105	/**
2106	* CODEC debug info item printing state.
2107	*/
2108	typedef struct CODECDEBUG
2109	{
2110	/** DBGF info helpers. */
2111	PCDBGFINFOHLP pHlp;
2112	/** Current recursion level. */
2113	uint8_t uLevel;
2114	/** Pointer to codec state. */
2115	PHDACODEC pThis;
2116	} CODECDEBUG;
2117	/** Pointer to the debug info item printing state for the codec. */
2118	typedef CODECDEBUG *PCODECDEBUG;
2119
2120	#define CODECDBG_INDENT pInfo->uLevel++;
2121	#define CODECDBG_UNINDENT if (pInfo->uLevel) pInfo->uLevel--;
2122
2123	#define CODECDBG_PRINT(...) pInfo->pHlp->pfnPrintf(pInfo->pHlp, __VA_ARGS__)
2124	#define CODECDBG_PRINTI(...) codecDbgPrintf(pInfo, __VA_ARGS__)
2125
2126	/** Wrapper around DBGFINFOHLP::pfnPrintf that adds identation. */
2127	static void codecDbgPrintf(PCODECDEBUG pInfo, const char *pszFormat, ...)
2128	{
2129	va_list va;
2130	va_start(va, pszFormat);
2131	pInfo->pHlp->pfnPrintf(pInfo->pHlp, "%s%N", pInfo->uLevel 4, "", pszFormat, &va);
2132	va_end(va);
2133	}
2134
2135	/** Power state */
2136	static void codecDbgPrintNodeRegF05(PCODECDEBUG pInfo, uint32_t u32Reg)
2137	{
2138	codecDbgPrintf(pInfo, "Power (F05): fReset=%RTbool, fStopOk=%RTbool, Set=%RU8, Act=%RU8\n",
2139	CODEC_F05_IS_RESET(u32Reg), CODEC_F05_IS_STOPOK(u32Reg), CODEC_F05_SET(u32Reg), CODEC_F05_ACT(u32Reg));
2140	}
2141
2142	static void codecDbgPrintNodeRegA(PCODECDEBUG pInfo, uint32_t u32Reg)
2143	{
2144	codecDbgPrintf(pInfo, "RegA: %x\n", u32Reg);
2145	}
2146
2147	static void codecDbgPrintNodeRegF00(PCODECDEBUG pInfo, uint32_t *paReg00)
2148	{
2149	codecDbgPrintf(pInfo, "Parameters (F00):\n");
2150
2151	CODECDBG_INDENT
2152	codecDbgPrintf(pInfo, "Connections: %RU8\n", CODEC_F00_0E_COUNT(paReg00[0xE]));
2153	codecDbgPrintf(pInfo, "Amplifier Caps:\n");
2154	uint32_t uReg = paReg00[0xD];
2155	CODECDBG_INDENT
2156	codecDbgPrintf(pInfo, "Input Steps=%02RU8, StepSize=%02RU8, StepOff=%02RU8, fCanMute=%RTbool\n",
2157	CODEC_F00_0D_NUM_STEPS(uReg),
2158	CODEC_F00_0D_STEP_SIZE(uReg),
2159	CODEC_F00_0D_OFFSET(uReg),
2160	RT_BOOL(CODEC_F00_0D_IS_CAP_MUTE(uReg)));
2161
2162	uReg = paReg00[0x12];
2163	codecDbgPrintf(pInfo, "Output Steps=%02RU8, StepSize=%02RU8, StepOff=%02RU8, fCanMute=%RTbool\n",
2164	CODEC_F00_12_NUM_STEPS(uReg),
2165	CODEC_F00_12_STEP_SIZE(uReg),
2166	CODEC_F00_12_OFFSET(uReg),
2167	RT_BOOL(CODEC_F00_12_IS_CAP_MUTE(uReg)));
2168	CODECDBG_UNINDENT
2169	CODECDBG_UNINDENT
2170	}
2171
2172	static void codecDbgPrintNodeAmp(PCODECDEBUG pInfo, uint32_t *paReg, uint8_t uIdx, uint8_t uDir)
2173	{
2174	# define CODECDBG_AMP(reg, chan) \
2175	codecDbgPrintf(pInfo, "Amp %RU8 %s %s: In=%RTbool, Out=%RTbool, Left=%RTbool, Right=%RTbool, Idx=%RU8, fMute=%RTbool, uGain=%RU8\n", \
2176	uIdx, chan, uDir == AMPLIFIER_IN ? "In" : "Out", \
2177	RT_BOOL(CODEC_SET_AMP_IS_IN_DIRECTION(reg)), RT_BOOL(CODEC_SET_AMP_IS_OUT_DIRECTION(reg)), \
2178	RT_BOOL(CODEC_SET_AMP_IS_LEFT_SIDE(reg)), RT_BOOL(CODEC_SET_AMP_IS_RIGHT_SIDE(reg)), \
2179	CODEC_SET_AMP_INDEX(reg), RT_BOOL(CODEC_SET_AMP_MUTE(reg)), CODEC_SET_AMP_GAIN(reg))
2180
2181	uint32_t regAmp = AMPLIFIER_REGISTER(paReg, uDir, AMPLIFIER_LEFT, uIdx);
2182	CODECDBG_AMP(regAmp, "Left");
2183	regAmp = AMPLIFIER_REGISTER(paReg, uDir, AMPLIFIER_RIGHT, uIdx);
2184	CODECDBG_AMP(regAmp, "Right");
2185
2186	# undef CODECDBG_AMP
2187	}
2188
2189	# if 0 /* unused */
2190	static void codecDbgPrintNodeConnections(PCODECDEBUG pInfo, PCODECNODE pNode)
2191	{
2192	if (pNode->node.au32F00_param[0xE] == 0) /* Directly connected to HDA link. */
2193	{
2194	codecDbgPrintf(pInfo, "[HDA LINK]\n");
2195	return;
2196	}
2197	}
2198	# endif
2199
2200	static void codecDbgPrintNode(PCODECDEBUG pInfo, PCODECNODE pNode, bool fRecursive)
2201	{
2202	codecDbgPrintf(pInfo, "Node 0x%02x (%02RU8): ", pNode->node.uID, pNode->node.uID);
2203
2204	if (pNode->node.uID == STAC9220_NID_ROOT)
2205	{
2206	CODECDBG_PRINT("ROOT\n");
2207	}
2208	else if (pNode->node.uID == STAC9220_NID_AFG)
2209	{
2210	CODECDBG_PRINT("AFG\n");
2211	CODECDBG_INDENT
2212	codecDbgPrintNodeRegF00(pInfo, pNode->node.au32F00_param);
2213	codecDbgPrintNodeRegF05(pInfo, pNode->afg.u32F05_param);
2214	CODECDBG_UNINDENT
2215	}
2216	else if (hdaCodecIsPortNode(pInfo->pThis, pNode->node.uID))
2217	{
2218	CODECDBG_PRINT("PORT\n");
2219	}
2220	else if (hdaCodecIsDacNode(pInfo->pThis, pNode->node.uID))
2221	{
2222	CODECDBG_PRINT("DAC\n");
2223	CODECDBG_INDENT
2224	codecDbgPrintNodeRegF00(pInfo, pNode->node.au32F00_param);
2225	codecDbgPrintNodeRegF05(pInfo, pNode->dac.u32F05_param);
2226	codecDbgPrintNodeRegA (pInfo, pNode->dac.u32A_param);
2227	codecDbgPrintNodeAmp (pInfo, pNode->dac.B_params, 0, AMPLIFIER_OUT);
2228	CODECDBG_UNINDENT
2229	}
2230	else if (hdaCodecIsAdcVolNode(pInfo->pThis, pNode->node.uID))
2231	{
2232	CODECDBG_PRINT("ADC VOLUME\n");
2233	CODECDBG_INDENT
2234	codecDbgPrintNodeRegF00(pInfo, pNode->node.au32F00_param);
2235	codecDbgPrintNodeRegA (pInfo, pNode->adcvol.u32A_params);
2236	codecDbgPrintNodeAmp (pInfo, pNode->adcvol.B_params, 0, AMPLIFIER_IN);
2237	CODECDBG_UNINDENT
2238	}
2239	else if (hdaCodecIsAdcNode(pInfo->pThis, pNode->node.uID))
2240	{
2241	CODECDBG_PRINT("ADC\n");
2242	CODECDBG_INDENT
2243	codecDbgPrintNodeRegF00(pInfo, pNode->node.au32F00_param);
2244	codecDbgPrintNodeRegF05(pInfo, pNode->adc.u32F05_param);
2245	codecDbgPrintNodeRegA (pInfo, pNode->adc.u32A_param);
2246	codecDbgPrintNodeAmp (pInfo, pNode->adc.B_params, 0, AMPLIFIER_IN);
2247	CODECDBG_UNINDENT
2248	}
2249	else if (hdaCodecIsAdcMuxNode(pInfo->pThis, pNode->node.uID))
2250	{
2251	CODECDBG_PRINT("ADC MUX\n");
2252	CODECDBG_INDENT
2253	codecDbgPrintNodeRegF00(pInfo, pNode->node.au32F00_param);
2254	codecDbgPrintNodeRegA (pInfo, pNode->adcmux.u32A_param);
2255	codecDbgPrintNodeAmp (pInfo, pNode->adcmux.B_params, 0, AMPLIFIER_IN);
2256	CODECDBG_UNINDENT
2257	}
2258	else if (hdaCodecIsPcbeepNode(pInfo->pThis, pNode->node.uID))
2259	CODECDBG_PRINT("PC BEEP\n");
2260	else if (hdaCodecIsSpdifOutNode(pInfo->pThis, pNode->node.uID))
2261	CODECDBG_PRINT("SPDIF OUT\n");
2262	else if (hdaCodecIsSpdifInNode(pInfo->pThis, pNode->node.uID))
2263	CODECDBG_PRINT("SPDIF IN\n");
2264	else if (hdaCodecIsDigInPinNode(pInfo->pThis, pNode->node.uID))
2265	CODECDBG_PRINT("DIGITAL IN PIN\n");
2266	else if (hdaCodecIsDigOutPinNode(pInfo->pThis, pNode->node.uID))
2267	CODECDBG_PRINT("DIGITAL OUT PIN\n");
2268	else if (hdaCodecIsCdNode(pInfo->pThis, pNode->node.uID))
2269	CODECDBG_PRINT("CD\n");
2270	else if (hdaCodecIsVolKnobNode(pInfo->pThis, pNode->node.uID))
2271	CODECDBG_PRINT("VOLUME KNOB\n");
2272	else if (hdaCodecIsReservedNode(pInfo->pThis, pNode->node.uID))
2273	CODECDBG_PRINT("RESERVED\n");
2274	else
2275	CODECDBG_PRINT("UNKNOWN TYPE 0x%x\n", pNode->node.uID);
2276
2277	if (fRecursive)
2278	{
2279	# define CODECDBG_PRINT_CONLIST_ENTRY(_aNode, _aEntry) \
2280	if (cCnt >= _aEntry) \
2281	{ \
2282	const uint8_t uID = RT_BYTE##_aEntry(_aNode->node.au32F02_param[0x0]); \
2283	if (pNode->node.uID == uID) \
2284	codecDbgPrintNode(pInfo, _aNode, false /* fRecursive */); \
2285	}
2286
2287	/* Slow recursion, but this is debug stuff anyway. */
2288	for (uint8_t i = 0; i < pInfo->pThis->cTotalNodes; i++)
2289	{
2290	const PCODECNODE pSubNode = &pInfo->pThis->aNodes[i];
2291	if (pSubNode->node.uID == pNode->node.uID)
2292	continue;
2293
2294	const uint8_t cCnt = CODEC_F00_0E_COUNT(pSubNode->node.au32F00_param[0xE]);
2295	if (cCnt == 0) /* No connections present? Skip. */
2296	continue;
2297
2298	CODECDBG_INDENT
2299	CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 1)
2300	CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 2)
2301	CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 3)
2302	CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 4)
2303	CODECDBG_UNINDENT
2304	}
2305
2306	# undef CODECDBG_PRINT_CONLIST_ENTRY
2307	}
2308	}
2309
2310	static DECLCALLBACK(void) codecR3DbgListNodes(PHDACODEC pThis, PHDACODECR3 pThisCC, PCDBGFINFOHLP pHlp, const char *pszArgs)
2311	{
2312	RT_NOREF(pThisCC, pszArgs);
2313
2314	pHlp->pfnPrintf(pHlp, "HDA LINK / INPUTS\n");
2315
2316	CODECDEBUG dbgInfo;
2317	dbgInfo.pHlp = pHlp;
2318	dbgInfo.pThis = pThis;
2319	dbgInfo.uLevel = 0;
2320
2321	PCODECDEBUG pInfo = &dbgInfo;
2322
2323	CODECDBG_INDENT
2324	for (uint8_t i = 0; i < pThis->cTotalNodes; i++)
2325	{
2326	PCODECNODE pNode = &pThis->aNodes[i];
2327
2328	/* Start with all nodes which have connection entries set. */
2329	if (CODEC_F00_0E_COUNT(pNode->node.au32F00_param[0xE]))
2330	codecDbgPrintNode(&dbgInfo, pNode, true /* fRecursive */);
2331	}
2332	CODECDBG_UNINDENT
2333	}
2334
2335	static DECLCALLBACK(void) codecR3DbgSelector(PHDACODEC pThis, PHDACODECR3 pThisCC, PCDBGFINFOHLP pHlp, const char *pszArgs)
2336	{
2337	RT_NOREF(pThis, pThisCC, pHlp, pszArgs);
2338	}
2339
2340	#endif /* IN_RING3 */
2341
2342	/**
2343	* Implements
2344	*/
2345	static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
2346	{
2347	/*
2348	* Clear the return value and assert some sanity.
2349	*/
2350	AssertPtr(puResp);
2351	*puResp = 0;
2352	AssertPtr(pThis);
2353	AssertPtr(pThisCC);
2354	AssertMsgReturn(CODEC_CAD(uCmd) == pThis->id,
2355	("Unknown codec address 0x%x\n", CODEC_CAD(uCmd)),
2356	VERR_INVALID_PARAMETER);
2357	AssertMsgReturn( CODEC_VERBDATA(uCmd) != 0
2358	&& CODEC_NID(uCmd) < pThis->cTotalNodes,
2359	("[NID0x%02x] Unknown / invalid node or data (0x%x)\n", CODEC_NID(uCmd), CODEC_VERBDATA(uCmd)),
2360	VERR_INVALID_PARAMETER);
2361	STAM_COUNTER_INC(&pThis->CTX_SUFF(StatLookups));
2362
2363	/*
2364	* Lookup the verb.
2365	* Note! if we want other verb tables, add a table selector before the loop.
2366	*/
2367	for (size_t i = 0; i < RT_ELEMENTS(g_aCodecVerbs); i++)
2368	{
2369	if ((CODEC_VERBDATA(uCmd) & g_aCodecVerbs[i].fMask) == g_aCodecVerbs[i].uVerb)
2370	{
2371	#ifndef IN_RING3
2372	if (!g_aCodecVerbs[i].pfn)
2373	{
2374	Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> VERR_INVALID_CONTEXT\n", /* -> ring-3 */
2375	CODEC_NID(uCmd), g_aCodecVerbs[i].uVerb, g_aCodecVerbs[i].pszName, CODEC_VERB_PAYLOAD8(uCmd)));
2376	return VERR_INVALID_CONTEXT;
2377	}
2378	#endif
2379	AssertPtrReturn(g_aCodecVerbs[i].pfn, VERR_INTERNAL_ERROR_5); /* Paranoia^2. */
2380
2381	int rc = g_aCodecVerbs[i].pfn(pThis, pThisCC, uCmd, puResp);
2382	AssertRC(rc);
2383	Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> 0x%x\n",
2384	CODEC_NID(uCmd), g_aCodecVerbs[i].uVerb, g_aCodecVerbs[i].pszName, CODEC_VERB_PAYLOAD8(uCmd), *puResp));
2385	return rc;
2386	}
2387	}
2388
2389	LogFunc(("[NID0x%02x] Callback for %x not found\n", CODEC_NID(uCmd), CODEC_VERBDATA(uCmd)));
2390	return VERR_NOT_FOUND;
2391	}
2392
2393
2394	/*
2395	* APIs exposed to DevHDA.
2396	*/
2397
2398	#ifdef IN_RING3
2399
2400	int hdaR3CodecAddStream(PHDACODECR3 pThisCC, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
2401	{
2402	AssertPtrReturn(pThisCC, VERR_INVALID_POINTER);
2403	AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2404
2405	int rc = VINF_SUCCESS;
2406
2407	switch (enmMixerCtl)
2408	{
2409	case PDMAUDIOMIXERCTL_VOLUME_MASTER:
2410	case PDMAUDIOMIXERCTL_FRONT:
2411	#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
2412	case PDMAUDIOMIXERCTL_CENTER_LFE:
2413	case PDMAUDIOMIXERCTL_REAR:
2414	#endif
2415	break;
2416
2417	case PDMAUDIOMIXERCTL_LINE_IN:
2418	#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
2419	case PDMAUDIOMIXERCTL_MIC_IN:
2420	#endif
2421	break;
2422
2423	default:
2424	AssertMsgFailed(("Mixer control %#x not implemented\n", enmMixerCtl));
2425	rc = VERR_NOT_IMPLEMENTED;
2426	break;
2427	}
2428
2429	if (RT_SUCCESS(rc))
2430	rc = pThisCC->pfnCbMixerAddStream(pThisCC->pDevIns, enmMixerCtl, pCfg);
2431
2432	LogFlowFuncLeaveRC(rc);
2433	return rc;
2434	}
2435
2436	int hdaR3CodecRemoveStream(PHDACODECR3 pThisCC, PDMAUDIOMIXERCTL enmMixerCtl)
2437	{
2438	AssertPtrReturn(pThisCC, VERR_INVALID_POINTER);
2439
2440	int rc = pThisCC->pfnCbMixerRemoveStream(pThisCC->pDevIns, enmMixerCtl);
2441
2442	LogFlowFuncLeaveRC(rc);
2443	return rc;
2444	}
2445
2446	int hdaCodecSaveState(PPDMDEVINS pDevIns, PHDACODEC pThis, PSSMHANDLE pSSM)
2447	{
2448	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2449	AssertLogRelMsgReturn(pThis->cTotalNodes == STAC9221_NUM_NODES, ("cTotalNodes=%#x, should be 0x1c", pThis->cTotalNodes),
2450	VERR_INTERNAL_ERROR);
2451	pHlp->pfnSSMPutU32(pSSM, pThis->cTotalNodes);
2452	for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
2453	pHlp->pfnSSMPutStructEx(pSSM, &pThis->aNodes[idxNode].SavedState, sizeof(pThis->aNodes[idxNode].SavedState),
2454	0 /fFlags/, g_aCodecNodeFields, NULL /pvUser/);
2455	return VINF_SUCCESS;
2456	}
2457
2458	int hdaR3CodecLoadState(PPDMDEVINS pDevIns, PHDACODEC pThis, PHDACODECR3 pThisCC, PSSMHANDLE pSSM, uint32_t uVersion)
2459	{
2460	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2461	PCSSMFIELD pFields = NULL;
2462	uint32_t fFlags = 0;
2463	if (uVersion >= HDA_SAVED_STATE_VERSION_4)
2464	{
2465	/* Since version 4 a flexible node count is supported. */
2466	uint32_t cNodes;
2467	int rc2 = pHlp->pfnSSMGetU32(pSSM, &cNodes);
2468	AssertRCReturn(rc2, rc2);
2469	AssertReturn(cNodes == 0x1c, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2470	AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
2471
2472	pFields = g_aCodecNodeFields;
2473	fFlags = 0;
2474	}
2475	else if (uVersion >= HDA_SAVED_STATE_VERSION_2)
2476	{
2477	AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
2478	pFields = g_aCodecNodeFields;
2479	fFlags = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
2480	}
2481	else if (uVersion >= HDA_SAVED_STATE_VERSION_1)
2482	{
2483	AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
2484	pFields = g_aCodecNodeFieldsV1;
2485	fFlags = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
2486	}
2487	else
2488	AssertFailedReturn(VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
2489
2490	for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
2491	{
2492	uint8_t idOld = pThis->aNodes[idxNode].SavedState.Core.uID;
2493	int rc = pHlp->pfnSSMGetStructEx(pSSM, &pThis->aNodes[idxNode].SavedState, sizeof(pThis->aNodes[idxNode].SavedState),
2494	fFlags, pFields, NULL);
2495	AssertRCReturn(rc, rc);
2496	AssertLogRelMsgReturn(idOld == pThis->aNodes[idxNode].SavedState.Core.uID,
2497	("loaded %#x, expected %#x\n", pThis->aNodes[idxNode].SavedState.Core.uID, idOld),
2498	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2499	}
2500
2501	/*
2502	* Update stuff after changing the state.
2503	*/
2504	PCODECNODE pNode;
2505	if (hdaCodecIsDacNode(pThis, pThis->u8DacLineOut))
2506	{
2507	pNode = &pThis->aNodes[pThis->u8DacLineOut];
2508	hdaR3CodecToAudVolume(pThisCC, pNode, &pNode->dac.B_params, PDMAUDIOMIXERCTL_FRONT);
2509	}
2510	else if (hdaCodecIsSpdifOutNode(pThis, pThis->u8DacLineOut))
2511	{
2512	pNode = &pThis->aNodes[pThis->u8DacLineOut];
2513	hdaR3CodecToAudVolume(pThisCC, pNode, &pNode->spdifout.B_params, PDMAUDIOMIXERCTL_FRONT);
2514	}
2515
2516	pNode = &pThis->aNodes[pThis->u8AdcVolsLineIn];
2517	hdaR3CodecToAudVolume(pThisCC, pNode, &pNode->adcvol.B_params, PDMAUDIOMIXERCTL_LINE_IN);
2518
2519	LogFlowFuncLeaveRC(VINF_SUCCESS);
2520	return VINF_SUCCESS;
2521	}
2522
2523	/**
2524	* Powers off the codec (ring-3).
2525	*
2526	* @param pThisCC Context-specific codec data (ring-3) to power off.
2527	*/
2528	void hdaR3CodecPowerOff(PHDACODECR3 pThisCC)
2529	{
2530	if (!pThisCC)
2531	return;
2532
2533	LogFlowFuncEnter();
2534
2535	LogRel2(("HDA: Powering off codec ...\n"));
2536
2537	int rc2 = hdaR3CodecRemoveStream(pThisCC, PDMAUDIOMIXERCTL_FRONT);
2538	AssertRC(rc2);
2539	#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
2540	rc2 = hdaR3CodecRemoveStream(pThisCC, PDMAUDIOMIXERCTL_CENTER_LFE);
2541	AssertRC(rc2);
2542	rc2 = hdaR3CodecRemoveStream(pThisCC, PDMAUDIOMIXERCTL_REAR);
2543	AssertRC(rc2);
2544	#endif
2545
2546	#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
2547	rc2 = hdaR3CodecRemoveStream(pThisCC, PDMAUDIOMIXERCTL_MIC_IN);
2548	AssertRC(rc2);
2549	#endif
2550	rc2 = hdaR3CodecRemoveStream(pThisCC, PDMAUDIOMIXERCTL_LINE_IN);
2551	AssertRC(rc2);
2552	}
2553
2554	/**
2555	* Constructs a codec (ring-3).
2556	*
2557	* @returns VBox status code.
2558	* @param pDevIns Associated device instance.
2559	* @param pThis Shared codec data beteen r0/r3.
2560	* @param pThisCC Context-specific codec data (ring-3).
2561	* @param uLUN Device LUN to assign.
2562	* @param pCfg CFGM node to use for configuration.
2563	*/
2564	int hdaR3CodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, PHDACODECR3 pThisCC, uint16_t uLUN, PCFGMNODE pCfg)
2565	{
2566	AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
2567	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2568	AssertPtrReturn(pThisCC, VERR_INVALID_POINTER);
2569	AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2570
2571	pThis->id = uLUN;
2572	pThis->enmType = CODEC_TYPE_STAC9220; /** @todo Make this dynamic. */
2573
2574	int rc;
2575
2576	switch (pThis->enmType)
2577	{
2578	case CODEC_TYPE_STAC9220:
2579	{
2580	rc = stac9220Construct(pThis);
2581	AssertRCReturn(rc, rc);
2582	break;
2583	}
2584
2585	default:
2586	AssertFailedReturn(VERR_NOT_IMPLEMENTED);
2587	break;
2588	}
2589
2590	pThisCC->pfnDbgSelector = codecR3DbgSelector;
2591	pThisCC->pfnDbgListNodes = codecR3DbgListNodes;
2592	pThisCC->pfnLookup = codecLookup;
2593
2594	/*
2595	* Set initial volume.
2596	*/
2597	PCODECNODE pNode = &pThis->aNodes[pThis->u8DacLineOut];
2598	rc = hdaR3CodecToAudVolume(pThisCC, pNode, &pNode->dac.B_params, PDMAUDIOMIXERCTL_FRONT);
2599	AssertRCReturn(rc, rc);
2600
2601	pNode = &pThis->aNodes[pThis->u8AdcVolsLineIn];
2602	rc = hdaR3CodecToAudVolume(pThisCC, pNode, &pNode->adcvol.B_params, PDMAUDIOMIXERCTL_LINE_IN);
2603	AssertRCReturn(rc, rc);
2604
2605	# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
2606	# error "Implement mic-in support!"
2607	# endif
2608
2609	/*
2610	* Statistics
2611	*/
2612	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatLookupsR3, STAMTYPE_COUNTER, "Codec/LookupsR0", STAMUNIT_OCCURENCES, "Number of R0 codecLookup calls");
2613	# if 0 /* Codec is not yet kosher enough for ring-0. @bugref{9890c64} */
2614	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatLookupsR0, STAMTYPE_COUNTER, "Codec/LookupsR3", STAMUNIT_OCCURENCES, "Number of R3 codecLookup calls");
2615	# endif
2616
2617	return rc;
2618	}
2619
2620	#else /* IN_RING0 */
2621
2622	/**
2623	* Constructs a codec (ring-0).
2624	*
2625	* @returns VBox status code.
2626	* @param pDevIns Associated device instance.
2627	* @param pThis Shared codec data beteen r0/r3.
2628	* @param pThisCC Context-specific codec data (ring-0).
2629	*/
2630	int hdaR0CodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, PHDACODECR0 pThisCC)
2631	{
2632	AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
2633	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2634	AssertPtrReturn(pThisCC, VERR_INVALID_POINTER);
2635
2636	pThisCC->pfnLookup = codecLookup;
2637
2638	/* Note: Everything else is done in the R3 part. */
2639
2640	return VINF_SUCCESS;
2641	}
2642
2643	#endif /* IN_RING0 */
2644
2645	/**
2646	* Destructs a codec.
2647	*
2648	* @param pThis Codec to destruct.
2649	*/
2650	void hdaCodecDestruct(PHDACODEC pThis)
2651	{
2652	if (!pThis)
2653	return;
2654
2655	/* Nothing to do here atm. */
2656
2657	LogFlowFuncEnter();
2658	}
2659
2660	/**
2661	* Resets a codec.
2662	*
2663	* @param pThis Codec to reset.
2664	*/
2665	void hdaCodecReset(PHDACODEC pThis)
2666	{
2667	switch (pThis->enmType)
2668	{
2669	case CODEC_TYPE_STAC9220:
2670	stac9220Reset(pThis);
2671	break;
2672
2673	default:
2674	AssertFailed();
2675	break;
2676	}
2677	}
2678

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Audio/DevHdaCodec.cpp@ 88503

以其他格式下載: