VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/DevIchHda.cpp@ 61541

Last change on this file since 61541 was 61529, checked in by vboxsync, 9 years ago

Audio: Don't release assert if the backend configuration could not be retrieved due to a host audio problem.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 223.0 KB
Line 
1/* $Id: DevIchHda.cpp 61529 2016-06-07 10:25:16Z vboxsync $ */
2/** @file
3 * DevIchHda - VBox ICH Intel HD Audio Controller.
4 *
5 * Implemented against the specifications found in "High Definition Audio
6 * Specification", Revision 1.0a June 17, 2010, and "Intel I/O Controller
7 * HUB 6 (ICH6) Family, Datasheet", document number 301473-002.
8 */
9
10/*
11 * Copyright (C) 2006-2016 Oracle Corporation
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 */
21
22
23/*********************************************************************************************************************************
24* Header Files *
25*********************************************************************************************************************************/
26#define LOG_GROUP LOG_GROUP_DEV_HDA
27#include <VBox/log.h>
28#include <VBox/vmm/pdmdev.h>
29#include <VBox/vmm/pdmaudioifs.h>
30#include <VBox/version.h>
31
32#include <iprt/assert.h>
33#include <iprt/asm.h>
34#include <iprt/asm-math.h>
35#include <iprt/file.h>
36#include <iprt/list.h>
37#ifdef IN_RING3
38# include <iprt/mem.h>
39# include <iprt/semaphore.h>
40# include <iprt/string.h>
41# include <iprt/uuid.h>
42#endif
43
44#include "VBoxDD.h"
45
46#include "AudioMixBuffer.h"
47#include "AudioMixer.h"
48#include "DevIchHdaCodec.h"
49#include "DevIchHdaCommon.h"
50#include "DrvAudio.h"
51
52
53/*********************************************************************************************************************************
54* Defined Constants And Macros *
55*********************************************************************************************************************************/
56//#define HDA_AS_PCI_EXPRESS
57#define VBOX_WITH_INTEL_HDA
58
59#ifdef DEBUG_andy
60/*
61 * HDA_DEBUG_DUMP_PCM_DATA enables dumping the raw PCM data
62 * to a file on the host. Be sure to adjust HDA_DEBUG_DUMP_PCM_DATA_PATH
63 * to your needs before using this!
64 */
65# define HDA_DEBUG_DUMP_PCM_DATA
66# ifdef RT_OS_WINDOWS
67# define HDA_DEBUG_DUMP_PCM_DATA_PATH "c:\\temp\\"
68# else
69# define HDA_DEBUG_DUMP_PCM_DATA_PATH "/tmp/"
70# endif
71
72/* Enables experimental support for separate mic-in handling.
73 Do not enable this yet for regular builds, as this needs more testing first! */
74//# define VBOX_WITH_HDA_MIC_IN
75#endif
76
77#if defined(VBOX_WITH_HP_HDA)
78/* HP Pavilion dv4t-1300 */
79# define HDA_PCI_VENDOR_ID 0x103c
80# define HDA_PCI_DEVICE_ID 0x30f7
81#elif defined(VBOX_WITH_INTEL_HDA)
82/* Intel HDA controller */
83# define HDA_PCI_VENDOR_ID 0x8086
84# define HDA_PCI_DEVICE_ID 0x2668
85#elif defined(VBOX_WITH_NVIDIA_HDA)
86/* nVidia HDA controller */
87# define HDA_PCI_VENDOR_ID 0x10de
88# define HDA_PCI_DEVICE_ID 0x0ac0
89#else
90# error "Please specify your HDA device vendor/device IDs"
91#endif
92
93/** @todo r=bird: Looking at what the linux driver (accidentally?) does when
94 * updating CORBWP, I belive that the ICH6 datahsheet is wrong and that CORBRP
95 * is read only except for bit 15 like the HDA spec states.
96 *
97 * Btw. the CORBRPRST implementation is incomplete according to both docs (sw
98 * writes 1, hw sets it to 1 (after completion), sw reads 1, sw writes 0). */
99#define BIRD_THINKS_CORBRP_IS_MOSTLY_RO
100
101/* Make sure that interleaving streams support is enabled if the 5.1 code is being used. */
102#if defined (VBOX_WITH_HDA_51_SURROUND) && !defined(VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT)
103# define VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
104#endif
105
106/**
107 * At the moment we support 4 input + 4 output streams max, which is 8 in total.
108 * Bidirectional streams are currently *not* supported.
109 *
110 * Note: When changing any of those values, be prepared for some saved state
111 * fixups / trouble!
112 */
113#define HDA_MAX_SDI 4
114#define HDA_MAX_SDO 4
115#define HDA_MAX_STREAMS (HDA_MAX_SDI + HDA_MAX_SDO)
116AssertCompile(HDA_MAX_SDI <= HDA_MAX_SDO);
117
118/** Number of general registers. */
119#define HDA_NUM_GENERAL_REGS 34
120/** Number of total registers in the HDA's register map. */
121#define HDA_NUM_REGS (HDA_NUM_GENERAL_REGS + (HDA_MAX_STREAMS * 10 /* Each stream descriptor has 10 registers */))
122/** Total number of stream tags (channels). Index 0 is reserved / invalid. */
123#define HDA_MAX_TAGS 16
124
125/**
126 * NB: Register values stored in memory (au32Regs[]) are indexed through
127 * the HDA_RMX_xxx macros (also HDA_MEM_IND_NAME()). On the other hand, the
128 * register descriptors in g_aHdaRegMap[] are indexed through the
129 * HDA_REG_xxx macros (also HDA_REG_IND_NAME()).
130 *
131 * The au32Regs[] layout is kept unchanged for saved state
132 * compatibility.
133 */
134
135/* Registers */
136#define HDA_REG_IND_NAME(x) HDA_REG_##x
137#define HDA_MEM_IND_NAME(x) HDA_RMX_##x
138#define HDA_REG_FIELD_MASK(reg, x) HDA_##reg##_##x##_MASK
139#define HDA_REG_FIELD_FLAG_MASK(reg, x) RT_BIT(HDA_##reg##_##x##_SHIFT)
140#define HDA_REG_FIELD_SHIFT(reg, x) HDA_##reg##_##x##_SHIFT
141#define HDA_REG_IND(pThis, x) ((pThis)->au32Regs[g_aHdaRegMap[x].mem_idx])
142#define HDA_REG(pThis, x) (HDA_REG_IND((pThis), HDA_REG_IND_NAME(x)))
143#define HDA_REG_FLAG_VALUE(pThis, reg, val) (HDA_REG((pThis),reg) & (((HDA_REG_FIELD_FLAG_MASK(reg, val)))))
144
145
146#define HDA_REG_GCAP 0 /* range 0x00-0x01*/
147#define HDA_RMX_GCAP 0
148/* GCAP HDASpec 3.3.2 This macro encodes the following information about HDA in a compact manner:
149 * oss (15:12) - number of output streams supported
150 * iss (11:8) - number of input streams supported
151 * bss (7:3) - number of bidirectional streams supported
152 * bds (2:1) - number of serial data out (SDO) signals supported
153 * b64sup (0) - 64 bit addressing supported.
154 */
155#define HDA_MAKE_GCAP(oss, iss, bss, bds, b64sup) \
156 ( (((oss) & 0xF) << 12) \
157 | (((iss) & 0xF) << 8) \
158 | (((bss) & 0x1F) << 3) \
159 | (((bds) & 0x3) << 1) \
160 | ((b64sup) & 1))
161
162#define HDA_REG_VMIN 1 /* 0x02 */
163#define HDA_RMX_VMIN 1
164
165#define HDA_REG_VMAJ 2 /* 0x03 */
166#define HDA_RMX_VMAJ 2
167
168#define HDA_REG_OUTPAY 3 /* 0x04-0x05 */
169#define HDA_RMX_OUTPAY 3
170
171#define HDA_REG_INPAY 4 /* 0x06-0x07 */
172#define HDA_RMX_INPAY 4
173
174#define HDA_REG_GCTL 5 /* 0x08-0x0B */
175#define HDA_RMX_GCTL 5
176#define HDA_GCTL_RST_SHIFT 0
177#define HDA_GCTL_FSH_SHIFT 1
178#define HDA_GCTL_UR_SHIFT 8
179
180#define HDA_REG_WAKEEN 6 /* 0x0C */
181#define HDA_RMX_WAKEEN 6
182
183#define HDA_REG_STATESTS 7 /* 0x0E */
184#define HDA_RMX_STATESTS 7
185#define HDA_STATES_SCSF 0x7
186
187#define HDA_REG_GSTS 8 /* 0x10-0x11*/
188#define HDA_RMX_GSTS 8
189#define HDA_GSTS_FSH_SHIFT 1
190
191#define HDA_REG_OUTSTRMPAY 9 /* 0x18 */
192#define HDA_RMX_OUTSTRMPAY 112
193
194#define HDA_REG_INSTRMPAY 10 /* 0x1a */
195#define HDA_RMX_INSTRMPAY 113
196
197#define HDA_REG_INTCTL 11 /* 0x20 */
198#define HDA_RMX_INTCTL 9
199#define HDA_INTCTL_GIE_SHIFT 31
200#define HDA_INTCTL_CIE_SHIFT 30
201#define HDA_INTCTL_S0_SHIFT 0
202#define HDA_INTCTL_S1_SHIFT 1
203#define HDA_INTCTL_S2_SHIFT 2
204#define HDA_INTCTL_S3_SHIFT 3
205#define HDA_INTCTL_S4_SHIFT 4
206#define HDA_INTCTL_S5_SHIFT 5
207#define HDA_INTCTL_S6_SHIFT 6
208#define HDA_INTCTL_S7_SHIFT 7
209#define INTCTL_SX(pThis, X) (HDA_REG_FLAG_VALUE((pThis), INTCTL, S##X))
210
211#define HDA_REG_INTSTS 12 /* 0x24 */
212#define HDA_RMX_INTSTS 10
213#define HDA_INTSTS_GIS_SHIFT 31
214#define HDA_INTSTS_CIS_SHIFT 30
215#define HDA_INTSTS_S0_SHIFT 0
216#define HDA_INTSTS_S1_SHIFT 1
217#define HDA_INTSTS_S2_SHIFT 2
218#define HDA_INTSTS_S3_SHIFT 3
219#define HDA_INTSTS_S4_SHIFT 4
220#define HDA_INTSTS_S5_SHIFT 5
221#define HDA_INTSTS_S6_SHIFT 6
222#define HDA_INTSTS_S7_SHIFT 7
223#define HDA_INTSTS_S_MASK(num) RT_BIT(HDA_REG_FIELD_SHIFT(S##num))
224
225#define HDA_REG_WALCLK 13 /* 0x30 */
226#define HDA_RMX_WALCLK /* Not defined! */
227
228/* Note: The HDA specification defines a SSYNC register at offset 0x38. The
229 * ICH6/ICH9 datahseet defines SSYNC at offset 0x34. The Linux HDA driver matches
230 * the datasheet.
231 */
232#define HDA_REG_SSYNC 14 /* 0x38 */
233#define HDA_RMX_SSYNC 12
234
235#define HDA_REG_CORBLBASE 15 /* 0x40 */
236#define HDA_RMX_CORBLBASE 13
237
238#define HDA_REG_CORBUBASE 16 /* 0x44 */
239#define HDA_RMX_CORBUBASE 14
240
241#define HDA_REG_CORBWP 17 /* 0x48 */
242#define HDA_RMX_CORBWP 15
243
244#define HDA_REG_CORBRP 18 /* 0x4A */
245#define HDA_RMX_CORBRP 16
246#define HDA_CORBRP_RST_SHIFT 15
247#define HDA_CORBRP_WP_SHIFT 0
248#define HDA_CORBRP_WP_MASK 0xFF
249
250#define HDA_REG_CORBCTL 19 /* 0x4C */
251#define HDA_RMX_CORBCTL 17
252#define HDA_CORBCTL_DMA_SHIFT 1
253#define HDA_CORBCTL_CMEIE_SHIFT 0
254
255#define HDA_REG_CORBSTS 20 /* 0x4D */
256#define HDA_RMX_CORBSTS 18
257#define HDA_CORBSTS_CMEI_SHIFT 0
258
259#define HDA_REG_CORBSIZE 21 /* 0x4E */
260#define HDA_RMX_CORBSIZE 19
261#define HDA_CORBSIZE_SZ_CAP 0xF0
262#define HDA_CORBSIZE_SZ 0x3
263/* till ich 10 sizes of CORB and RIRB are hardcoded to 256 in real hw */
264
265#define HDA_REG_RIRBLBASE 22 /* 0x50 */
266#define HDA_RMX_RIRBLBASE 20
267
268#define HDA_REG_RIRBUBASE 23 /* 0x54 */
269#define HDA_RMX_RIRBUBASE 21
270
271#define HDA_REG_RIRBWP 24 /* 0x58 */
272#define HDA_RMX_RIRBWP 22
273#define HDA_RIRBWP_RST_SHIFT 15
274#define HDA_RIRBWP_WP_MASK 0xFF
275
276#define HDA_REG_RINTCNT 25 /* 0x5A */
277#define HDA_RMX_RINTCNT 23
278#define RINTCNT_N(pThis) (HDA_REG(pThis, RINTCNT) & 0xff)
279
280#define HDA_REG_RIRBCTL 26 /* 0x5C */
281#define HDA_RMX_RIRBCTL 24
282#define HDA_RIRBCTL_RIC_SHIFT 0
283#define HDA_RIRBCTL_DMA_SHIFT 1
284#define HDA_ROI_DMA_SHIFT 2
285
286#define HDA_REG_RIRBSTS 27 /* 0x5D */
287#define HDA_RMX_RIRBSTS 25
288#define HDA_RIRBSTS_RINTFL_SHIFT 0
289#define HDA_RIRBSTS_RIRBOIS_SHIFT 2
290
291#define HDA_REG_RIRBSIZE 28 /* 0x5E */
292#define HDA_RMX_RIRBSIZE 26
293#define HDA_RIRBSIZE_SZ_CAP 0xF0
294#define HDA_RIRBSIZE_SZ 0x3
295
296#define RIRBSIZE_SZ(pThis) (HDA_REG(pThis, HDA_REG_RIRBSIZE) & HDA_RIRBSIZE_SZ)
297#define RIRBSIZE_SZ_CAP(pThis) (HDA_REG(pThis, HDA_REG_RIRBSIZE) & HDA_RIRBSIZE_SZ_CAP)
298
299
300#define HDA_REG_IC 29 /* 0x60 */
301#define HDA_RMX_IC 27
302
303#define HDA_REG_IR 30 /* 0x64 */
304#define HDA_RMX_IR 28
305
306#define HDA_REG_IRS 31 /* 0x68 */
307#define HDA_RMX_IRS 29
308#define HDA_IRS_ICB_SHIFT 0
309#define HDA_IRS_IRV_SHIFT 1
310
311#define HDA_REG_DPLBASE 32 /* 0x70 */
312#define HDA_RMX_DPLBASE 30
313#define DPLBASE(pThis) (HDA_REG((pThis), DPLBASE))
314
315#define HDA_REG_DPUBASE 33 /* 0x74 */
316#define HDA_RMX_DPUBASE 31
317#define DPUBASE(pThis) (HDA_REG((pThis), DPUBASE))
318
319#define DPBASE_ADDR_MASK (~(uint64_t)0x7f)
320
321#define HDA_STREAM_REG_DEF(name, num) (HDA_REG_SD##num##name)
322#define HDA_STREAM_RMX_DEF(name, num) (HDA_RMX_SD##num##name)
323/* Note: sdnum here _MUST_ be stream reg number [0,7]. */
324#define HDA_STREAM_REG(pThis, name, sdnum) (HDA_REG_IND((pThis), HDA_REG_SD0##name + (sdnum) * 10))
325
326#define HDA_SD_NUM_FROM_REG(pThis, func, reg) ((reg - HDA_STREAM_REG_DEF(func, 0)) / 10)
327
328/** @todo Condense marcos! */
329
330#define HDA_REG_SD0CTL HDA_NUM_GENERAL_REGS /* 0x80 */
331#define HDA_REG_SD1CTL (HDA_STREAM_REG_DEF(CTL, 0) + 10) /* 0xA0 */
332#define HDA_REG_SD2CTL (HDA_STREAM_REG_DEF(CTL, 0) + 20) /* 0xC0 */
333#define HDA_REG_SD3CTL (HDA_STREAM_REG_DEF(CTL, 0) + 30) /* 0xE0 */
334#define HDA_REG_SD4CTL (HDA_STREAM_REG_DEF(CTL, 0) + 40) /* 0x100 */
335#define HDA_REG_SD5CTL (HDA_STREAM_REG_DEF(CTL, 0) + 50) /* 0x120 */
336#define HDA_REG_SD6CTL (HDA_STREAM_REG_DEF(CTL, 0) + 60) /* 0x140 */
337#define HDA_REG_SD7CTL (HDA_STREAM_REG_DEF(CTL, 0) + 70) /* 0x160 */
338#define HDA_RMX_SD0CTL 32
339#define HDA_RMX_SD1CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 10)
340#define HDA_RMX_SD2CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 20)
341#define HDA_RMX_SD3CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 30)
342#define HDA_RMX_SD4CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 40)
343#define HDA_RMX_SD5CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 50)
344#define HDA_RMX_SD6CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 60)
345#define HDA_RMX_SD7CTL (HDA_STREAM_RMX_DEF(CTL, 0) + 70)
346
347#define SD(func, num) SD##num##func
348
349#define HDA_SDCTL(pThis, num) HDA_REG((pThis), SD(CTL, num))
350#define HDA_SDCTL_NUM(pThis, num) ((HDA_SDCTL((pThis), num) & HDA_REG_FIELD_MASK(SDCTL,NUM)) >> HDA_REG_FIELD_SHIFT(SDCTL, NUM))
351#define HDA_SDCTL_NUM_MASK 0xF
352#define HDA_SDCTL_NUM_SHIFT 20
353#define HDA_SDCTL_DIR_SHIFT 19
354#define HDA_SDCTL_TP_SHIFT 18
355#define HDA_SDCTL_STRIPE_MASK 0x3
356#define HDA_SDCTL_STRIPE_SHIFT 16
357#define HDA_SDCTL_DEIE_SHIFT 4
358#define HDA_SDCTL_FEIE_SHIFT 3
359#define HDA_SDCTL_ICE_SHIFT 2
360#define HDA_SDCTL_RUN_SHIFT 1
361#define HDA_SDCTL_SRST_SHIFT 0
362
363#define HDA_REG_SD0STS 35 /* 0x83 */
364#define HDA_REG_SD1STS (HDA_STREAM_REG_DEF(STS, 0) + 10) /* 0xA3 */
365#define HDA_REG_SD2STS (HDA_STREAM_REG_DEF(STS, 0) + 20) /* 0xC3 */
366#define HDA_REG_SD3STS (HDA_STREAM_REG_DEF(STS, 0) + 30) /* 0xE3 */
367#define HDA_REG_SD4STS (HDA_STREAM_REG_DEF(STS, 0) + 40) /* 0x103 */
368#define HDA_REG_SD5STS (HDA_STREAM_REG_DEF(STS, 0) + 50) /* 0x123 */
369#define HDA_REG_SD6STS (HDA_STREAM_REG_DEF(STS, 0) + 60) /* 0x143 */
370#define HDA_REG_SD7STS (HDA_STREAM_REG_DEF(STS, 0) + 70) /* 0x163 */
371#define HDA_RMX_SD0STS 33
372#define HDA_RMX_SD1STS (HDA_STREAM_RMX_DEF(STS, 0) + 10)
373#define HDA_RMX_SD2STS (HDA_STREAM_RMX_DEF(STS, 0) + 20)
374#define HDA_RMX_SD3STS (HDA_STREAM_RMX_DEF(STS, 0) + 30)
375#define HDA_RMX_SD4STS (HDA_STREAM_RMX_DEF(STS, 0) + 40)
376#define HDA_RMX_SD5STS (HDA_STREAM_RMX_DEF(STS, 0) + 50)
377#define HDA_RMX_SD6STS (HDA_STREAM_RMX_DEF(STS, 0) + 60)
378#define HDA_RMX_SD7STS (HDA_STREAM_RMX_DEF(STS, 0) + 70)
379
380#define SDSTS(pThis, num) HDA_REG((pThis), SD(STS, num))
381#define HDA_SDSTS_FIFORDY_SHIFT 5
382#define HDA_SDSTS_DE_SHIFT 4
383#define HDA_SDSTS_FE_SHIFT 3
384#define HDA_SDSTS_BCIS_SHIFT 2
385
386#define HDA_REG_SD0LPIB 36 /* 0x84 */
387#define HDA_REG_SD1LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 10) /* 0xA4 */
388#define HDA_REG_SD2LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 20) /* 0xC4 */
389#define HDA_REG_SD3LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 30) /* 0xE4 */
390#define HDA_REG_SD4LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 40) /* 0x104 */
391#define HDA_REG_SD5LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 50) /* 0x124 */
392#define HDA_REG_SD6LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 60) /* 0x144 */
393#define HDA_REG_SD7LPIB (HDA_STREAM_REG_DEF(LPIB, 0) + 70) /* 0x164 */
394#define HDA_RMX_SD0LPIB 34
395#define HDA_RMX_SD1LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 10)
396#define HDA_RMX_SD2LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 20)
397#define HDA_RMX_SD3LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 30)
398#define HDA_RMX_SD4LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 40)
399#define HDA_RMX_SD5LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 50)
400#define HDA_RMX_SD6LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 60)
401#define HDA_RMX_SD7LPIB (HDA_STREAM_RMX_DEF(LPIB, 0) + 70)
402
403#define HDA_REG_SD0CBL 37 /* 0x88 */
404#define HDA_REG_SD1CBL (HDA_STREAM_REG_DEF(CBL, 0) + 10) /* 0xA8 */
405#define HDA_REG_SD2CBL (HDA_STREAM_REG_DEF(CBL, 0) + 20) /* 0xC8 */
406#define HDA_REG_SD3CBL (HDA_STREAM_REG_DEF(CBL, 0) + 30) /* 0xE8 */
407#define HDA_REG_SD4CBL (HDA_STREAM_REG_DEF(CBL, 0) + 40) /* 0x108 */
408#define HDA_REG_SD5CBL (HDA_STREAM_REG_DEF(CBL, 0) + 50) /* 0x128 */
409#define HDA_REG_SD6CBL (HDA_STREAM_REG_DEF(CBL, 0) + 60) /* 0x148 */
410#define HDA_REG_SD7CBL (HDA_STREAM_REG_DEF(CBL, 0) + 70) /* 0x168 */
411#define HDA_RMX_SD0CBL 35
412#define HDA_RMX_SD1CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 10)
413#define HDA_RMX_SD2CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 20)
414#define HDA_RMX_SD3CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 30)
415#define HDA_RMX_SD4CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 40)
416#define HDA_RMX_SD5CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 50)
417#define HDA_RMX_SD6CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 60)
418#define HDA_RMX_SD7CBL (HDA_STREAM_RMX_DEF(CBL, 0) + 70)
419
420#define HDA_REG_SD0LVI 38 /* 0x8C */
421#define HDA_REG_SD1LVI (HDA_STREAM_REG_DEF(LVI, 0) + 10) /* 0xAC */
422#define HDA_REG_SD2LVI (HDA_STREAM_REG_DEF(LVI, 0) + 20) /* 0xCC */
423#define HDA_REG_SD3LVI (HDA_STREAM_REG_DEF(LVI, 0) + 30) /* 0xEC */
424#define HDA_REG_SD4LVI (HDA_STREAM_REG_DEF(LVI, 0) + 40) /* 0x10C */
425#define HDA_REG_SD5LVI (HDA_STREAM_REG_DEF(LVI, 0) + 50) /* 0x12C */
426#define HDA_REG_SD6LVI (HDA_STREAM_REG_DEF(LVI, 0) + 60) /* 0x14C */
427#define HDA_REG_SD7LVI (HDA_STREAM_REG_DEF(LVI, 0) + 70) /* 0x16C */
428#define HDA_RMX_SD0LVI 36
429#define HDA_RMX_SD1LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 10)
430#define HDA_RMX_SD2LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 20)
431#define HDA_RMX_SD3LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 30)
432#define HDA_RMX_SD4LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 40)
433#define HDA_RMX_SD5LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 50)
434#define HDA_RMX_SD6LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 60)
435#define HDA_RMX_SD7LVI (HDA_STREAM_RMX_DEF(LVI, 0) + 70)
436
437#define HDA_REG_SD0FIFOW 39 /* 0x8E */
438#define HDA_REG_SD1FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 10) /* 0xAE */
439#define HDA_REG_SD2FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 20) /* 0xCE */
440#define HDA_REG_SD3FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 30) /* 0xEE */
441#define HDA_REG_SD4FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 40) /* 0x10E */
442#define HDA_REG_SD5FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 50) /* 0x12E */
443#define HDA_REG_SD6FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 60) /* 0x14E */
444#define HDA_REG_SD7FIFOW (HDA_STREAM_REG_DEF(FIFOW, 0) + 70) /* 0x16E */
445#define HDA_RMX_SD0FIFOW 37
446#define HDA_RMX_SD1FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 10)
447#define HDA_RMX_SD2FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 20)
448#define HDA_RMX_SD3FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 30)
449#define HDA_RMX_SD4FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 40)
450#define HDA_RMX_SD5FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 50)
451#define HDA_RMX_SD6FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 60)
452#define HDA_RMX_SD7FIFOW (HDA_STREAM_RMX_DEF(FIFOW, 0) + 70)
453
454/*
455 * ICH6 datasheet defined limits for FIFOW values (18.2.38).
456 */
457#define HDA_SDFIFOW_8B 0x2
458#define HDA_SDFIFOW_16B 0x3
459#define HDA_SDFIFOW_32B 0x4
460
461#define HDA_REG_SD0FIFOS 40 /* 0x90 */
462#define HDA_REG_SD1FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 10) /* 0xB0 */
463#define HDA_REG_SD2FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 20) /* 0xD0 */
464#define HDA_REG_SD3FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 30) /* 0xF0 */
465#define HDA_REG_SD4FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 40) /* 0x110 */
466#define HDA_REG_SD5FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 50) /* 0x130 */
467#define HDA_REG_SD6FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 60) /* 0x150 */
468#define HDA_REG_SD7FIFOS (HDA_STREAM_REG_DEF(FIFOS, 0) + 70) /* 0x170 */
469#define HDA_RMX_SD0FIFOS 38
470#define HDA_RMX_SD1FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 10)
471#define HDA_RMX_SD2FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 20)
472#define HDA_RMX_SD3FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 30)
473#define HDA_RMX_SD4FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 40)
474#define HDA_RMX_SD5FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 50)
475#define HDA_RMX_SD6FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 60)
476#define HDA_RMX_SD7FIFOS (HDA_STREAM_RMX_DEF(FIFOS, 0) + 70)
477
478/*
479 * ICH6 datasheet defines limits for FIFOS registers (18.2.39)
480 * formula: size - 1
481 * Other values not listed are not supported.
482 */
483#define HDA_SDIFIFO_120B 0x77 /* 8-, 16-, 20-, 24-, 32-bit Input Streams */
484#define HDA_SDIFIFO_160B 0x9F /* 20-, 24-bit Input Streams Streams */
485
486#define HDA_SDOFIFO_16B 0x0F /* 8-, 16-, 20-, 24-, 32-bit Output Streams */
487#define HDA_SDOFIFO_32B 0x1F /* 8-, 16-, 20-, 24-, 32-bit Output Streams */
488#define HDA_SDOFIFO_64B 0x3F /* 8-, 16-, 20-, 24-, 32-bit Output Streams */
489#define HDA_SDOFIFO_128B 0x7F /* 8-, 16-, 20-, 24-, 32-bit Output Streams */
490#define HDA_SDOFIFO_192B 0xBF /* 8-, 16-, 20-, 24-, 32-bit Output Streams */
491#define HDA_SDOFIFO_256B 0xFF /* 20-, 24-bit Output Streams */
492#define SDFIFOS(pThis, num) HDA_REG((pThis), SD(FIFOS, num))
493
494#define HDA_REG_SD0FMT 41 /* 0x92 */
495#define HDA_REG_SD1FMT (HDA_STREAM_REG_DEF(FMT, 0) + 10) /* 0xB2 */
496#define HDA_REG_SD2FMT (HDA_STREAM_REG_DEF(FMT, 0) + 20) /* 0xD2 */
497#define HDA_REG_SD3FMT (HDA_STREAM_REG_DEF(FMT, 0) + 30) /* 0xF2 */
498#define HDA_REG_SD4FMT (HDA_STREAM_REG_DEF(FMT, 0) + 40) /* 0x112 */
499#define HDA_REG_SD5FMT (HDA_STREAM_REG_DEF(FMT, 0) + 50) /* 0x132 */
500#define HDA_REG_SD6FMT (HDA_STREAM_REG_DEF(FMT, 0) + 60) /* 0x152 */
501#define HDA_REG_SD7FMT (HDA_STREAM_REG_DEF(FMT, 0) + 70) /* 0x172 */
502#define HDA_RMX_SD0FMT 39
503#define HDA_RMX_SD1FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 10)
504#define HDA_RMX_SD2FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 20)
505#define HDA_RMX_SD3FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 30)
506#define HDA_RMX_SD4FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 40)
507#define HDA_RMX_SD5FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 50)
508#define HDA_RMX_SD6FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 60)
509#define HDA_RMX_SD7FMT (HDA_STREAM_RMX_DEF(FMT, 0) + 70)
510
511#define SDFMT(pThis, num) (HDA_REG((pThis), SD(FMT, num)))
512#define HDA_SDFMT_BASE_RATE(pThis, num) ((SDFMT(pThis, num) & HDA_REG_FIELD_FLAG_MASK(SDFMT, BASE_RATE)) >> HDA_REG_FIELD_SHIFT(SDFMT, BASE_RATE))
513#define HDA_SDFMT_MULT(pThis, num) ((SDFMT((pThis), num) & HDA_REG_FIELD_MASK(SDFMT,MULT)) >> HDA_REG_FIELD_SHIFT(SDFMT, MULT))
514#define HDA_SDFMT_DIV(pThis, num) ((SDFMT((pThis), num) & HDA_REG_FIELD_MASK(SDFMT,DIV)) >> HDA_REG_FIELD_SHIFT(SDFMT, DIV))
515
516#define HDA_REG_SD0BDPL 42 /* 0x98 */
517#define HDA_REG_SD1BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 10) /* 0xB8 */
518#define HDA_REG_SD2BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 20) /* 0xD8 */
519#define HDA_REG_SD3BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 30) /* 0xF8 */
520#define HDA_REG_SD4BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 40) /* 0x118 */
521#define HDA_REG_SD5BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 50) /* 0x138 */
522#define HDA_REG_SD6BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 60) /* 0x158 */
523#define HDA_REG_SD7BDPL (HDA_STREAM_REG_DEF(BDPL, 0) + 70) /* 0x178 */
524#define HDA_RMX_SD0BDPL 40
525#define HDA_RMX_SD1BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 10)
526#define HDA_RMX_SD2BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 20)
527#define HDA_RMX_SD3BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 30)
528#define HDA_RMX_SD4BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 40)
529#define HDA_RMX_SD5BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 50)
530#define HDA_RMX_SD6BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 60)
531#define HDA_RMX_SD7BDPL (HDA_STREAM_RMX_DEF(BDPL, 0) + 70)
532
533#define HDA_REG_SD0BDPU 43 /* 0x9C */
534#define HDA_REG_SD1BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 10) /* 0xBC */
535#define HDA_REG_SD2BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 20) /* 0xDC */
536#define HDA_REG_SD3BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 30) /* 0xFC */
537#define HDA_REG_SD4BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 40) /* 0x11C */
538#define HDA_REG_SD5BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 50) /* 0x13C */
539#define HDA_REG_SD6BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 60) /* 0x15C */
540#define HDA_REG_SD7BDPU (HDA_STREAM_REG_DEF(BDPU, 0) + 70) /* 0x17C */
541#define HDA_RMX_SD0BDPU 41
542#define HDA_RMX_SD1BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 10)
543#define HDA_RMX_SD2BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 20)
544#define HDA_RMX_SD3BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 30)
545#define HDA_RMX_SD4BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 40)
546#define HDA_RMX_SD5BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 50)
547#define HDA_RMX_SD6BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 60)
548#define HDA_RMX_SD7BDPU (HDA_STREAM_RMX_DEF(BDPU, 0) + 70)
549
550#define HDA_CODEC_CAD_SHIFT 28
551/* Encodes the (required) LUN into a codec command. */
552#define HDA_CODEC_CMD(cmd, lun) ((cmd) | (lun << HDA_CODEC_CAD_SHIFT))
553
554
555
556/*********************************************************************************************************************************
557* Structures and Typedefs *
558*********************************************************************************************************************************/
559
560/**
561 * Internal state of a Buffer Descriptor List Entry (BDLE),
562 * needed to keep track of the data needed for the actual device
563 * emulation.
564 */
565typedef struct HDABDLESTATE
566{
567 /** Own index within the BDL (Buffer Descriptor List). */
568 uint32_t u32BDLIndex;
569 /** Number of bytes below the stream's FIFO watermark (SDFIFOW).
570 * Used to check if we need fill up the FIFO again. */
571 uint32_t cbBelowFIFOW;
572 /** The buffer descriptor's internal DMA buffer. */
573 uint8_t au8FIFO[HDA_SDOFIFO_256B + 1];
574 /** Current offset in DMA buffer (in bytes).*/
575 uint32_t u32BufOff;
576 uint32_t Padding;
577} HDABDLESTATE, *PHDABDLESTATE;
578
579/**
580 * Buffer Descriptor List Entry (BDLE) (3.6.3).
581 *
582 * Contains only register values which do *not* change until a
583 * stream reset occurs.
584 */
585typedef struct HDABDLE
586{
587 /** Starting address of the actual buffer. Must be 128-bit aligned. */
588 uint64_t u64BufAdr;
589 /** Size of the actual buffer (in bytes). */
590 uint32_t u32BufSize;
591 /** Interrupt on completion; the controller will generate
592 * an interrupt when the last byte of the buffer has been
593 * fetched by the DMA engine. */
594 bool fIntOnCompletion;
595 /** Internal state of this BDLE.
596 * Not part of the actual BDLE registers. */
597 HDABDLESTATE State;
598} HDABDLE, *PHDABDLE;
599
600/**
601 * Structure for keeping an audio stream data mapping.
602 */
603typedef struct HDASTREAMMAPPING
604{
605 /** The stream's layout. */
606 PDMAUDIOSTREAMLAYOUT enmLayout;
607 /** Number of audio channels in this stream. */
608 uint8_t cChannels;
609 /** Array audio channels. */
610 R3PTRTYPE(PPDMAUDIOSTREAMCHANNEL) paChannels;
611 R3PTRTYPE(PRTCIRCBUF) pCircBuf;
612} HDASTREAMMAPPING, *PHDASTREAMMAPPING;
613
614/**
615 * Internal state of a HDA stream.
616 */
617typedef struct HDASTREAMSTATE
618{
619 /** Current BDLE to use. Wraps around to 0 if
620 * maximum (cBDLE) is reached. */
621 uint16_t uCurBDLE;
622 /** Stop indicator. */
623 volatile bool fDoStop;
624 /** Flag indicating whether this stream is in an
625 * active (operative) state or not. */
626 volatile bool fActive;
627 /** Flag indicating whether this stream currently is
628 * in reset mode and therefore not acccessible by the guest. */
629 volatile bool fInReset;
630 /** Unused, padding. */
631 bool fPadding;
632 /** Mutex semaphore handle to serialize access. */
633 RTSEMMUTEX hMtx;
634 /** Event signalling that the stream's state has been changed. */
635 RTSEMEVENT hStateChangedEvent;
636 /** This stream's data mapping. */
637 HDASTREAMMAPPING Mapping;
638 /** Current BDLE (Buffer Descriptor List Entry). */
639 HDABDLE BDLE;
640} HDASTREAMSTATE, *PHDASTREAMSTATE;
641
642/**
643 * Structure defining an HDA mixer sink.
644 * Its purpose is to know which audio mixer sink is bound to
645 * which SDn (SDI/SDO) device stream.
646 *
647 * This is needed in order to handle interleaved streams
648 * (that is, multiple channels in one stream) or non-interleaved
649 * streams (each channel has a dedicated stream).
650 *
651 * This is only known to the actual device emulation level.
652 */
653typedef struct HDAMIXERSINK
654{
655 /** SDn ID this sink is assigned to. 0 if not assigned. */
656 uint8_t uSD;
657 /** Channel ID of SDn ID. Only valid if SDn ID is valid. */
658 uint8_t uChannel;
659 uint8_t Padding[3];
660 /** Pointer to the actual audio mixer sink. */
661 R3PTRTYPE(PAUDMIXSINK) pMixSink;
662} HDAMIXERSINK, *PHDAMIXERSINK;
663
664/**
665 * Structure for keeping a HDA stream state.
666 *
667 * Contains only register values which do *not* change until a
668 * stream reset occurs.
669 */
670typedef struct HDASTREAM
671{
672 /** Stream descriptor number (SDn). */
673 uint8_t u8SD;
674 uint8_t Padding0[7];
675 /** DMA base address (SDnBDPU - SDnBDPL). */
676 uint64_t u64BDLBase;
677 /** Cyclic Buffer Length (SDnCBL).
678 * Represents the size of the ring buffer. */
679 uint32_t u32CBL;
680 /** Format (SDnFMT). */
681 uint16_t u16FMT;
682 /** FIFO Size (FIFOS).
683 * Maximum number of bytes that may have been DMA'd into
684 * memory but not yet transmitted on the link.
685 *
686 * Must be a power of two. */
687 uint16_t u16FIFOS;
688 /** Last Valid Index (SDnLVI). */
689 uint16_t u16LVI;
690 uint16_t Padding1[3];
691 /** Pointer to HDA sink this stream is attached to. */
692 R3PTRTYPE(PHDAMIXERSINK) pMixSink;
693 /** Internal state of this stream. */
694 HDASTREAMSTATE State;
695} HDASTREAM, *PHDASTREAM;
696
697/**
698 * Structure for mapping a stream tag to an HDA stream.
699 */
700typedef struct HDATAG
701{
702 /** Own stream tag. */
703 uint8_t uTag;
704 uint8_t Padding[7];
705 /** Pointer to associated stream. */
706 R3PTRTYPE(PHDASTREAM) pStrm;
707} HDATAG, *PHDATAG;
708
709/**
710 * Structure defining an HDA mixer stream.
711 * This is being used together with an audio mixer instance.
712 */
713typedef struct HDAMIXERSTREAM
714{
715 union
716 {
717 /** Desired playback destination (for an output stream). */
718 PDMAUDIOPLAYBACKDEST Dest;
719 /** Desired recording source (for an input stream). */
720 PDMAUDIORECSOURCE Source;
721 } DestSource;
722 uint8_t Padding1[4];
723 /** Associated mixer handle. */
724 R3PTRTYPE(PAUDMIXSTREAM) pMixStrm;
725} HDAMIXERSTREAM, *PHDAMIXERSTREAM;
726
727/**
728 * Struct for maintaining a host backend driver.
729 * This driver must be associated to one, and only one,
730 * HDA codec. The HDA controller does the actual multiplexing
731 * of HDA codec data to various host backend drivers then.
732 *
733 * This HDA device uses a timer in order to synchronize all
734 * read/write accesses across all attached LUNs / backends.
735 */
736typedef struct HDADRIVER
737{
738 /** Node for storing this driver in our device driver list of HDASTATE. */
739 RTLISTNODER3 Node;
740 /** Pointer to HDA controller (state). */
741 R3PTRTYPE(PHDASTATE) pHDAState;
742 /** Driver flags. */
743 PDMAUDIODRVFLAGS Flags;
744 uint8_t u32Padding0[2];
745 /** LUN to which this driver has been assigned. */
746 uint8_t uLUN;
747 /** Whether this driver is in an attached state or not. */
748 bool fAttached;
749 /** Pointer to attached driver base interface. */
750 R3PTRTYPE(PPDMIBASE) pDrvBase;
751 /** Audio connector interface to the underlying host backend. */
752 R3PTRTYPE(PPDMIAUDIOCONNECTOR) pConnector;
753 /** Mixer stream for line input. */
754 HDAMIXERSTREAM LineIn;
755#ifdef VBOX_WITH_HDA_MIC_IN
756 /** Mixer stream for mic input. */
757 HDAMIXERSTREAM MicIn;
758#endif
759 /** Mixer stream for front output. */
760 HDAMIXERSTREAM Front;
761#ifdef VBOX_WITH_HDA_51_SURROUND
762 /** Mixer stream for center/LFE output. */
763 HDAMIXERSTREAM CenterLFE;
764 /** Mixer stream for rear output. */
765 HDAMIXERSTREAM Rear;
766#endif
767} HDADRIVER;
768
769/**
770 * ICH Intel HD Audio Controller state.
771 */
772typedef struct HDASTATE
773{
774 /** The PCI device structure. */
775 PCIDevice PciDev;
776 /** R3 Pointer to the device instance. */
777 PPDMDEVINSR3 pDevInsR3;
778 /** R0 Pointer to the device instance. */
779 PPDMDEVINSR0 pDevInsR0;
780 /** R0 Pointer to the device instance. */
781 PPDMDEVINSRC pDevInsRC;
782 /** Padding for alignment. */
783 uint32_t u32Padding;
784 /** The base interface for LUN\#0. */
785 PDMIBASE IBase;
786 RTGCPHYS MMIOBaseAddr;
787 /** The HDA's register set. */
788 uint32_t au32Regs[HDA_NUM_REGS];
789 /** Internal stream states. */
790 HDASTREAM aStreams[HDA_MAX_STREAMS];
791 /** Mapping table between stream tags and stream states. */
792 HDATAG aTags[HDA_MAX_TAGS];
793 /** CORB buffer base address. */
794 uint64_t u64CORBBase;
795 /** RIRB buffer base address. */
796 uint64_t u64RIRBBase;
797 /** DMA base address.
798 * Made out of DPLBASE + DPUBASE (3.3.32 + 3.3.33). */
799 uint64_t u64DPBase;
800 /** DMA position buffer enable bit. */
801 bool fDMAPosition;
802 /** Padding for alignment. */
803 uint8_t u8Padding0[7];
804 /** Pointer to CORB buffer. */
805 R3PTRTYPE(uint32_t *) pu32CorbBuf;
806 /** Size in bytes of CORB buffer. */
807 uint32_t cbCorbBuf;
808 /** Padding for alignment. */
809 uint32_t u32Padding1;
810 /** Pointer to RIRB buffer. */
811 R3PTRTYPE(uint64_t *) pu64RirbBuf;
812 /** Size in bytes of RIRB buffer. */
813 uint32_t cbRirbBuf;
814 /** Indicates if HDA controller is in reset mode. */
815 bool fInReset;
816 /** Flag whether the R0 part is enabled. */
817 bool fR0Enabled;
818 /** Flag whether the RC part is enabled. */
819 bool fRCEnabled;
820 /** Number of active (running) SDn streams. */
821 uint8_t cStreamsActive;
822#ifndef VBOX_WITH_AUDIO_CALLBACKS
823 /** The timer for pumping data thru the attached LUN drivers. */
824 PTMTIMERR3 pTimer;
825 /** Flag indicating whether the timer is active or not. */
826 bool fTimerActive;
827 uint8_t u8Padding1[7];
828 /** Timer ticks per Hz. */
829 uint64_t cTimerTicks;
830 /** Timestamp of the last timer callback (hdaTimer).
831 * Used to calculate the time actually elapsed between two timer callbacks. */
832 uint64_t uTimerTS;
833#endif
834#ifdef VBOX_WITH_STATISTICS
835# ifndef VBOX_WITH_AUDIO_CALLBACKS
836 STAMPROFILE StatTimer;
837# endif
838 STAMCOUNTER StatBytesRead;
839 STAMCOUNTER StatBytesWritten;
840#endif
841 /** Pointer to HDA codec to use. */
842 R3PTRTYPE(PHDACODEC) pCodec;
843 /** List of associated LUN drivers (HDADRIVER). */
844 RTLISTANCHORR3 lstDrv;
845 /** The device' software mixer. */
846 R3PTRTYPE(PAUDIOMIXER) pMixer;
847 /** HDA sink for (front) output. */
848 HDAMIXERSINK SinkFront;
849#ifdef VBOX_WITH_HDA_51_SURROUND
850 /** HDA sink for center / LFE output. */
851 HDAMIXERSINK SinkCenterLFE;
852 /** HDA sink for rear output. */
853 HDAMIXERSINK SinkRear;
854#endif
855 /** HDA mixer sink for line input. */
856 HDAMIXERSINK SinkLineIn;
857#ifdef VBOX_WITH_HDA_MIC_IN
858 /** Audio mixer sink for microphone input. */
859 HDAMIXERSINK SinkMicIn;
860#endif
861 uint64_t u64BaseTS;
862 /** Response Interrupt Count (RINTCNT). */
863 uint8_t u8RespIntCnt;
864 /** Padding for alignment. */
865 uint8_t au8Padding2[7];
866} HDASTATE;
867/** Pointer to the ICH Intel HD Audio Controller state. */
868typedef HDASTATE *PHDASTATE;
869
870#ifdef VBOX_WITH_AUDIO_CALLBACKS
871typedef struct HDACALLBACKCTX
872{
873 PHDASTATE pThis;
874 PHDADRIVER pDriver;
875} HDACALLBACKCTX, *PHDACALLBACKCTX;
876#endif
877
878/*********************************************************************************************************************************
879* Internal Functions *
880*********************************************************************************************************************************/
881#ifndef VBOX_DEVICE_STRUCT_TESTCASE
882static FNPDMDEVRESET hdaReset;
883
884/*
885 * Stubs.
886 */
887static int hdaRegReadUnimpl(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
888static int hdaRegWriteUnimpl(PHDASTATE pThis, uint32_t iReg, uint32_t pu32Value);
889
890/*
891 * Global register set read/write functions.
892 */
893static int hdaRegWriteGCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
894static int hdaRegReadINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
895static int hdaRegReadLPIB(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
896static int hdaRegReadWALCLK(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
897static int hdaRegReadSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
898static int hdaRegWriteSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
899static int hdaRegWriteINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
900static int hdaRegWriteCORBWP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
901static int hdaRegWriteCORBRP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
902static int hdaRegWriteCORBCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
903static int hdaRegWriteCORBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
904static int hdaRegWriteRIRBWP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
905static int hdaRegWriteRIRBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
906static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
907static int hdaRegWriteIRS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
908static int hdaRegReadIRS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
909static int hdaRegWriteBase(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
910
911/*
912 * {IOB}SDn read/write functions.
913 */
914static int hdaRegWriteSDCBL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
915static int hdaRegWriteSDCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
916static int hdaRegWriteSDSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
917static int hdaRegWriteSDLVI(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
918static int hdaRegWriteSDFIFOW(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
919static int hdaRegWriteSDFIFOS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
920static int hdaRegWriteSDFMT(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
921static int hdaRegWriteSDBDPL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
922static int hdaRegWriteSDBDPU(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
923DECLINLINE(int) hdaRegWriteSDLock(PHDASTATE pThis, PHDASTREAM pStream, uint32_t iReg, uint32_t u32Value);
924DECLINLINE(void) hdaRegWriteSDUnlock(PHDASTREAM pStream);
925
926/*
927 * Generic register read/write functions.
928 */
929static int hdaRegReadU32(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
930static int hdaRegWriteU32(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
931static int hdaRegReadU24(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
932static int hdaRegWriteU24(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
933static int hdaRegReadU16(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
934static int hdaRegWriteU16(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
935static int hdaRegReadU8(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
936static int hdaRegWriteU8(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
937
938#ifdef IN_RING3
939static void hdaStreamDestroy(PHDASTREAM pStream);
940static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive);
941static int hdaStreamStart(PHDASTREAM pStream);
942static int hdaStreamStop(PHDASTREAM pStream);
943static int hdaStreamWaitForStateChange(PHDASTREAM pStream, RTMSINTERVAL msTimeout);
944static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStream);
945#endif
946
947#ifdef IN_RING3
948static int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg);
949static void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping);
950static void hdaStreamMapReset(PHDASTREAMMAPPING pMapping);
951#endif
952
953#ifdef IN_RING3
954static int hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
955DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB);
956# ifdef LOG_ENABLED
957static void hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BaseDMA, uint16_t cBDLE);
958# endif
959#endif
960static int hdaProcessInterrupt(PHDASTATE pThis);
961
962/*
963 * Timer routines.
964 */
965#ifndef VBOX_WITH_AUDIO_CALLBACKS
966static void hdaTimerMaybeStart(PHDASTATE pThis);
967static void hdaTimerMaybeStop(PHDASTATE pThis);
968static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
969#endif
970
971/*********************************************************************************************************************************
972* Global Variables *
973*********************************************************************************************************************************/
974
975/** Offset of the SD0 register map. */
976#define HDA_REG_DESC_SD0_BASE 0x80
977
978/** Turn a short global register name into an memory index and a stringized name. */
979#define HDA_REG_IDX(abbrev) HDA_MEM_IND_NAME(abbrev), #abbrev
980
981/** Turns a short stream register name into an memory index and a stringized name. */
982#define HDA_REG_IDX_STRM(reg, suff) HDA_MEM_IND_NAME(reg ## suff), #reg #suff
983
984/** Same as above for a register *not* stored in memory. */
985#define HDA_REG_IDX_LOCAL(abbrev) 0, #abbrev
986
987/** Emits a single audio stream register set (e.g. OSD0) at a specified offset. */
988#define HDA_REG_MAP_STRM(offset, name) \
989 /* offset size read mask write mask read callback write callback index + abbrev description */ \
990 /* ------- ------- ---------- ---------- -------------- ----------------- ------------------------------ ----------- */ \
991 /* Offset 0x80 (SD0) */ \
992 { offset, 0x00003, 0x00FF001F, 0x00F0001F, hdaRegReadU24 , hdaRegWriteSDCTL , HDA_REG_IDX_STRM(name, CTL) , #name " Stream Descriptor Control" }, \
993 /* Offset 0x83 (SD0) */ \
994 { offset + 0x3, 0x00001, 0x0000001C, 0x0000003C, hdaRegReadU8 , hdaRegWriteSDSTS , HDA_REG_IDX_STRM(name, STS) , #name " Status" }, \
995 /* Offset 0x84 (SD0) */ \
996 { offset + 0x4, 0x00004, 0xFFFFFFFF, 0x00000000, hdaRegReadLPIB, hdaRegWriteU32 , HDA_REG_IDX_STRM(name, LPIB) , #name " Link Position In Buffer" }, \
997 /* Offset 0x88 (SD0) */ \
998 { offset + 0x8, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32, hdaRegWriteSDCBL , HDA_REG_IDX_STRM(name, CBL) , #name " Cyclic Buffer Length" }, \
999 /* Offset 0x8C (SD0) */ \
1000 { offset + 0xC, 0x00002, 0x0000FFFF, 0x0000FFFF, hdaRegReadU16, hdaRegWriteSDLVI , HDA_REG_IDX_STRM(name, LVI) , #name " Last Valid Index" }, \
1001 /* Reserved: FIFO Watermark. ** @todo Document this! */ \
1002 { offset + 0xE, 0x00002, 0x00000007, 0x00000007, hdaRegReadU16, hdaRegWriteU16, HDA_REG_IDX_STRM(name, FIFOW), #name " FIFO Watermark" }, \
1003 /* Offset 0x90 (SD0) */ \
1004 { offset + 0x10, 0x00002, 0x000000FF, 0x00000000, hdaRegReadU16, hdaRegWriteU16, HDA_REG_IDX_STRM(name, FIFOS), #name " FIFO Size" }, \
1005 /* Offset 0x92 (SD0) */ \
1006 { offset + 0x12, 0x00002, 0x00007F7F, 0x00007F7F, hdaRegReadU16, hdaRegWriteSDFMT , HDA_REG_IDX_STRM(name, FMT) , #name " Stream Format" }, \
1007 /* Reserved: 0x94 - 0x98. */ \
1008 /* Offset 0x98 (SD0) */ \
1009 { offset + 0x18, 0x00004, 0xFFFFFF80, 0xFFFFFF80, hdaRegReadU32, hdaRegWriteSDBDPL , HDA_REG_IDX_STRM(name, BDPL) , #name " Buffer Descriptor List Pointer-Lower Base Address" }, \
1010 /* Offset 0x9C (SD0) */ \
1011 { offset + 0x1C, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32, hdaRegWriteSDBDPU , HDA_REG_IDX_STRM(name, BDPU) , #name " Buffer Descriptor List Pointer-Upper Base Address" }
1012
1013/** Defines a single audio stream register set (e.g. OSD0). */
1014#define HDA_REG_MAP_DEF_STREAM(index, name) \
1015 HDA_REG_MAP_STRM(HDA_REG_DESC_SD0_BASE + (index * 32 /* 0x20 */), name)
1016
1017/* See 302349 p 6.2. */
1018static const struct HDAREGDESC
1019{
1020 /** Register offset in the register space. */
1021 uint32_t offset;
1022 /** Size in bytes. Registers of size > 4 are in fact tables. */
1023 uint32_t size;
1024 /** Readable bits. */
1025 uint32_t readable;
1026 /** Writable bits. */
1027 uint32_t writable;
1028 /** Read callback. */
1029 int (*pfnRead)(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
1030 /** Write callback. */
1031 int (*pfnWrite)(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
1032 /** Index into the register storage array. */
1033 uint32_t mem_idx;
1034 /** Abbreviated name. */
1035 const char *abbrev;
1036 /** Descripton. */
1037 const char *desc;
1038} g_aHdaRegMap[HDA_NUM_REGS] =
1039
1040{
1041 /* offset size read mask write mask read callback write callback index + abbrev */
1042 /*------- ------- ---------- ---------- ----------------------- ---------------------- ---------------- */
1043 { 0x00000, 0x00002, 0x0000FFFB, 0x00000000, hdaRegReadU16 , hdaRegWriteUnimpl , HDA_REG_IDX(GCAP) }, /* Global Capabilities */
1044 { 0x00002, 0x00001, 0x000000FF, 0x00000000, hdaRegReadU8 , hdaRegWriteUnimpl , HDA_REG_IDX(VMIN) }, /* Minor Version */
1045 { 0x00003, 0x00001, 0x000000FF, 0x00000000, hdaRegReadU8 , hdaRegWriteUnimpl , HDA_REG_IDX(VMAJ) }, /* Major Version */
1046 { 0x00004, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16 , hdaRegWriteU16 , HDA_REG_IDX(OUTPAY) }, /* Output Payload Capabilities */
1047 { 0x00006, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16 , hdaRegWriteUnimpl , HDA_REG_IDX(INPAY) }, /* Input Payload Capabilities */
1048 { 0x00008, 0x00004, 0x00000103, 0x00000103, hdaRegReadU32 , hdaRegWriteGCTL , HDA_REG_IDX(GCTL) }, /* Global Control */
1049 { 0x0000c, 0x00002, 0x00007FFF, 0x00007FFF, hdaRegReadU16 , hdaRegWriteU16 , HDA_REG_IDX(WAKEEN) }, /* Wake Enable */
1050 { 0x0000e, 0x00002, 0x00000007, 0x00000007, hdaRegReadU8 , hdaRegWriteSTATESTS , HDA_REG_IDX(STATESTS) }, /* State Change Status */
1051 { 0x00010, 0x00002, 0xFFFFFFFF, 0x00000000, hdaRegReadUnimpl , hdaRegWriteUnimpl , HDA_REG_IDX(GSTS) }, /* Global Status */
1052 { 0x00018, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16 , hdaRegWriteU16 , HDA_REG_IDX(OUTSTRMPAY) }, /* Output Stream Payload Capability */
1053 { 0x0001A, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16 , hdaRegWriteUnimpl , HDA_REG_IDX(INSTRMPAY) }, /* Input Stream Payload Capability */
1054 { 0x00020, 0x00004, 0xC00000FF, 0xC00000FF, hdaRegReadU32 , hdaRegWriteU32 , HDA_REG_IDX(INTCTL) }, /* Interrupt Control */
1055 { 0x00024, 0x00004, 0xC00000FF, 0x00000000, hdaRegReadINTSTS , hdaRegWriteUnimpl , HDA_REG_IDX(INTSTS) }, /* Interrupt Status */
1056 { 0x00030, 0x00004, 0xFFFFFFFF, 0x00000000, hdaRegReadWALCLK , hdaRegWriteUnimpl , HDA_REG_IDX_LOCAL(WALCLK) }, /* Wall Clock Counter */
1057 { 0x00034, 0x00004, 0x000000FF, 0x000000FF, hdaRegReadU32 , hdaRegWriteU32 , HDA_REG_IDX(SSYNC) }, /* Stream Synchronization */
1058 { 0x00040, 0x00004, 0xFFFFFF80, 0xFFFFFF80, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(CORBLBASE) }, /* CORB Lower Base Address */
1059 { 0x00044, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(CORBUBASE) }, /* CORB Upper Base Address */
1060 { 0x00048, 0x00002, 0x000000FF, 0x000000FF, hdaRegReadU16 , hdaRegWriteCORBWP , HDA_REG_IDX(CORBWP) }, /* CORB Write Pointer */
1061 { 0x0004A, 0x00002, 0x000080FF, 0x000080FF, hdaRegReadU16 , hdaRegWriteCORBRP , HDA_REG_IDX(CORBRP) }, /* CORB Read Pointer */
1062 { 0x0004C, 0x00001, 0x00000003, 0x00000003, hdaRegReadU8 , hdaRegWriteCORBCTL , HDA_REG_IDX(CORBCTL) }, /* CORB Control */
1063 { 0x0004D, 0x00001, 0x00000001, 0x00000001, hdaRegReadU8 , hdaRegWriteCORBSTS , HDA_REG_IDX(CORBSTS) }, /* CORB Status */
1064 { 0x0004E, 0x00001, 0x000000F3, 0x00000000, hdaRegReadU8 , hdaRegWriteUnimpl , HDA_REG_IDX(CORBSIZE) }, /* CORB Size */
1065 { 0x00050, 0x00004, 0xFFFFFF80, 0xFFFFFF80, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(RIRBLBASE) }, /* RIRB Lower Base Address */
1066 { 0x00054, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(RIRBUBASE) }, /* RIRB Upper Base Address */
1067 { 0x00058, 0x00002, 0x000000FF, 0x00008000, hdaRegReadU8 , hdaRegWriteRIRBWP , HDA_REG_IDX(RIRBWP) }, /* RIRB Write Pointer */
1068 { 0x0005A, 0x00002, 0x000000FF, 0x000000FF, hdaRegReadU16 , hdaRegWriteU16 , HDA_REG_IDX(RINTCNT) }, /* Response Interrupt Count */
1069 { 0x0005C, 0x00001, 0x00000007, 0x00000007, hdaRegReadU8 , hdaRegWriteU8 , HDA_REG_IDX(RIRBCTL) }, /* RIRB Control */
1070 { 0x0005D, 0x00001, 0x00000005, 0x00000005, hdaRegReadU8 , hdaRegWriteRIRBSTS , HDA_REG_IDX(RIRBSTS) }, /* RIRB Status */
1071 { 0x0005E, 0x00001, 0x000000F3, 0x00000000, hdaRegReadU8 , hdaRegWriteUnimpl , HDA_REG_IDX(RIRBSIZE) }, /* RIRB Size */
1072 { 0x00060, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32 , hdaRegWriteU32 , HDA_REG_IDX(IC) }, /* Immediate Command */
1073 { 0x00064, 0x00004, 0x00000000, 0xFFFFFFFF, hdaRegReadU32 , hdaRegWriteUnimpl , HDA_REG_IDX(IR) }, /* Immediate Response */
1074 { 0x00068, 0x00002, 0x00000002, 0x00000002, hdaRegReadIRS , hdaRegWriteIRS , HDA_REG_IDX(IRS) }, /* Immediate Command Status */
1075 { 0x00070, 0x00004, 0xFFFFFFFF, 0xFFFFFF81, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(DPLBASE) }, /* DMA Position Lower Base */
1076 { 0x00074, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32 , hdaRegWriteBase , HDA_REG_IDX(DPUBASE) }, /* DMA Position Upper Base */
1077 /* 4 Serial Data In (SDI). */
1078 HDA_REG_MAP_DEF_STREAM(0, SD0),
1079 HDA_REG_MAP_DEF_STREAM(1, SD1),
1080 HDA_REG_MAP_DEF_STREAM(2, SD2),
1081 HDA_REG_MAP_DEF_STREAM(3, SD3),
1082 /* 4 Serial Data Out (SDO). */
1083 HDA_REG_MAP_DEF_STREAM(4, SD4),
1084 HDA_REG_MAP_DEF_STREAM(5, SD5),
1085 HDA_REG_MAP_DEF_STREAM(6, SD6),
1086 HDA_REG_MAP_DEF_STREAM(7, SD7)
1087};
1088
1089/**
1090 * HDA register aliases (HDA spec 3.3.45).
1091 * @remarks Sorted by offReg.
1092 */
1093static const struct
1094{
1095 /** The alias register offset. */
1096 uint32_t offReg;
1097 /** The register index. */
1098 int idxAlias;
1099} g_aHdaRegAliases[] =
1100{
1101 { 0x2084, HDA_REG_SD0LPIB },
1102 { 0x20a4, HDA_REG_SD1LPIB },
1103 { 0x20c4, HDA_REG_SD2LPIB },
1104 { 0x20e4, HDA_REG_SD3LPIB },
1105 { 0x2104, HDA_REG_SD4LPIB },
1106 { 0x2124, HDA_REG_SD5LPIB },
1107 { 0x2144, HDA_REG_SD6LPIB },
1108 { 0x2164, HDA_REG_SD7LPIB },
1109};
1110
1111#ifdef IN_RING3
1112/** HDABDLE field descriptors for the v6+ saved state. */
1113static SSMFIELD const g_aSSMBDLEFields6[] =
1114{
1115 SSMFIELD_ENTRY(HDABDLE, u64BufAdr),
1116 SSMFIELD_ENTRY(HDABDLE, u32BufSize),
1117 SSMFIELD_ENTRY(HDABDLE, fIntOnCompletion),
1118 SSMFIELD_ENTRY_TERM()
1119};
1120
1121/** HDABDLESTATE field descriptors for the v6+ saved state. */
1122static SSMFIELD const g_aSSMBDLEStateFields6[] =
1123{
1124 SSMFIELD_ENTRY(HDABDLESTATE, u32BDLIndex),
1125 SSMFIELD_ENTRY(HDABDLESTATE, cbBelowFIFOW),
1126 SSMFIELD_ENTRY(HDABDLESTATE, au8FIFO),
1127 SSMFIELD_ENTRY(HDABDLESTATE, u32BufOff),
1128 SSMFIELD_ENTRY_TERM()
1129};
1130
1131/** HDASTREAMSTATE field descriptors for the v6+ saved state. */
1132static SSMFIELD const g_aSSMStreamStateFields6[] =
1133{
1134 SSMFIELD_ENTRY_OLD(cBDLE, 2),
1135 SSMFIELD_ENTRY(HDASTREAMSTATE, uCurBDLE),
1136 SSMFIELD_ENTRY(HDASTREAMSTATE, fDoStop),
1137 SSMFIELD_ENTRY(HDASTREAMSTATE, fActive),
1138 SSMFIELD_ENTRY(HDASTREAMSTATE, fInReset),
1139 SSMFIELD_ENTRY_TERM()
1140};
1141#endif
1142
1143/**
1144 * 32-bit size indexed masks, i.e. g_afMasks[2 bytes] = 0xffff.
1145 */
1146static uint32_t const g_afMasks[5] =
1147{
1148 UINT32_C(0), UINT32_C(0x000000ff), UINT32_C(0x0000ffff), UINT32_C(0x00ffffff), UINT32_C(0xffffffff)
1149};
1150
1151#ifdef IN_RING3
1152DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB)
1153{
1154 AssertPtrReturn(pThis, 0);
1155 AssertPtrReturn(pStream, 0);
1156
1157 Assert(u32LPIB <= pStream->u32CBL);
1158
1159 LogFlowFunc(("[SD%RU8]: LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",
1160 pStream->u8SD, u32LPIB, pThis->fDMAPosition));
1161
1162 /* Update LPIB in any case. */
1163 HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) = u32LPIB;
1164
1165 /* Do we need to tell the current DMA position? */
1166 if (pThis->fDMAPosition)
1167 {
1168 int rc2 = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
1169 (pThis->u64DPBase & DPBASE_ADDR_MASK) + (pStream->u8SD * 2 * sizeof(uint32_t)),
1170 (void *)&u32LPIB, sizeof(uint32_t));
1171 AssertRC(rc2);
1172 }
1173
1174 return u32LPIB;
1175}
1176#endif
1177
1178/**
1179 * Retrieves the number of bytes of a FIFOS register.
1180 *
1181 * @return Number of bytes of a given FIFOS register.
1182 */
1183DECLINLINE(uint16_t) hdaSDFIFOSToBytes(uint32_t u32RegFIFOS)
1184{
1185 uint16_t cb;
1186 switch (u32RegFIFOS)
1187 {
1188 /* Input */
1189 case HDA_SDIFIFO_120B: cb = 120; break;
1190 case HDA_SDIFIFO_160B: cb = 160; break;
1191
1192 /* Output */
1193 case HDA_SDOFIFO_16B: cb = 16; break;
1194 case HDA_SDOFIFO_32B: cb = 32; break;
1195 case HDA_SDOFIFO_64B: cb = 64; break;
1196 case HDA_SDOFIFO_128B: cb = 128; break;
1197 case HDA_SDOFIFO_192B: cb = 192; break;
1198 case HDA_SDOFIFO_256B: cb = 256; break;
1199 default:
1200 {
1201 cb = 0; /* Can happen on stream reset. */
1202 break;
1203 }
1204 }
1205
1206 return cb;
1207}
1208
1209/**
1210 * Retrieves the number of bytes of a FIFOW register.
1211 *
1212 * @return Number of bytes of a given FIFOW register.
1213 */
1214DECLINLINE(uint8_t) hdaSDFIFOWToBytes(uint32_t u32RegFIFOW)
1215{
1216 uint32_t cb;
1217 switch (u32RegFIFOW)
1218 {
1219 case HDA_SDFIFOW_8B: cb = 8; break;
1220 case HDA_SDFIFOW_16B: cb = 16; break;
1221 case HDA_SDFIFOW_32B: cb = 32; break;
1222 default: cb = 0; break;
1223 }
1224
1225#ifdef RT_STRICT
1226 Assert(RT_IS_POWER_OF_TWO(cb));
1227#endif
1228 return cb;
1229}
1230
1231#ifdef IN_RING3
1232/**
1233 * Fetches the next BDLE to use for a stream.
1234 *
1235 * @return IPRT status code.
1236 */
1237DECLINLINE(int) hdaStreamGetNextBDLE(PHDASTATE pThis, PHDASTREAM pStream)
1238{
1239 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1240 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1241
1242 NOREF(pThis);
1243
1244 Assert(pStream->State.uCurBDLE < pStream->u16LVI + 1);
1245
1246 LogFlowFuncEnter();
1247
1248#ifdef DEBUG
1249 uint32_t uOldBDLE = pStream->State.uCurBDLE;
1250#endif
1251
1252 PHDABDLE pBDLE = &pStream->State.BDLE;
1253
1254 /*
1255 * Switch to the next BDLE entry and do a wrap around
1256 * if we reached the end of the Buffer Descriptor List (BDL).
1257 */
1258 pStream->State.uCurBDLE++;
1259 if (pStream->State.uCurBDLE == pStream->u16LVI + 1)
1260 {
1261 pStream->State.uCurBDLE = 0;
1262
1263 hdaStreamUpdateLPIB(pThis, pStream, 0);
1264 }
1265
1266 Assert(pStream->State.uCurBDLE < pStream->u16LVI + 1);
1267
1268 /* Fetch the next BDLE entry. */
1269 int rc = hdaBDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
1270
1271#ifdef DEBUG
1272 LogFlowFunc(("[SD%RU8]: uOldBDLE=%RU16, uCurBDLE=%RU16, LVI=%RU32, rc=%Rrc, %R[bdle]\n",
1273 pStream->u8SD, uOldBDLE, pStream->State.uCurBDLE, pStream->u16LVI, rc, pBDLE));
1274#endif
1275
1276 return rc;
1277}
1278#endif /* IN_RING3 */
1279
1280/**
1281 * Returns the audio direction of a specified stream descriptor.
1282 *
1283 * The register layout specifies that input streams (SDI) come first,
1284 * followed by the output streams (SDO). So every stream ID below HDA_MAX_SDI
1285 * is an input stream, whereas everything >= HDA_MAX_SDI is an output stream.
1286 *
1287 * Note: SDnFMT register does not provide that information, so we have to judge
1288 * for ourselves.
1289 *
1290 * @return Audio direction.
1291 */
1292DECLINLINE(PDMAUDIODIR) hdaGetDirFromSD(uint8_t uSD)
1293{
1294 AssertReturn(uSD <= HDA_MAX_STREAMS, PDMAUDIODIR_UNKNOWN);
1295
1296 if (uSD < HDA_MAX_SDI)
1297 return PDMAUDIODIR_IN;
1298
1299 return PDMAUDIODIR_OUT;
1300}
1301
1302/**
1303 * Returns the HDA stream of specified stream descriptor number.
1304 *
1305 * @return Pointer to HDA stream, or NULL if none found.
1306 */
1307DECLINLINE(PHDASTREAM) hdaStreamFromSD(PHDASTATE pThis, uint8_t uSD)
1308{
1309 AssertPtrReturn(pThis, NULL);
1310 AssertReturn(uSD <= HDA_MAX_STREAMS, NULL);
1311
1312 if (uSD >= HDA_MAX_STREAMS)
1313 return NULL;
1314
1315 return &pThis->aStreams[uSD];
1316}
1317
1318/**
1319 * Returns the HDA stream of specified HDA sink.
1320 *
1321 * @return Pointer to HDA stream, or NULL if none found.
1322 */
1323DECLINLINE(PHDASTREAM) hdaGetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
1324{
1325 AssertPtrReturn(pThis, NULL);
1326 AssertPtrReturn(pSink, NULL);
1327
1328 /** @todo Do something with the channel mapping here? */
1329 return hdaStreamFromSD(pThis, pSink->uSD);
1330}
1331
1332/**
1333 * Retrieves the minimum number of bytes accumulated/free in the
1334 * FIFO before the controller will start a fetch/eviction of data.
1335 *
1336 * Uses SDFIFOW (FIFO Watermark Register).
1337 *
1338 * @return Number of bytes accumulated/free in the FIFO.
1339 */
1340DECLINLINE(uint8_t) hdaStreamGetFIFOW(PHDASTATE pThis, PHDASTREAM pStream)
1341{
1342 AssertPtrReturn(pThis, 0);
1343 AssertPtrReturn(pStream, 0);
1344
1345#ifdef VBOX_HDA_WITH_FIFO
1346 return hdaSDFIFOWToBytes(HDA_STREAM_REG(pThis, FIFOW, pStream->u8SD));
1347#else
1348 return 0;
1349#endif
1350}
1351
1352static int hdaProcessInterrupt(PHDASTATE pThis)
1353{
1354#define IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, num) \
1355 ( INTCTL_SX((pThis), num) \
1356 && (SDSTS(pThis, num) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
1357
1358 int iLevel = 0;
1359
1360 /** @todo Optimize IRQ handling. */
1361
1362 if (/* Controller Interrupt Enable (CIE). */
1363 HDA_REG_FLAG_VALUE(pThis, INTCTL, CIE)
1364 && ( HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
1365 || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
1366 || (HDA_REG(pThis, STATESTS) & HDA_REG(pThis, WAKEEN))))
1367 {
1368 iLevel = 1;
1369 }
1370
1371 if ( IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 0)
1372 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 1)
1373 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 2)
1374 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 3)
1375 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 4)
1376 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 5)
1377 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 6)
1378 || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 7))
1379 {
1380 iLevel = 1;
1381 }
1382
1383 if (HDA_REG_FLAG_VALUE(pThis, INTCTL, GIE))
1384 {
1385 Log3Func(("Level=%d\n", iLevel));
1386 PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , iLevel);
1387 }
1388
1389#undef IS_INTERRUPT_OCCURED_AND_ENABLED
1390
1391 return VINF_SUCCESS;
1392}
1393
1394/**
1395 * Looks up a register at the exact offset given by @a offReg.
1396 *
1397 * @returns Register index on success, -1 if not found.
1398 * @param pThis The HDA device state.
1399 * @param offReg The register offset.
1400 */
1401static int hdaRegLookup(PHDASTATE pThis, uint32_t offReg)
1402{
1403 /*
1404 * Aliases.
1405 */
1406 if (offReg >= g_aHdaRegAliases[0].offReg)
1407 {
1408 for (unsigned i = 0; i < RT_ELEMENTS(g_aHdaRegAliases); i++)
1409 if (offReg == g_aHdaRegAliases[i].offReg)
1410 return g_aHdaRegAliases[i].idxAlias;
1411 Assert(g_aHdaRegMap[RT_ELEMENTS(g_aHdaRegMap) - 1].offset < offReg);
1412 return -1;
1413 }
1414
1415 /*
1416 * Binary search the
1417 */
1418 int idxEnd = RT_ELEMENTS(g_aHdaRegMap);
1419 int idxLow = 0;
1420 for (;;)
1421 {
1422 int idxMiddle = idxLow + (idxEnd - idxLow) / 2;
1423 if (offReg < g_aHdaRegMap[idxMiddle].offset)
1424 {
1425 if (idxLow == idxMiddle)
1426 break;
1427 idxEnd = idxMiddle;
1428 }
1429 else if (offReg > g_aHdaRegMap[idxMiddle].offset)
1430 {
1431 idxLow = idxMiddle + 1;
1432 if (idxLow >= idxEnd)
1433 break;
1434 }
1435 else
1436 return idxMiddle;
1437 }
1438
1439#ifdef RT_STRICT
1440 for (unsigned i = 0; i < RT_ELEMENTS(g_aHdaRegMap); i++)
1441 Assert(g_aHdaRegMap[i].offset != offReg);
1442#endif
1443 return -1;
1444}
1445
1446/**
1447 * Looks up a register covering the offset given by @a offReg.
1448 *
1449 * @returns Register index on success, -1 if not found.
1450 * @param pThis The HDA device state.
1451 * @param offReg The register offset.
1452 */
1453static int hdaRegLookupWithin(PHDASTATE pThis, uint32_t offReg)
1454{
1455 /*
1456 * Aliases.
1457 */
1458 if (offReg >= g_aHdaRegAliases[0].offReg)
1459 {
1460 for (unsigned i = 0; i < RT_ELEMENTS(g_aHdaRegAliases); i++)
1461 {
1462 uint32_t off = offReg - g_aHdaRegAliases[i].offReg;
1463 if (off < 4 && off < g_aHdaRegMap[g_aHdaRegAliases[i].idxAlias].size)
1464 return g_aHdaRegAliases[i].idxAlias;
1465 }
1466 Assert(g_aHdaRegMap[RT_ELEMENTS(g_aHdaRegMap) - 1].offset < offReg);
1467 return -1;
1468 }
1469
1470 /*
1471 * Binary search the register map.
1472 */
1473 int idxEnd = RT_ELEMENTS(g_aHdaRegMap);
1474 int idxLow = 0;
1475 for (;;)
1476 {
1477 int idxMiddle = idxLow + (idxEnd - idxLow) / 2;
1478 if (offReg < g_aHdaRegMap[idxMiddle].offset)
1479 {
1480 if (idxLow == idxMiddle)
1481 break;
1482 idxEnd = idxMiddle;
1483 }
1484 else if (offReg >= g_aHdaRegMap[idxMiddle].offset + g_aHdaRegMap[idxMiddle].size)
1485 {
1486 idxLow = idxMiddle + 1;
1487 if (idxLow >= idxEnd)
1488 break;
1489 }
1490 else
1491 return idxMiddle;
1492 }
1493
1494#ifdef RT_STRICT
1495 for (unsigned i = 0; i < RT_ELEMENTS(g_aHdaRegMap); i++)
1496 Assert(offReg - g_aHdaRegMap[i].offset >= g_aHdaRegMap[i].size);
1497#endif
1498 return -1;
1499}
1500
1501#ifdef IN_RING3
1502static int hdaCmdSync(PHDASTATE pThis, bool fLocal)
1503{
1504 int rc = VINF_SUCCESS;
1505 if (fLocal)
1506 {
1507 Assert((HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA)));
1508 Assert(pThis->u64CORBBase);
1509 AssertPtr(pThis->pu32CorbBuf);
1510 Assert(pThis->cbCorbBuf);
1511
1512 rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), pThis->u64CORBBase, pThis->pu32CorbBuf, pThis->cbCorbBuf);
1513 if (RT_FAILURE(rc))
1514 AssertRCReturn(rc, rc);
1515#ifdef DEBUG_CMD_BUFFER
1516 uint8_t i = 0;
1517 do
1518 {
1519 LogFunc(("CORB%02x: ", i));
1520 uint8_t j = 0;
1521 do
1522 {
1523 const char *pszPrefix;
1524 if ((i + j) == HDA_REG(pThis, CORBRP));
1525 pszPrefix = "[R]";
1526 else if ((i + j) == HDA_REG(pThis, CORBWP));
1527 pszPrefix = "[W]";
1528 else
1529 pszPrefix = " "; /* three spaces */
1530 LogFunc(("%s%08x", pszPrefix, pThis->pu32CorbBuf[i + j]));
1531 j++;
1532 } while (j < 8);
1533 LogFunc(("\n"));
1534 i += 8;
1535 } while(i != 0);
1536#endif
1537 }
1538 else
1539 {
1540 Assert((HDA_REG_FLAG_VALUE(pThis, RIRBCTL, DMA)));
1541 rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), pThis->u64RIRBBase, pThis->pu64RirbBuf, pThis->cbRirbBuf);
1542 if (RT_FAILURE(rc))
1543 AssertRCReturn(rc, rc);
1544#ifdef DEBUG_CMD_BUFFER
1545 uint8_t i = 0;
1546 do {
1547 LogFunc(("RIRB%02x: ", i));
1548 uint8_t j = 0;
1549 do {
1550 const char *prefix;
1551 if ((i + j) == HDA_REG(pThis, RIRBWP))
1552 prefix = "[W]";
1553 else
1554 prefix = " ";
1555 LogFunc((" %s%016lx", prefix, pThis->pu64RirbBuf[i + j]));
1556 } while (++j < 8);
1557 LogFunc(("\n"));
1558 i += 8;
1559 } while (i != 0);
1560#endif
1561 }
1562 return rc;
1563}
1564
1565static int hdaCORBCmdProcess(PHDASTATE pThis)
1566{
1567 int rc = hdaCmdSync(pThis, true);
1568 if (RT_FAILURE(rc))
1569 AssertRCReturn(rc, rc);
1570
1571 uint8_t corbRp = HDA_REG(pThis, CORBRP);
1572 uint8_t corbWp = HDA_REG(pThis, CORBWP);
1573 uint8_t rirbWp = HDA_REG(pThis, RIRBWP);
1574
1575 Assert((corbWp != corbRp));
1576 Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
1577
1578 while (corbRp != corbWp)
1579 {
1580 uint64_t uResp;
1581 uint32_t uCmd = pThis->pu32CorbBuf[++corbRp];
1582
1583 int rc2 = pThis->pCodec->pfnLookup(pThis->pCodec, HDA_CODEC_CMD(uCmd, 0 /* Codec index */), &uResp);
1584 if (RT_FAILURE(rc2))
1585 LogFunc(("Codec lookup failed with rc=%Rrc\n", rc2));
1586
1587 (rirbWp)++;
1588
1589 if ( (uResp & CODEC_RESPONSE_UNSOLICITED)
1590 && !HDA_REG_FLAG_VALUE(pThis, GCTL, UR))
1591 {
1592 LogFunc(("Unexpected unsolicited response\n"));
1593 HDA_REG(pThis, CORBRP) = corbRp;
1594 return rc;
1595 }
1596
1597 pThis->pu64RirbBuf[rirbWp] = uResp;
1598
1599 pThis->u8RespIntCnt++;
1600 if (pThis->u8RespIntCnt == RINTCNT_N(pThis))
1601 break;
1602 }
1603
1604 HDA_REG(pThis, CORBRP) = corbRp;
1605 HDA_REG(pThis, RIRBWP) = rirbWp;
1606
1607 rc = hdaCmdSync(pThis, false);
1608
1609 Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
1610
1611 if (HDA_REG_FLAG_VALUE(pThis, RIRBCTL, RIC))
1612 {
1613 HDA_REG(pThis, RIRBSTS) |= HDA_REG_FIELD_FLAG_MASK(RIRBSTS,RINTFL);
1614
1615 pThis->u8RespIntCnt = 0;
1616 rc = hdaProcessInterrupt(pThis);
1617 }
1618
1619 if (RT_FAILURE(rc))
1620 AssertRCReturn(rc, rc);
1621 return rc;
1622}
1623
1624static int hdaStreamCreate(PHDASTREAM pStream, uint8_t uSD)
1625{
1626 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1627 AssertReturn(uSD <= HDA_MAX_STREAMS, VERR_INVALID_PARAMETER);
1628
1629 int rc = RTSemEventCreate(&pStream->State.hStateChangedEvent);
1630 if (RT_SUCCESS(rc))
1631 rc = RTSemMutexCreate(&pStream->State.hMtx);
1632
1633 if (RT_SUCCESS(rc))
1634 {
1635 pStream->u8SD = uSD;
1636 pStream->pMixSink = NULL;
1637
1638 pStream->State.fActive = false;
1639 pStream->State.fInReset = false;
1640 pStream->State.fDoStop = false;
1641 }
1642
1643 LogFlowFunc(("uSD=%RU8\n", uSD));
1644 return rc;
1645}
1646
1647static void hdaStreamDestroy(PHDASTREAM pStream)
1648{
1649 AssertPtrReturnVoid(pStream);
1650
1651 LogFlowFunc(("[SD%RU8]: Destroying ...\n", pStream->u8SD));
1652
1653 int rc2 = hdaStreamStop(pStream);
1654 AssertRC(rc2);
1655
1656 hdaStreamMapDestroy(&pStream->State.Mapping);
1657
1658 if (pStream->State.hMtx != NIL_RTSEMMUTEX)
1659 {
1660 rc2 = RTSemMutexDestroy(pStream->State.hMtx);
1661 AssertRC(rc2);
1662 pStream->State.hMtx = NIL_RTSEMMUTEX;
1663 }
1664
1665 if (pStream->State.hStateChangedEvent != NIL_RTSEMEVENT)
1666 {
1667 rc2 = RTSemEventDestroy(pStream->State.hStateChangedEvent);
1668 AssertRC(rc2);
1669 pStream->State.hStateChangedEvent = NIL_RTSEMEVENT;
1670 }
1671
1672 LogFlowFuncLeave();
1673}
1674
1675static int hdaStreamInit(PHDASTATE pThis, PHDASTREAM pStream, uint8_t u8SD)
1676{
1677 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1678 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1679
1680 pStream->u8SD = u8SD;
1681 pStream->u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStream->u8SD),
1682 HDA_STREAM_REG(pThis, BDPU, pStream->u8SD));
1683 pStream->u16LVI = HDA_STREAM_REG(pThis, LVI, pStream->u8SD);
1684 pStream->u32CBL = HDA_STREAM_REG(pThis, CBL, pStream->u8SD);
1685 pStream->u16FIFOS = hdaSDFIFOSToBytes(HDA_STREAM_REG(pThis, FIFOS, pStream->u8SD));
1686
1687 RT_ZERO(pStream->State.BDLE);
1688 pStream->State.uCurBDLE = 0;
1689
1690 hdaStreamMapReset(&pStream->State.Mapping);
1691
1692 LogFlowFunc(("[SD%RU8]: DMA @ 0x%x (%RU32 bytes), LVI=%RU16, FIFOS=%RU16\n",
1693 pStream->u8SD, pStream->u64BDLBase, pStream->u32CBL, pStream->u16LVI, pStream->u16FIFOS));
1694
1695#ifdef DEBUG
1696 uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStream->u8SD),
1697 HDA_STREAM_REG(pThis, BDPU, pStream->u8SD));
1698 uint16_t u16LVI = HDA_STREAM_REG(pThis, LVI, pStream->u8SD);
1699 uint32_t u32CBL = HDA_STREAM_REG(pThis, CBL, pStream->u8SD);
1700
1701 LogFlowFunc(("\t-> DMA @ 0x%x, LVI=%RU16, CBL=%RU32\n", u64BaseDMA, u16LVI, u32CBL));
1702
1703 hdaBDLEDumpAll(pThis, u64BaseDMA, u16LVI + 1);
1704#endif
1705
1706 return VINF_SUCCESS;
1707}
1708
1709static void hdaStreamReset(PHDASTATE pThis, PHDASTREAM pStream)
1710{
1711 AssertPtrReturnVoid(pThis);
1712 AssertPtrReturnVoid(pStream);
1713
1714 const uint8_t uSD = pStream->u8SD;
1715
1716#ifdef VBOX_STRICT
1717 AssertReleaseMsg(!RT_BOOL(HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
1718 ("[SD%RU8] Cannot reset stream while in running state\n", uSD));
1719#endif
1720
1721 LogFunc(("[SD%RU8]: Reset\n", uSD));
1722
1723 /*
1724 * Set reset state.
1725 */
1726 Assert(ASMAtomicReadBool(&pStream->State.fInReset) == false); /* No nested calls. */
1727 ASMAtomicXchgBool(&pStream->State.fInReset, true);
1728
1729 /*
1730 * First, reset the internal stream state.
1731 */
1732 RT_ZERO(pStream->State.BDLE);
1733 pStream->State.uCurBDLE = 0;
1734
1735 /*
1736 * Second, initialize the registers.
1737 */
1738 HDA_STREAM_REG(pThis, STS, uSD) = HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
1739 /* According to the ICH6 datasheet, 0x40000 is the default value for stream descriptor register 23:20
1740 * bits are reserved for stream number 18.2.33, resets SDnCTL except SRST bit. */
1741 HDA_STREAM_REG(pThis, CTL, uSD) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
1742 /* ICH6 defines default values (0x77 for input and 0xBF for output descriptors) of FIFO size. 18.2.39. */
1743 HDA_STREAM_REG(pThis, FIFOS, uSD) = hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN ? HDA_SDIFIFO_120B : HDA_SDOFIFO_192B;
1744 /* See 18.2.38: Always defaults to 0x4 (32 bytes). */
1745 HDA_STREAM_REG(pThis, FIFOW, uSD) = HDA_SDFIFOW_32B;
1746 HDA_STREAM_REG(pThis, LPIB, uSD) = 0;
1747 HDA_STREAM_REG(pThis, CBL, uSD) = 0;
1748 HDA_STREAM_REG(pThis, LVI, uSD) = 0;
1749 HDA_STREAM_REG(pThis, FMT, uSD) = HDA_SDFMT_MAKE(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
1750 HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_1X, HDA_SDFMT_16_BIT,
1751 HDA_SDFMT_CHAN_STEREO);
1752 HDA_STREAM_REG(pThis, BDPU, uSD) = 0;
1753 HDA_STREAM_REG(pThis, BDPL, uSD) = 0;
1754
1755 int rc2 = hdaStreamInit(pThis, pStream, uSD);
1756 AssertRC(rc2);
1757
1758 /* Report that we're done resetting this stream. */
1759 HDA_STREAM_REG(pThis, CTL, uSD) = 0;
1760
1761 /* Exit reset state. */
1762 ASMAtomicXchgBool(&pStream->State.fInReset, false);
1763}
1764
1765static bool hdaStreamIsActive(PHDASTATE pThis, PHDASTREAM pStream)
1766{
1767 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1768 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1769
1770 bool fActive = pStream->State.fActive;
1771
1772 if (!fActive)
1773 {
1774 AssertPtr(pStream->pMixSink);
1775 if (pStream->pMixSink->pMixSink)
1776 fActive = AudioMixerSinkGetStatus(pStream->pMixSink->pMixSink) & AUDMIXSINK_STS_DIRTY;
1777 }
1778
1779 LogFlowFunc(("SD=%RU8, fActive=%RTbool\n", pStream->u8SD, fActive));
1780 return fActive;
1781}
1782
1783static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive)
1784{
1785 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1786 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1787
1788 if (!pStream->pMixSink) /* No mixer sink assigned? Bail out early. */
1789 {
1790 LogFlowFunc(("u8Strm=%RU8 has no mixer sink assigned\n", pStream->u8SD));
1791 return VINF_SUCCESS;
1792 }
1793
1794 AUDMIXSINKCMD enmCmd = fActive
1795 ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
1796
1797 /* First, enable or disable the stream and the stream's sink, if any. */
1798 if (pStream->pMixSink->pMixSink)
1799 AudioMixerSinkCtl(pStream->pMixSink->pMixSink, enmCmd);
1800
1801 pStream->State.fActive = fActive;
1802
1803 /* Second, see if we need to start or stop the timer. */
1804 if (!fActive)
1805 {
1806 if (pThis->cStreamsActive) /* Disable can be called mupltiple times. */
1807 pThis->cStreamsActive--;
1808
1809#ifndef VBOX_WITH_AUDIO_CALLBACKS
1810 hdaTimerMaybeStop(pThis);
1811#endif
1812 }
1813 else
1814 {
1815 pThis->cStreamsActive++;
1816#ifndef VBOX_WITH_AUDIO_CALLBACKS
1817 hdaTimerMaybeStart(pThis);
1818#endif
1819 }
1820
1821 LogFlowFunc(("u8Strm=%RU8, fActive=%RTbool, cStreamsActive=%RU8\n", pStream->u8SD, fActive, pThis->cStreamsActive));
1822 return VINF_SUCCESS;
1823}
1824
1825static void hdaStreamAssignToSink(PHDASTREAM pStream, PHDAMIXERSINK pMixSink)
1826{
1827 AssertPtrReturnVoid(pStream);
1828
1829 int rc2 = RTSemMutexRequest(pStream->State.hMtx, RT_INDEFINITE_WAIT);
1830 if (RT_SUCCESS(rc2))
1831 {
1832 pStream->pMixSink = pMixSink;
1833
1834 rc2 = RTSemMutexRelease(pStream->State.hMtx);
1835 AssertRC(rc2);
1836 }
1837}
1838
1839static int hdaStreamStart(PHDASTREAM pStream)
1840{
1841 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1842
1843 ASMAtomicXchgBool(&pStream->State.fDoStop, false);
1844 ASMAtomicXchgBool(&pStream->State.fActive, true);
1845
1846 LogFlowFuncLeave();
1847 return VINF_SUCCESS;
1848}
1849
1850static int hdaStreamStop(PHDASTREAM pStream)
1851{
1852 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1853
1854 /* Already in stopped state? */
1855 bool fActive = ASMAtomicReadBool(&pStream->State.fActive);
1856 if (!fActive)
1857 return VINF_SUCCESS;
1858
1859#if 0 /** @todo Does not work (yet), as EMT deadlocks then. */
1860 /*
1861 * Wait for the stream to stop.
1862 */
1863 ASMAtomicXchgBool(&pStream->State.fDoStop, true);
1864
1865 int rc = hdaStreamWaitForStateChange(pStream, 60 * 1000 /* ms timeout */);
1866 fActive = ASMAtomicReadBool(&pStream->State.fActive);
1867 if ( /* Waiting failed? */
1868 RT_FAILURE(rc)
1869 /* Stream is still active? */
1870 || fActive)
1871 {
1872 AssertRC(rc);
1873 LogRel(("HDA: Warning: Unable to stop stream %RU8 (state: %s), rc=%Rrc\n",
1874 pStream->u8Strm, fActive ? "active" : "stopped", rc));
1875 }
1876#else
1877 int rc = VINF_SUCCESS;
1878#endif
1879
1880 LogFlowFuncLeaveRC(rc);
1881 return rc;
1882}
1883
1884static int hdaStreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf)
1885{
1886 AssertPtrReturn(pChan, VERR_INVALID_POINTER);
1887 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1888 AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1889
1890 AssertRelease(pChan->cbOff <= cbBuf);
1891
1892 const uint8_t *pu8Buf = (const uint8_t *)pvBuf;
1893
1894 size_t cbSrc = cbBuf - pChan->cbOff;
1895 const uint8_t *pvSrc = &pu8Buf[pChan->cbOff];
1896
1897 size_t cbDst;
1898 uint8_t *pvDst;
1899 RTCircBufAcquireWriteBlock(pChan->Data.pCircBuf, cbBuf, (void **)&pvDst, &cbDst);
1900
1901 cbSrc = RT_MIN(cbSrc, cbDst);
1902
1903 while (cbSrc)
1904 {
1905 AssertBreak(cbDst >= cbSrc);
1906
1907 /* Enough data for at least one next frame? */
1908 if (cbSrc < pChan->cbFrame)
1909 break;
1910
1911 memcpy(pvDst, pvSrc, pChan->cbFrame);
1912
1913 /* Advance to next channel frame in stream. */
1914 pvSrc += pChan->cbStep;
1915 Assert(cbSrc >= pChan->cbStep);
1916 cbSrc -= pChan->cbStep;
1917
1918 /* Advance destination by one frame. */
1919 pvDst += pChan->cbFrame;
1920 Assert(cbDst >= pChan->cbFrame);
1921 cbDst -= pChan->cbFrame;
1922
1923 /* Adjust offset. */
1924 pChan->cbOff += pChan->cbFrame;
1925 }
1926
1927 RTCircBufReleaseWriteBlock(pChan->Data.pCircBuf, cbDst);
1928
1929 return VINF_SUCCESS;
1930}
1931
1932static int hdaStreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv)
1933{
1934 AssertPtrReturn(pChan, VERR_INVALID_POINTER);
1935
1936 if (!cbAdv)
1937 return VINF_SUCCESS;
1938
1939 return VINF_SUCCESS;
1940}
1941
1942static int hdaStreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags)
1943{
1944 int rc = RTCircBufCreate(&pChanData->pCircBuf, 256); /** @todo Make this configurable? */
1945 if (RT_SUCCESS(rc))
1946 {
1947 pChanData->fFlags = fFlags;
1948 }
1949
1950 return rc;
1951}
1952
1953/**
1954 * Frees a stream channel data block again.
1955 *
1956 * @param pChanData Pointer to channel data to free.
1957 */
1958static void hdaStreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData)
1959{
1960 if (!pChanData)
1961 return;
1962
1963 if (pChanData->pCircBuf)
1964 {
1965 RTCircBufDestroy(pChanData->pCircBuf);
1966 pChanData->pCircBuf = NULL;
1967 }
1968
1969 pChanData->fFlags = PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE;
1970}
1971
1972static int hdaStreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void *pvData, size_t *pcbData)
1973{
1974 AssertPtrReturn(pChanData, VERR_INVALID_POINTER);
1975 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1976 AssertPtrReturn(pcbData, VERR_INVALID_POINTER);
1977
1978 RTCircBufAcquireReadBlock(pChanData->pCircBuf, 256 /** @todo Make this configurarble? */, &pvData, &pChanData->cbAcq);
1979
1980 *pcbData = pChanData->cbAcq;
1981 return VINF_SUCCESS;
1982}
1983
1984static int hdaStreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData)
1985{
1986 AssertPtrReturn(pChanData, VERR_INVALID_POINTER);
1987 RTCircBufReleaseReadBlock(pChanData->pCircBuf, pChanData->cbAcq);
1988
1989 return VINF_SUCCESS;
1990}
1991
1992static int hdaStreamWaitForStateChange(PHDASTREAM pStream, RTMSINTERVAL msTimeout)
1993{
1994 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1995
1996 LogFlowFunc(("[SD%RU8]: msTimeout=%RU32\n", pStream->u8SD, msTimeout));
1997 return RTSemEventWait(pStream->State.hStateChangedEvent, msTimeout);
1998}
1999#endif /* IN_RING3 */
2000
2001/* Register access handlers. */
2002
2003static int hdaRegReadUnimpl(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2004{
2005 *pu32Value = 0;
2006 return VINF_SUCCESS;
2007}
2008
2009static int hdaRegWriteUnimpl(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2010{
2011 return VINF_SUCCESS;
2012}
2013
2014/* U8 */
2015static int hdaRegReadU8(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2016{
2017 Assert(((pThis->au32Regs[g_aHdaRegMap[iReg].mem_idx] & g_aHdaRegMap[iReg].readable) & 0xffffff00) == 0);
2018 return hdaRegReadU32(pThis, iReg, pu32Value);
2019}
2020
2021static int hdaRegWriteU8(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2022{
2023 Assert((u32Value & 0xffffff00) == 0);
2024 return hdaRegWriteU32(pThis, iReg, u32Value);
2025}
2026
2027/* U16 */
2028static int hdaRegReadU16(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2029{
2030 Assert(((pThis->au32Regs[g_aHdaRegMap[iReg].mem_idx] & g_aHdaRegMap[iReg].readable) & 0xffff0000) == 0);
2031 return hdaRegReadU32(pThis, iReg, pu32Value);
2032}
2033
2034static int hdaRegWriteU16(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2035{
2036 Assert((u32Value & 0xffff0000) == 0);
2037 return hdaRegWriteU32(pThis, iReg, u32Value);
2038}
2039
2040/* U24 */
2041static int hdaRegReadU24(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2042{
2043 Assert(((pThis->au32Regs[g_aHdaRegMap[iReg].mem_idx] & g_aHdaRegMap[iReg].readable) & 0xff000000) == 0);
2044 return hdaRegReadU32(pThis, iReg, pu32Value);
2045}
2046
2047static int hdaRegWriteU24(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2048{
2049 Assert((u32Value & 0xff000000) == 0);
2050 return hdaRegWriteU32(pThis, iReg, u32Value);
2051}
2052
2053/* U32 */
2054static int hdaRegReadU32(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2055{
2056 uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
2057
2058 *pu32Value = pThis->au32Regs[iRegMem] & g_aHdaRegMap[iReg].readable;
2059 return VINF_SUCCESS;
2060}
2061
2062static int hdaRegWriteU32(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2063{
2064 uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
2065
2066 pThis->au32Regs[iRegMem] = (u32Value & g_aHdaRegMap[iReg].writable)
2067 | (pThis->au32Regs[iRegMem] & ~g_aHdaRegMap[iReg].writable);
2068 return VINF_SUCCESS;
2069}
2070
2071static int hdaRegWriteGCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2072{
2073 if (u32Value & HDA_REG_FIELD_FLAG_MASK(GCTL, RST))
2074 {
2075 /* Set the CRST bit to indicate that we're leaving reset mode. */
2076 HDA_REG(pThis, GCTL) |= HDA_REG_FIELD_FLAG_MASK(GCTL, RST);
2077
2078 if (pThis->fInReset)
2079 {
2080 LogFunc(("Guest leaving HDA reset\n"));
2081 pThis->fInReset = false;
2082 }
2083 }
2084 else
2085 {
2086#ifdef IN_RING3
2087 /* Enter reset state. */
2088 LogFunc(("Guest entering HDA reset with DMA(RIRB:%s, CORB:%s)\n",
2089 HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA) ? "on" : "off",
2090 HDA_REG_FLAG_VALUE(pThis, RIRBCTL, DMA) ? "on" : "off"));
2091
2092 /* Clear the CRST bit to indicate that we're in reset state. */
2093 HDA_REG(pThis, GCTL) &= ~HDA_REG_FIELD_FLAG_MASK(GCTL, RST);
2094 pThis->fInReset = true;
2095
2096 hdaReset(pThis->CTX_SUFF(pDevIns));
2097#else
2098 return VINF_IOM_R3_MMIO_WRITE;
2099#endif
2100 }
2101
2102 if (u32Value & HDA_REG_FIELD_FLAG_MASK(GCTL, FSH))
2103 {
2104 /* Flush: GSTS:1 set, see 6.2.6. */
2105 HDA_REG(pThis, GSTS) |= HDA_REG_FIELD_FLAG_MASK(GSTS, FSH); /* Set the flush state. */
2106 /* DPLBASE and DPUBASE should be initialized with initial value (see 6.2.6). */
2107 }
2108 return VINF_SUCCESS;
2109}
2110
2111static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2112{
2113 uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
2114
2115 uint32_t v = pThis->au32Regs[iRegMem];
2116 uint32_t nv = u32Value & HDA_STATES_SCSF;
2117 pThis->au32Regs[iRegMem] &= ~(v & nv); /* write of 1 clears corresponding bit */
2118 return VINF_SUCCESS;
2119}
2120
2121static int hdaRegReadINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2122{
2123 uint32_t v = 0;
2124 if ( HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
2125 || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
2126 || HDA_REG_FLAG_VALUE(pThis, CORBSTS, CMEI)
2127 || HDA_REG(pThis, STATESTS))
2128 {
2129 v |= RT_BIT(30); /* Touch CIS. */
2130 }
2131
2132#define HDA_MARK_STREAM(x) \
2133 if (/* Descriptor Error */ \
2134 (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE)) \
2135 /* FIFO Error */ \
2136 || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE)) \
2137 /* Buffer Completion Interrupt Status */ \
2138 || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS))) \
2139 { \
2140 Log3Func(("[SD%RU8] BCIS: Marked\n", x)); \
2141 v |= RT_BIT(x); \
2142 }
2143
2144 HDA_MARK_STREAM(0);
2145 HDA_MARK_STREAM(1);
2146 HDA_MARK_STREAM(2);
2147 HDA_MARK_STREAM(3);
2148 HDA_MARK_STREAM(4);
2149 HDA_MARK_STREAM(5);
2150 HDA_MARK_STREAM(6);
2151 HDA_MARK_STREAM(7);
2152
2153#undef HDA_MARK_STREAM
2154
2155 /* "OR" bit of all interrupt status bits. */
2156 v |= v ? RT_BIT(31) : 0;
2157
2158 *pu32Value = v;
2159 return VINF_SUCCESS;
2160}
2161
2162static int hdaRegReadLPIB(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2163{
2164 const uint8_t u8Strm = HDA_SD_NUM_FROM_REG(pThis, LPIB, iReg);
2165 uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, u8Strm);
2166 const uint32_t u32CBL = HDA_STREAM_REG(pThis, CBL, u8Strm);
2167
2168 LogFlowFunc(("[SD%RU8]: LPIB=%RU32, CBL=%RU32\n", u8Strm, u32LPIB, u32CBL));
2169
2170 *pu32Value = u32LPIB;
2171 return VINF_SUCCESS;
2172}
2173
2174static int hdaRegReadWALCLK(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2175{
2176 /* HDA spec (1a): 3.3.16 WALCLK counter ticks with 24Mhz bitclock rate. */
2177 *pu32Value = (uint32_t)ASMMultU64ByU32DivByU32(PDMDevHlpTMTimeVirtGetNano(pThis->CTX_SUFF(pDevIns))
2178 - pThis->u64BaseTS, 24, 1000);
2179 LogFlowFunc(("%RU32\n", *pu32Value));
2180 return VINF_SUCCESS;
2181}
2182
2183static int hdaRegReadSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2184{
2185 /* HDA spec (1a): 3.3.16 WALCLK counter ticks with 24Mhz bitclock rate. */
2186 *pu32Value = HDA_REG(pThis, SSYNC);
2187 LogFlowFunc(("%RU32\n", *pu32Value));
2188 return VINF_SUCCESS;
2189}
2190
2191static int hdaRegWriteSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2192{
2193 LogFlowFunc(("%RU32\n", u32Value));
2194 return hdaRegWriteU32(pThis, iReg, u32Value);
2195}
2196
2197static int hdaRegWriteCORBRP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2198{
2199 if (u32Value & HDA_REG_FIELD_FLAG_MASK(CORBRP, RST))
2200 {
2201 HDA_REG(pThis, CORBRP) = 0;
2202 }
2203#ifndef BIRD_THINKS_CORBRP_IS_MOSTLY_RO
2204 else
2205 return hdaRegWriteU8(pThis, iReg, u32Value);
2206#endif
2207 return VINF_SUCCESS;
2208}
2209
2210static int hdaRegWriteCORBCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2211{
2212#ifdef IN_RING3
2213 int rc = hdaRegWriteU8(pThis, iReg, u32Value);
2214 AssertRC(rc);
2215 if ( HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP)
2216 && HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA) != 0)
2217 {
2218 return hdaCORBCmdProcess(pThis);
2219 }
2220 return rc;
2221#else
2222 return VINF_IOM_R3_MMIO_WRITE;
2223#endif
2224}
2225
2226static int hdaRegWriteCORBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2227{
2228 uint32_t v = HDA_REG(pThis, CORBSTS);
2229 HDA_REG(pThis, CORBSTS) &= ~(v & u32Value);
2230 return VINF_SUCCESS;
2231}
2232
2233static int hdaRegWriteCORBWP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2234{
2235#ifdef IN_RING3
2236 int rc;
2237 rc = hdaRegWriteU16(pThis, iReg, u32Value);
2238 if (RT_FAILURE(rc))
2239 AssertRCReturn(rc, rc);
2240 if (HDA_REG(pThis, CORBWP) == HDA_REG(pThis, CORBRP))
2241 return VINF_SUCCESS;
2242 if (!HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA))
2243 return VINF_SUCCESS;
2244 rc = hdaCORBCmdProcess(pThis);
2245 return rc;
2246#else /* !IN_RING3 */
2247 return VINF_IOM_R3_MMIO_WRITE;
2248#endif /* IN_RING3 */
2249}
2250
2251static int hdaRegWriteSDCBL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2252{
2253#ifdef IN_RING3
2254 if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
2255 return VINF_SUCCESS;
2256
2257 PHDASTREAM pStream = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, CBL, iReg));
2258 if (!pStream)
2259 {
2260 LogFunc(("[SD%RU8]: Warning: Changing SDCBL on non-attached stream (0x%x)\n", HDA_SD_NUM_FROM_REG(pThis, CTL, iReg), u32Value));
2261 return hdaRegWriteU32(pThis, iReg, u32Value);
2262 }
2263
2264 int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
2265 AssertRC(rc2);
2266
2267 pStream->u32CBL = u32Value;
2268
2269 /* Reset BDLE state. */
2270 RT_ZERO(pStream->State.BDLE);
2271 pStream->State.uCurBDLE = 0;
2272
2273 rc2 = hdaRegWriteU32(pThis, iReg, u32Value);
2274 AssertRC(rc2);
2275
2276 LogFlowFunc(("[SD%RU8]: CBL=%RU32\n", pStream->u8SD, u32Value));
2277 hdaRegWriteSDUnlock(pStream);
2278
2279 return VINF_SUCCESS; /* Always return success to the MMIO handler. */
2280#else /* !IN_RING3 */
2281 return VINF_IOM_R3_MMIO_WRITE;
2282#endif /* IN_RING3 */
2283}
2284
2285static int hdaRegWriteSDCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2286{
2287 bool fRun = RT_BOOL(u32Value & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
2288 bool fInRun = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
2289 bool fReset = RT_BOOL(u32Value & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
2290 bool fInReset = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
2291
2292 if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
2293 return VINF_SUCCESS;
2294
2295 /* Get the stream descriptor. */
2296 uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, CTL, iReg);
2297
2298 /*
2299 * Extract the stream tag the guest wants to use for this specific
2300 * stream descriptor (SDn). This only can happen if the stream is in a non-running
2301 * state, so we're doing the lookup and assignment here.
2302 *
2303 * So depending on the guest OS, SD3 can use stream tag 4, for example.
2304 */
2305 uint8_t uTag = (u32Value >> HDA_SDCTL_NUM_SHIFT) & HDA_SDCTL_NUM_MASK;
2306 if (uTag > HDA_MAX_TAGS)
2307 {
2308 LogFunc(("[SD%RU8]: Warning: Invalid stream tag %RU8 specified!\n", uSD, uTag));
2309 return hdaRegWriteU24(pThis, iReg, u32Value);
2310 }
2311
2312#ifdef IN_RING3
2313 PHDATAG pTag = &pThis->aTags[uTag];
2314 AssertPtr(pTag);
2315
2316 LogFunc(("[SD%RU8]: Using stream tag=%RU8\n", uSD, uTag));
2317
2318 /* Assign new values. */
2319 pTag->uTag = uTag;
2320 pTag->pStrm = hdaStreamFromSD(pThis, uSD);
2321
2322 PHDASTREAM pStream = pTag->pStrm;
2323 AssertPtr(pStream);
2324
2325 /* Note: Do not use hdaRegWriteSDLock() here, as SDnCTL might change the RUN bit. */
2326 int rc2 = RTSemMutexRequest(pStream->State.hMtx, RT_INDEFINITE_WAIT);
2327 AssertRC(rc2);
2328#endif /* IN_RING3 */
2329
2330 LogFunc(("[SD%RU8]: fRun=%RTbool, fInRun=%RTbool, fReset=%RTbool, fInReset=%RTbool, %R[sdctl]\n",
2331 uSD, fRun, fInRun, fReset, fInReset, u32Value));
2332
2333 if (fInReset)
2334 {
2335 Assert(!fReset);
2336 Assert(!fInRun && !fRun);
2337
2338 /* Report that we're done resetting this stream by clearing SRST. */
2339 HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST);
2340
2341 LogFunc(("[SD%RU8]: Guest initiated exit of stream reset\n", uSD));
2342 }
2343 else if (fReset)
2344 {
2345#ifdef IN_RING3
2346 /* ICH6 datasheet 18.2.33 says that RUN bit should be cleared before initiation of reset. */
2347 Assert(!fInRun && !fRun);
2348
2349 LogFunc(("[SD%RU8]: Guest initiated enter to stream reset\n", pStream->u8SD));
2350 hdaStreamReset(pThis, pStream);
2351#endif
2352 }
2353 else
2354 {
2355#ifdef IN_RING3
2356 /*
2357 * We enter here to change DMA states only.
2358 */
2359 if (fInRun != fRun)
2360 {
2361 Assert(!fReset && !fInReset);
2362 LogFunc(("[SD%RU8]: fRun=%RTbool\n", pStream->u8SD, fRun));
2363
2364 hdaStreamSetActive(pThis, pStream, fRun);
2365
2366 if (fRun)
2367 {
2368 /* (Re-)Fetch the current BDLE entry. */
2369 rc2 = hdaBDLEFetch(pThis, &pStream->State.BDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
2370 AssertRC(rc2);
2371 }
2372 }
2373
2374 if (!fInRun && !fRun)
2375 hdaStreamInit(pThis, pStream, pStream->u8SD);
2376#endif /* IN_RING3 */
2377 }
2378
2379 /* Make sure to handle interrupts here as well. */
2380 hdaProcessInterrupt(pThis);
2381
2382#ifdef IN_RING3
2383 rc2 = hdaRegWriteU24(pThis, iReg, u32Value);
2384 AssertRC(rc2);
2385
2386 hdaRegWriteSDUnlock(pStream);
2387 return VINF_SUCCESS; /* Always return success to the MMIO handler. */
2388#else
2389 return VINF_IOM_R3_MMIO_WRITE;
2390#endif
2391}
2392
2393static int hdaRegWriteSDSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2394{
2395 uint32_t v = HDA_REG_IND(pThis, iReg);
2396 /* Clear (zero) FIFOE and DESE bits when writing 1 to it. */
2397 v &= ~(u32Value & v);
2398
2399 HDA_REG_IND(pThis, iReg) = v;
2400
2401 hdaProcessInterrupt(pThis);
2402 return VINF_SUCCESS;
2403}
2404
2405static int hdaRegWriteSDLVI(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2406{
2407#ifdef IN_RING3
2408 if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
2409 return VINF_SUCCESS;
2410
2411 PHDASTREAM pStream = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, LVI, iReg));
2412 if (!pStream)
2413 {
2414 LogFunc(("[SD%RU8]: Warning: Changing SDLVI on non-attached stream (0x%x)\n", HDA_SD_NUM_FROM_REG(pThis, CTL, iReg), u32Value));
2415 return hdaRegWriteU16(pThis, iReg, u32Value);
2416 }
2417
2418 int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
2419 AssertRC(rc2);
2420
2421 /** @todo Validate LVI. */
2422 pStream->u16LVI = u32Value;
2423
2424 /* Reset BDLE state. */
2425 RT_ZERO(pStream->State.BDLE);
2426 pStream->State.uCurBDLE = 0;
2427
2428 rc2 = hdaRegWriteU16(pThis, iReg, u32Value);
2429 AssertRC(rc2);
2430
2431 LogFlowFunc(("[SD%RU8]: LVI=%RU32\n", pStream->u8SD, u32Value));
2432 hdaRegWriteSDUnlock(pStream);
2433
2434 return VINF_SUCCESS; /* Always return success to the MMIO handler. */
2435#else /* !IN_RING3 */
2436 return VINF_IOM_R3_MMIO_WRITE;
2437#endif /* IN_RING3 */
2438}
2439
2440static int hdaRegWriteSDFIFOW(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2441{
2442 uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
2443 /** @todo Only allow updating FIFOS if RUN bit is 0? */
2444 uint32_t u32FIFOW = 0;
2445
2446 if (hdaGetDirFromSD(uSD) != PDMAUDIODIR_IN) /* FIFOW for input streams only. */
2447 {
2448 LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to stream #%RU8, ignoring\n", uSD));
2449 return VINF_SUCCESS;
2450 }
2451
2452 switch (u32Value)
2453 {
2454 case HDA_SDFIFOW_8B:
2455 case HDA_SDFIFOW_16B:
2456 case HDA_SDFIFOW_32B:
2457 u32FIFOW = u32Value;
2458 break;
2459 default:
2460 LogRel(("HDA: Warning: Guest tried write unsupported FIFOW (0x%x) to stream #%RU8, defaulting to 32 bytes\n",
2461 u32Value, uSD));
2462 u32FIFOW = HDA_SDFIFOW_32B;
2463 break;
2464 }
2465
2466 if (u32FIFOW)
2467 {
2468 LogFunc(("[SD%RU8]: Updating FIFOW to %RU32 bytes\n", uSD, hdaSDFIFOSToBytes(u32FIFOW)));
2469 /** @todo Update internal stream state with new FIFOS. */
2470
2471 return hdaRegWriteU16(pThis, iReg, u32FIFOW);
2472 }
2473
2474 return VINF_SUCCESS; /* Never reached. */
2475}
2476
2477/**
2478 * @note This method could be called for changing value on Output Streams
2479 * only (ICH6 datasheet 18.2.39).
2480 */
2481static int hdaRegWriteSDFIFOS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2482{
2483 uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg);
2484 /** @todo Only allow updating FIFOS if RUN bit is 0? */
2485 uint32_t u32FIFOS = 0;
2486
2487 if (hdaGetDirFromSD(uSD) != PDMAUDIODIR_OUT) /* FIFOS for output streams only. */
2488 {
2489 LogRel(("HDA: Warning: Guest tried to write read-only FIFOS to stream #%RU8, ignoring\n", uSD));
2490 return VINF_SUCCESS;
2491 }
2492
2493 switch(u32Value)
2494 {
2495 case HDA_SDOFIFO_16B:
2496 case HDA_SDOFIFO_32B:
2497 case HDA_SDOFIFO_64B:
2498 case HDA_SDOFIFO_128B:
2499 case HDA_SDOFIFO_192B:
2500 u32FIFOS = u32Value;
2501 break;
2502
2503 case HDA_SDOFIFO_256B: /** @todo r=andy Investigate this. */
2504 LogFunc(("256-bit is unsupported, HDA is switched into 192-bit mode\n"));
2505 /* Fall through is intentional. */
2506 default:
2507 LogRel(("HDA: Warning: Guest tried write unsupported FIFOS (0x%x) to stream #%RU8, defaulting to 192 bytes\n",
2508 u32Value, uSD));
2509 u32FIFOS = HDA_SDOFIFO_192B;
2510 break;
2511 }
2512
2513 if (u32FIFOS)
2514 {
2515 LogFunc(("[SD%RU8]: Updating FIFOS to %RU32 bytes\n",
2516 HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg), hdaSDFIFOSToBytes(u32FIFOS)));
2517 /** @todo Update internal stream state with new FIFOS. */
2518
2519 return hdaRegWriteU16(pThis, iReg, u32FIFOS);
2520 }
2521
2522 return VINF_SUCCESS;
2523}
2524
2525#ifdef IN_RING3
2526static int hdaSDFMTToStrmCfg(uint32_t u32SDFMT, PPDMAUDIOSTREAMCFG pStrmCfg)
2527{
2528 AssertPtrReturn(pStrmCfg, VERR_INVALID_POINTER);
2529
2530# define EXTRACT_VALUE(v, mask, shift) ((v & ((mask) << (shift))) >> (shift))
2531
2532 int rc = VINF_SUCCESS;
2533
2534 uint32_t u32Hz = EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_BASE_RATE_MASK, HDA_SDFMT_BASE_RATE_SHIFT)
2535 ? 44100 : 48000;
2536 uint32_t u32HzMult = 1;
2537 uint32_t u32HzDiv = 1;
2538
2539 switch (EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_MULT_MASK, HDA_SDFMT_MULT_SHIFT))
2540 {
2541 case 0: u32HzMult = 1; break;
2542 case 1: u32HzMult = 2; break;
2543 case 2: u32HzMult = 3; break;
2544 case 3: u32HzMult = 4; break;
2545 default:
2546 LogFunc(("Unsupported multiplier %x\n",
2547 EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_MULT_MASK, HDA_SDFMT_MULT_SHIFT)));
2548 rc = VERR_NOT_SUPPORTED;
2549 break;
2550 }
2551 switch (EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_DIV_MASK, HDA_SDFMT_DIV_SHIFT))
2552 {
2553 case 0: u32HzDiv = 1; break;
2554 case 1: u32HzDiv = 2; break;
2555 case 2: u32HzDiv = 3; break;
2556 case 3: u32HzDiv = 4; break;
2557 case 4: u32HzDiv = 5; break;
2558 case 5: u32HzDiv = 6; break;
2559 case 6: u32HzDiv = 7; break;
2560 case 7: u32HzDiv = 8; break;
2561 default:
2562 LogFunc(("Unsupported divisor %x\n",
2563 EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_DIV_MASK, HDA_SDFMT_DIV_SHIFT)));
2564 rc = VERR_NOT_SUPPORTED;
2565 break;
2566 }
2567
2568 PDMAUDIOFMT enmFmt;
2569 switch (EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_BITS_MASK, HDA_SDFMT_BITS_SHIFT))
2570 {
2571 case 0:
2572 enmFmt = PDMAUDIOFMT_S8;
2573 break;
2574 case 1:
2575 enmFmt = PDMAUDIOFMT_S16;
2576 break;
2577 case 4:
2578 enmFmt = PDMAUDIOFMT_S32;
2579 break;
2580 default:
2581 AssertMsgFailed(("Unsupported bits per sample %x\n",
2582 EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_BITS_MASK, HDA_SDFMT_BITS_SHIFT)));
2583 rc = VERR_NOT_SUPPORTED;
2584 break;
2585 }
2586
2587 if (RT_SUCCESS(rc))
2588 {
2589 pStrmCfg->uHz = u32Hz * u32HzMult / u32HzDiv;
2590 pStrmCfg->cChannels = (u32SDFMT & 0xf) + 1;
2591 pStrmCfg->enmFormat = enmFmt;
2592 pStrmCfg->enmEndianness = PDMAUDIOHOSTENDIANNESS;
2593 }
2594
2595# undef EXTRACT_VALUE
2596 return rc;
2597}
2598
2599static int hdaAddStreamOut(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
2600{
2601 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2602 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2603
2604 AssertReturn(pCfg->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
2605
2606 LogFlowFunc(("Stream=%s\n", pCfg->szName));
2607
2608 int rc = VINF_SUCCESS;
2609
2610 bool fUseFront = true; /* Always use front out by default. */
2611#ifdef VBOX_WITH_HDA_51_SURROUND
2612 bool fUseRear;
2613 bool fUseCenter;
2614 bool fUseLFE;
2615
2616 fUseRear = fUseCenter = fUseLFE = false;
2617
2618 /*
2619 * Use commonly used setups for speaker configurations.
2620 */
2621
2622 /** @todo Make the following configurable through mixer API and/or CFGM? */
2623 switch (pCfg->cChannels)
2624 {
2625 case 3: /* 2.1: Front (Stereo) + LFE. */
2626 {
2627 fUseLFE = true;
2628 break;
2629 }
2630
2631 case 4: /* Quadrophonic: Front (Stereo) + Rear (Stereo). */
2632 {
2633 fUseRear = true;
2634 break;
2635 }
2636
2637 case 5: /* 4.1: Front (Stereo) + Rear (Stereo) + LFE. */
2638 {
2639 fUseRear = true;
2640 fUseLFE = true;
2641 break;
2642 }
2643
2644 case 6: /* 5.1: Front (Stereo) + Rear (Stereo) + Center/LFE. */
2645 {
2646 fUseRear = true;
2647 fUseCenter = true;
2648 fUseLFE = true;
2649 break;
2650 }
2651
2652 default: /* Unknown; fall back to 2 front channels (stereo). */
2653 {
2654 rc = VERR_NOT_SUPPORTED;
2655 break;
2656 }
2657 }
2658#else /* !VBOX_WITH_HDA_51_SURROUND */
2659 /* Only support mono or stereo channels. */
2660 if ( pCfg->cChannels != 1 /* Mono */
2661 && pCfg->cChannels != 2 /* Stereo */)
2662 {
2663 rc = VERR_NOT_SUPPORTED;
2664 }
2665#endif
2666
2667 if (rc == VERR_NOT_SUPPORTED)
2668 {
2669 LogRel(("HDA: Unsupported channel count (%RU8), falling back to stereo channels\n", pCfg->cChannels));
2670 pCfg->cChannels = 2;
2671
2672 rc = VINF_SUCCESS;
2673 }
2674
2675 do
2676 {
2677 if (RT_FAILURE(rc))
2678 break;
2679
2680 if (fUseFront)
2681 {
2682 if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Front"))
2683 {
2684 rc = VERR_BUFFER_OVERFLOW;
2685 break;
2686 }
2687
2688 pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_FRONT;
2689 pCfg->cChannels = 2;
2690 rc = hdaCodecRemoveStream(pThis->pCodec, PDMAUDIOMIXERCTL_FRONT);
2691 if (RT_SUCCESS(rc))
2692 rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_FRONT, pCfg);
2693 }
2694
2695#ifdef VBOX_WITH_HDA_51_SURROUND
2696 if ( RT_SUCCESS(rc)
2697 && (fUseCenter || fUseLFE))
2698 {
2699 if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Center/LFE"))
2700 {
2701 rc = VERR_BUFFER_OVERFLOW;
2702 break;
2703 }
2704
2705 pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_CENTER_LFE;
2706 pCfg->cChannels = (fUseCenter && fUseLFE) ? 2 : 1;
2707 rc = hdaCodecRemoveStream(pThis->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE);
2708 if (RT_SUCCESS(rc))
2709 rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE, pCfg);
2710 }
2711
2712 if ( RT_SUCCESS(rc)
2713 && fUseRear)
2714 {
2715 if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Rear"))
2716 {
2717 rc = VERR_BUFFER_OVERFLOW;
2718 break;
2719 }
2720
2721 pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_REAR;
2722 pCfg->cChannels = 2;
2723 rc = hdaCodecRemoveStream(pThis->pCodec, PDMAUDIOMIXERCTL_REAR);
2724 if (RT_SUCCESS(rc))
2725 rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_REAR, pCfg);
2726 }
2727#endif /* VBOX_WITH_HDA_51_SURROUND */
2728
2729 } while (0);
2730
2731 LogFlowFuncLeaveRC(rc);
2732 return rc;
2733}
2734
2735static int hdaAddStreamIn(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
2736{
2737 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2738 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2739
2740 AssertReturn(pCfg->enmDir == PDMAUDIODIR_IN, VERR_INVALID_PARAMETER);
2741
2742 LogFlowFunc(("Stream=%s, Source=%ld\n", pCfg->szName, pCfg->DestSource.Source));
2743
2744 int rc;
2745
2746 switch (pCfg->DestSource.Source)
2747 {
2748 case PDMAUDIORECSOURCE_LINE:
2749 {
2750 rc = hdaCodecRemoveStream(pThis->pCodec, PDMAUDIOMIXERCTL_LINE_IN);
2751 if (RT_SUCCESS(rc))
2752 rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_LINE_IN, pCfg);
2753 break;
2754 }
2755#ifdef VBOX_WITH_HDA_MIC_IN
2756 case PDMAUDIORECSOURCE_MIC:
2757 {
2758 rc = hdaCodecRemoveStream(pThis->pCodec, PDMAUDIOMIXERCTL_MIC_IN);
2759 if (RT_SUCCESS(rc))
2760 rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_MIC_IN, pCfg);
2761 break;
2762 }
2763#endif
2764 default:
2765 rc = VERR_NOT_SUPPORTED;
2766 break;
2767 }
2768
2769 LogFlowFuncLeaveRC(rc);
2770 return rc;
2771}
2772#endif /* IN_RING3 */
2773
2774static int hdaRegWriteSDFMT(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2775{
2776#ifdef IN_RING3
2777 PDMAUDIOSTREAMCFG strmCfg;
2778 RT_ZERO(strmCfg);
2779
2780 int rc = hdaSDFMTToStrmCfg(u32Value, &strmCfg);
2781 if (RT_FAILURE(rc))
2782 return VINF_SUCCESS; /* Always return success to the MMIO handler. */
2783
2784 PHDASTREAM pStream = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, FMT, iReg));
2785 if (!pStream)
2786 {
2787 LogFunc(("[SD%RU8]: Warning: Changing SDFMT on non-attached stream (0x%x)\n",
2788 HDA_SD_NUM_FROM_REG(pThis, FMT, iReg), u32Value));
2789 return hdaRegWriteU16(pThis, iReg, u32Value);
2790 }
2791
2792 rc = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
2793 AssertRC(rc);
2794
2795 LogFunc(("[SD%RU8]: Hz=%RU32, Channels=%RU8, enmFmt=%RU32\n",
2796 pStream->u8SD, strmCfg.uHz, strmCfg.cChannels, strmCfg.enmFormat));
2797
2798 /* Set audio direction. */
2799 strmCfg.enmDir = hdaGetDirFromSD(pStream->u8SD);
2800 switch (strmCfg.enmDir)
2801 {
2802 case PDMAUDIODIR_IN:
2803#ifdef VBOX_WITH_HDA_MIC_IN
2804# error "Implement me!"
2805#else
2806 strmCfg.DestSource.Source = PDMAUDIORECSOURCE_LINE;
2807#endif
2808 break;
2809
2810 case PDMAUDIODIR_OUT:
2811 /* Destination(s) will be set in hdaAddStreamOut(),
2812 * based on the channels / stream layout. */
2813 break;
2814
2815 default:
2816 rc = VERR_NOT_SUPPORTED;
2817 break;
2818 }
2819
2820 /*
2821 * Initialize the stream mapping in any case, regardless if
2822 * we support surround audio or not. This is needed to handle
2823 * the supported channels within a single audio stream, e.g. mono/stereo.
2824 *
2825 * In other words, the stream mapping *always* knowns the real
2826 * number of channels in a single audio stream.
2827 */
2828 if (RT_SUCCESS(rc))
2829 {
2830 rc = hdaStreamMapInit(&pStream->State.Mapping, &strmCfg);
2831 AssertRC(rc);
2832 }
2833
2834 if (RT_SUCCESS(rc))
2835 {
2836 int rc2;
2837 PHDADRIVER pDrv;
2838 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
2839 {
2840 switch (strmCfg.enmDir)
2841 {
2842 case PDMAUDIODIR_OUT:
2843 rc2 = hdaAddStreamOut(pThis, &strmCfg);
2844 break;
2845
2846 case PDMAUDIODIR_IN:
2847 rc2 = hdaAddStreamIn(pThis, &strmCfg);
2848 break;
2849
2850 default:
2851 rc2 = VERR_NOT_SUPPORTED;
2852 AssertFailed();
2853 break;
2854 }
2855
2856 if ( RT_FAILURE(rc2)
2857 && (pDrv->Flags & PDMAUDIODRVFLAG_PRIMARY)) /* We only care about primary drivers here, the rest may fail. */
2858 {
2859 if (RT_SUCCESS(rc))
2860 rc = rc2;
2861 /* Keep going. */
2862 }
2863 }
2864
2865 /* If (re-)opening the stream by the codec above failed, don't write the new
2866 * format to the register so that the guest is aware it didn't work. */
2867 if (RT_SUCCESS(rc))
2868 {
2869 rc = hdaRegWriteU16(pThis, iReg, u32Value);
2870 AssertRC(rc);
2871 }
2872 else
2873 LogFunc(("[SD%RU8]: (Re-)Opening stream failed with rc=%Rrc\n", pStream->u8SD, rc));
2874
2875 hdaRegWriteSDUnlock(pStream);
2876 }
2877
2878 return VINF_SUCCESS; /* Never return failure. */
2879#else /* !IN_RING3 */
2880 return VINF_IOM_R3_MMIO_WRITE;
2881#endif
2882}
2883
2884/* Note: Will be called for both, BDPL and BDPU, registers. */
2885DECLINLINE(int) hdaRegWriteSDBDPX(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value, uint8_t u8Strm)
2886{
2887#ifdef IN_RING3
2888 if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
2889 return VINF_SUCCESS;
2890
2891 PHDASTREAM pStream = hdaStreamFromSD(pThis, u8Strm);
2892 if (!pStream)
2893 {
2894 LogFunc(("[SD%RU8]: Warning: Changing SDBPL/SDBPU on non-attached stream (0x%x)\n", HDA_SD_NUM_FROM_REG(pThis, CTL, iReg), u32Value));
2895 return hdaRegWriteU32(pThis, iReg, u32Value);
2896 }
2897
2898 int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
2899 AssertRC(rc2);
2900
2901 rc2 = hdaRegWriteU32(pThis, iReg, u32Value);
2902 AssertRC(rc2);
2903
2904 /* Update BDL base. */
2905 pStream->u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, u8Strm),
2906 HDA_STREAM_REG(pThis, BDPU, u8Strm));
2907 /* Reset BDLE state. */
2908 RT_ZERO(pStream->State.BDLE);
2909 pStream->State.uCurBDLE = 0;
2910
2911 LogFlowFunc(("[SD%RU8]: BDLBase=0x%x\n", pStream->u8SD, pStream->u64BDLBase));
2912 hdaRegWriteSDUnlock(pStream);
2913
2914 return VINF_SUCCESS; /* Always return success to the MMIO handler. */
2915#else /* !IN_RING3 */
2916 return VINF_IOM_R3_MMIO_WRITE;
2917#endif /* IN_RING3 */
2918}
2919
2920static int hdaRegWriteSDBDPL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2921{
2922 return hdaRegWriteSDBDPX(pThis, iReg, u32Value, HDA_SD_NUM_FROM_REG(pThis, BDPL, iReg));
2923}
2924
2925static int hdaRegWriteSDBDPU(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2926{
2927 return hdaRegWriteSDBDPX(pThis, iReg, u32Value, HDA_SD_NUM_FROM_REG(pThis, BDPU, iReg));
2928}
2929
2930#ifdef IN_RING3
2931/**
2932 * XXX
2933 *
2934 * @return bool Returns @true if write is allowed, @false if not.
2935 * @param pThis Pointer to HDA state.
2936 * @param iReg Register to write.
2937 * @param u32Value Value to write.
2938 */
2939DECLINLINE(int) hdaRegWriteSDLock(PHDASTATE pThis, PHDASTREAM pStream, uint32_t iReg, uint32_t u32Value)
2940{
2941 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2942 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2943
2944#ifdef VBOX_STRICT
2945 /* Check if the SD's RUN bit is set. */
2946 uint32_t u32SDCTL = HDA_STREAM_REG(pThis, CTL, pStream->u8SD);
2947 bool fIsRunning = RT_BOOL(u32SDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
2948 if (fIsRunning)
2949 {
2950 LogFunc(("[SD%RU8]: Warning: Cannot write to register 0x%x (0x%x) when RUN bit is set (%R[sdctl])\n",
2951 pStream->u8SD, iReg, u32Value, u32SDCTL));
2952# ifdef DEBUG_andy
2953 AssertFailed();
2954# endif
2955 return VERR_ACCESS_DENIED;
2956 }
2957#endif
2958
2959 return RTSemMutexRequest(pStream->State.hMtx, RT_INDEFINITE_WAIT);
2960}
2961
2962DECLINLINE(void) hdaRegWriteSDUnlock(PHDASTREAM pStream)
2963{
2964 AssertPtrReturnVoid(pStream);
2965
2966 int rc2 = RTSemMutexRelease(pStream->State.hMtx);
2967 AssertRC(rc2);
2968}
2969#endif /* IN_RING3 */
2970
2971static int hdaRegReadIRS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
2972{
2973 /* regarding 3.4.3 we should mark IRS as busy in case CORB is active */
2974 if ( HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP)
2975 || HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA))
2976 {
2977 HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, ICB); /* busy */
2978 }
2979
2980 return hdaRegReadU32(pThis, iReg, pu32Value);
2981}
2982
2983static int hdaRegWriteIRS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
2984{
2985 int rc = VINF_SUCCESS;
2986
2987 /*
2988 * If the guest set the ICB bit of IRS register, HDA should process the verb in IC register,
2989 * write the response to IR register, and set the IRV (valid in case of success) bit of IRS register.
2990 */
2991 if ( u32Value & HDA_REG_FIELD_FLAG_MASK(IRS, ICB)
2992 && !HDA_REG_FLAG_VALUE(pThis, IRS, ICB))
2993 {
2994#ifdef IN_RING3
2995 uint32_t uCmd = HDA_REG(pThis, IC);
2996
2997 if (HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP))
2998 {
2999 /*
3000 * 3.4.3: Defines behavior of immediate Command status register.
3001 */
3002 LogRel(("HDA: Guest attempted process immediate verb (%x) with active CORB\n", uCmd));
3003 return rc;
3004 }
3005
3006 HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, ICB); /* busy */
3007
3008 uint64_t uResp;
3009 int rc2 = pThis->pCodec->pfnLookup(pThis->pCodec,
3010 HDA_CODEC_CMD(uCmd, 0 /* LUN */), &uResp);
3011 if (RT_FAILURE(rc2))
3012 LogFunc(("Codec lookup failed with rc=%Rrc\n", rc2));
3013
3014 HDA_REG(pThis, IR) = (uint32_t)uResp; /** @todo r=andy Do we need a 64-bit response? */
3015 HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, IRV); /* result is ready */
3016 HDA_REG(pThis, IRS) &= ~HDA_REG_FIELD_FLAG_MASK(IRS, ICB); /* busy is clear */
3017#else /* !IN_RING3 */
3018 rc = VINF_IOM_R3_MMIO_WRITE;
3019#endif
3020 return rc;
3021 }
3022
3023 /*
3024 * Once the guest read the response, it should clean the IRV bit of the IRS register.
3025 */
3026 if ( u32Value & HDA_REG_FIELD_FLAG_MASK(IRS, IRV)
3027 && HDA_REG_FLAG_VALUE(pThis, IRS, IRV))
3028 HDA_REG(pThis, IRS) &= ~HDA_REG_FIELD_FLAG_MASK(IRS, IRV);
3029 return rc;
3030}
3031
3032static int hdaRegWriteRIRBWP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
3033{
3034 if (u32Value & HDA_REG_FIELD_FLAG_MASK(RIRBWP, RST))
3035 HDA_REG(pThis, RIRBWP) = 0;
3036
3037 /* The remaining bits are O, see 6.2.22. */
3038 return VINF_SUCCESS;
3039}
3040
3041static int hdaRegWriteBase(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
3042{
3043 uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
3044 int rc = hdaRegWriteU32(pThis, iReg, u32Value);
3045 if (RT_FAILURE(rc))
3046 AssertRCReturn(rc, rc);
3047
3048 switch(iReg)
3049 {
3050 case HDA_REG_CORBLBASE:
3051 pThis->u64CORBBase &= UINT64_C(0xFFFFFFFF00000000);
3052 pThis->u64CORBBase |= pThis->au32Regs[iRegMem];
3053 break;
3054 case HDA_REG_CORBUBASE:
3055 pThis->u64CORBBase &= UINT64_C(0x00000000FFFFFFFF);
3056 pThis->u64CORBBase |= ((uint64_t)pThis->au32Regs[iRegMem] << 32);
3057 break;
3058 case HDA_REG_RIRBLBASE:
3059 pThis->u64RIRBBase &= UINT64_C(0xFFFFFFFF00000000);
3060 pThis->u64RIRBBase |= pThis->au32Regs[iRegMem];
3061 break;
3062 case HDA_REG_RIRBUBASE:
3063 pThis->u64RIRBBase &= UINT64_C(0x00000000FFFFFFFF);
3064 pThis->u64RIRBBase |= ((uint64_t)pThis->au32Regs[iRegMem] << 32);
3065 break;
3066 case HDA_REG_DPLBASE:
3067 {
3068 pThis->u64DPBase &= UINT64_C(0xFFFFFFFF00000000);
3069 pThis->u64DPBase |= pThis->au32Regs[iRegMem];
3070
3071 /* Also make sure to handle the DMA position enable bit. */
3072 pThis->fDMAPosition = RT_BOOL(pThis->u64DPBase & RT_BIT_64(0));
3073 LogRel(("HDA: %s DMA position buffer\n", pThis->fDMAPosition ? "Enabled" : "Disabled"));
3074 break;
3075 }
3076 case HDA_REG_DPUBASE:
3077 pThis->u64DPBase &= UINT64_C(0x00000000FFFFFFFF);
3078 pThis->u64DPBase |= ((uint64_t)pThis->au32Regs[iRegMem] << 32);
3079 break;
3080 default:
3081 AssertMsgFailed(("Invalid index\n"));
3082 break;
3083 }
3084
3085 LogFunc(("CORB base:%llx RIRB base: %llx DP base: %llx\n",
3086 pThis->u64CORBBase, pThis->u64RIRBBase, pThis->u64DPBase));
3087 return rc;
3088}
3089
3090static int hdaRegWriteRIRBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
3091{
3092 uint8_t v = HDA_REG(pThis, RIRBSTS);
3093 HDA_REG(pThis, RIRBSTS) &= ~(v & u32Value);
3094
3095 return hdaProcessInterrupt(pThis);
3096}
3097
3098#ifdef IN_RING3
3099#ifdef LOG_ENABLED
3100static void hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE)
3101{
3102 LogFlowFunc(("BDLEs @ 0x%x (%RU16):\n", u64BDLBase, cBDLE));
3103 if (!u64BDLBase)
3104 return;
3105
3106 uint32_t cbBDLE = 0;
3107 for (uint16_t i = 0; i < cBDLE; i++)
3108 {
3109 uint8_t bdle[16]; /** @todo Use a define. */
3110 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BDLBase + i * 16, bdle, 16); /** @todo Use a define. */
3111
3112 uint64_t addr = *(uint64_t *)bdle;
3113 uint32_t len = *(uint32_t *)&bdle[8];
3114 uint32_t ioc = *(uint32_t *)&bdle[12];
3115
3116 LogFlowFunc(("\t#%03d BDLE(adr:0x%llx, size:%RU32, ioc:%RTbool)\n",
3117 i, addr, len, RT_BOOL(ioc & 0x1)));
3118
3119 cbBDLE += len;
3120 }
3121
3122 LogFlowFunc(("Total: %RU32 bytes\n", cbBDLE));
3123
3124 if (!pThis->u64DPBase) /* No DMA base given? Bail out. */
3125 return;
3126
3127 LogFlowFunc(("DMA counters:\n"));
3128
3129 for (int i = 0; i < cBDLE; i++)
3130 {
3131 uint32_t uDMACnt;
3132 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
3133 &uDMACnt, sizeof(uDMACnt));
3134
3135 LogFlowFunc(("\t#%03d DMA @ 0x%x\n", i , uDMACnt));
3136 }
3137}
3138#endif
3139
3140/**
3141 * Fetches a Bundle Descriptor List Entry (BDLE) from the DMA engine.
3142 *
3143 * @param pThis Pointer to HDA state.
3144 * @param pBDLE Where to store the fetched result.
3145 * @param u64BaseDMA Address base of DMA engine to use.
3146 * @param u16Entry BDLE entry to fetch.
3147 */
3148static int hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry)
3149{
3150 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3151 AssertPtrReturn(pBDLE, VERR_INVALID_POINTER);
3152 AssertReturn(u64BaseDMA, VERR_INVALID_PARAMETER);
3153
3154 if (!u64BaseDMA)
3155 {
3156 LogRel2(("HDA: Unable to fetch BDLE #%RU16 - no base DMA address set (yet)\n", u16Entry));
3157 return VERR_NOT_FOUND;
3158 }
3159 /** @todo Compare u16Entry with LVI. */
3160
3161 uint8_t uBundleEntry[16]; /** @todo Define a BDLE length. */
3162 int rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BaseDMA + u16Entry * 16, /** @todo Define a BDLE length. */
3163 uBundleEntry, RT_ELEMENTS(uBundleEntry));
3164 if (RT_FAILURE(rc))
3165 return rc;
3166
3167 RT_BZERO(pBDLE, sizeof(HDABDLE));
3168
3169 pBDLE->State.u32BDLIndex = u16Entry;
3170 pBDLE->u64BufAdr = *(uint64_t *) uBundleEntry;
3171 pBDLE->u32BufSize = *(uint32_t *)&uBundleEntry[8];
3172 if (pBDLE->u32BufSize < sizeof(uint16_t)) /* Must be at least one word. */
3173 return VERR_INVALID_STATE;
3174
3175 pBDLE->fIntOnCompletion = (*(uint32_t *)&uBundleEntry[12]) & RT_BIT(0);
3176
3177 return VINF_SUCCESS;
3178}
3179
3180/**
3181 * Returns the number of outstanding stream data bytes which need to be processed
3182 * by the DMA engine assigned to this stream.
3183 *
3184 * @return Number of bytes for the DMA engine to process.
3185 */
3186DECLINLINE(uint32_t) hdaStreamGetTransferSize(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbMax)
3187{
3188 AssertPtrReturn(pThis, 0);
3189 AssertPtrReturn(pStream, 0);
3190
3191 if (!cbMax)
3192 return 0;
3193
3194 PHDABDLE pBDLE = &pStream->State.BDLE;
3195
3196 uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
3197 Assert(u32LPIB <= pStream->u32CBL);
3198
3199 uint32_t cbFree = pStream->u32CBL - u32LPIB;
3200 if (cbFree)
3201 {
3202 /* Limit to the available free space of the current BDLE. */
3203 cbFree = RT_MIN(cbFree, pBDLE->u32BufSize - pBDLE->State.u32BufOff);
3204
3205 /* Make sure we only copy as much as the stream's FIFO can hold (SDFIFOS, 18.2.39). */
3206 cbFree = RT_MIN(cbFree, uint32_t(pStream->u16FIFOS));
3207
3208 /* Make sure we only transfer as many bytes as requested. */
3209 cbFree = RT_MIN(cbFree, cbMax);
3210
3211 if (pBDLE->State.cbBelowFIFOW)
3212 {
3213 /* Are we not going to reach (or exceed) the FIFO watermark yet with the data to copy?
3214 * No need to read data from DMA then. */
3215 if (cbFree > pBDLE->State.cbBelowFIFOW)
3216 {
3217 /* Subtract the amount of bytes that still would fit in the stream's FIFO
3218 * and therefore do not need to be processed by DMA. */
3219 cbFree -= pBDLE->State.cbBelowFIFOW;
3220 }
3221 }
3222 }
3223
3224 LogFlowFunc(("[SD%RU8]: CBL=%RU32, LPIB=%RU32, FIFOS=%RU16, cbFree=%RU32, %R[bdle]\n", pStream->u8SD,
3225 pStream->u32CBL, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), pStream->u16FIFOS, cbFree, pBDLE));
3226 return cbFree;
3227}
3228
3229DECLINLINE(void) hdaBDLEUpdate(PHDABDLE pBDLE, uint32_t cbData, uint32_t cbProcessed)
3230{
3231 AssertPtrReturnVoid(pBDLE);
3232
3233 if (!cbData || !cbProcessed)
3234 return;
3235
3236 /* Fewer than cbBelowFIFOW bytes were copied.
3237 * Probably we need to move the buffer, but it is rather hard to imagine a situation
3238 * where it might happen. */
3239 AssertMsg((cbProcessed == pBDLE->State.cbBelowFIFOW + cbData), /* we assume that we write the entire buffer including unreported bytes */
3240 ("cbProcessed=%RU32 != pBDLE->State.cbBelowFIFOW=%RU32 + cbData=%RU32\n",
3241 cbProcessed, pBDLE->State.cbBelowFIFOW, cbData));
3242
3243#if 0
3244 if ( pBDLE->State.cbBelowFIFOW
3245 && pBDLE->State.cbBelowFIFOW <= cbWritten)
3246 {
3247 LogFlowFunc(("BDLE(cbUnderFifoW:%RU32, off:%RU32, size:%RU32)\n",
3248 pBDLE->State.cbBelowFIFOW, pBDLE->State.u32BufOff, pBDLE->u32BufSize));
3249 }
3250#endif
3251
3252 pBDLE->State.cbBelowFIFOW -= RT_MIN(pBDLE->State.cbBelowFIFOW, cbProcessed);
3253 Assert(pBDLE->State.cbBelowFIFOW == 0);
3254
3255 /* We always increment the position of DMA buffer counter because we're always reading
3256 * into an intermediate buffer. */
3257 pBDLE->State.u32BufOff += cbData;
3258 Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
3259
3260 LogFlowFunc(("cbData=%RU32, cbProcessed=%RU32, %R[bdle]\n", cbData, cbProcessed, pBDLE));
3261}
3262
3263#ifdef IN_RING3
3264/**
3265 * Initializes a stream mapping structure according to the given stream configuration.
3266 *
3267 * @return IPRT status code.
3268 * @param pMapping Pointer to mapping to initialize.
3269 * @param pCfg Pointer to stream configuration to use.
3270 */
3271static int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg)
3272{
3273 AssertPtrReturn(pMapping, VERR_INVALID_POINTER);
3274 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
3275
3276 AssertReturn(pCfg->cChannels, VERR_INVALID_PARAMETER);
3277
3278 hdaStreamMapReset(pMapping);
3279
3280 pMapping->paChannels = (PPDMAUDIOSTREAMCHANNEL)RTMemAlloc(sizeof(PDMAUDIOSTREAMCHANNEL) * pCfg->cChannels);
3281 if (!pMapping->paChannels)
3282 return VERR_NO_MEMORY;
3283
3284 PDMPCMPROPS Props;
3285 int rc = DrvAudioHlpStreamCfgToProps(pCfg, &Props);
3286 if (RT_FAILURE(rc))
3287 return rc;
3288
3289 Assert(RT_IS_POWER_OF_TWO(Props.cBits));
3290
3291 /** @todo We assume all channels in a stream have the same format. */
3292 PPDMAUDIOSTREAMCHANNEL pChan = pMapping->paChannels;
3293 for (uint8_t i = 0; i < pCfg->cChannels; i++)
3294 {
3295 pChan->uChannel = i;
3296 pChan->cbStep = (Props.cBits / 2);
3297 pChan->cbFrame = pChan->cbStep * pCfg->cChannels;
3298 pChan->cbFirst = i * pChan->cbStep;
3299 pChan->cbOff = pChan->cbFirst;
3300
3301 int rc2 = hdaStreamChannelDataInit(&pChan->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE);
3302 if (RT_SUCCESS(rc))
3303 rc = rc2;
3304
3305 if (RT_FAILURE(rc))
3306 break;
3307
3308 pChan++;
3309 }
3310
3311 if ( RT_SUCCESS(rc)
3312 /* Create circular buffer if not created yet. */
3313 && !pMapping->pCircBuf)
3314 {
3315 rc = RTCircBufCreate(&pMapping->pCircBuf, _4K); /** @todo Make size configurable? */
3316 }
3317
3318 if (RT_SUCCESS(rc))
3319 {
3320 pMapping->cChannels = pCfg->cChannels;
3321#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
3322 pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_INTERLEAVED;
3323#else
3324 pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
3325#endif
3326 }
3327
3328 return rc;
3329}
3330
3331/**
3332 * Destroys a given stream mapping.
3333 *
3334 * @param pMapping Pointer to mapping to destroy.
3335 */
3336static void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping)
3337{
3338 hdaStreamMapReset(pMapping);
3339
3340 if (pMapping->pCircBuf)
3341 {
3342 RTCircBufDestroy(pMapping->pCircBuf);
3343 pMapping->pCircBuf = NULL;
3344 }
3345}
3346
3347/**
3348 * Resets a given stream mapping.
3349 *
3350 * @param pMapping Pointer to mapping to reset.
3351 */
3352static void hdaStreamMapReset(PHDASTREAMMAPPING pMapping)
3353{
3354 AssertPtrReturnVoid(pMapping);
3355
3356 pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_UNKNOWN;
3357
3358 if (pMapping->cChannels)
3359 {
3360 for (uint8_t i = 0; i < pMapping->cChannels; i++)
3361 hdaStreamChannelDataDestroy(&pMapping->paChannels[i].Data);
3362
3363 AssertPtr(pMapping->paChannels);
3364 RTMemFree(pMapping->paChannels);
3365 pMapping->paChannels = NULL;
3366
3367 pMapping->cChannels = 0;
3368 }
3369}
3370#endif /* IN_RING3 */
3371
3372DECLINLINE(bool) hdaStreamNeedsNextBDLE(PHDASTATE pThis, PHDASTREAM pStream)
3373{
3374 AssertPtrReturn(pThis, false);
3375 AssertPtrReturn(pStream, false);
3376
3377 PHDABDLE pBDLE = &pStream->State.BDLE;
3378 uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
3379
3380 /* Did we reach the CBL (Cyclic Buffer List) limit? */
3381 bool fCBLLimitReached = u32LPIB >= pStream->u32CBL;
3382
3383 /* Do we need to use the next BDLE entry? Either because we reached
3384 * the CBL limit or our internal DMA buffer is full. */
3385 bool fNeedsNextBDLE = ( fCBLLimitReached
3386 || (pBDLE->State.u32BufOff >= pBDLE->u32BufSize));
3387
3388 Assert(u32LPIB <= pStream->u32CBL);
3389 Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
3390
3391 LogFlowFunc(("[SD%RU8]: LPIB=%RU32, CBL=%RU32, fCBLLimitReached=%RTbool, fNeedsNextBDLE=%RTbool, %R[bdle]\n",
3392 pStream->u8SD, u32LPIB, pStream->u32CBL, fCBLLimitReached, fNeedsNextBDLE, pBDLE));
3393
3394 return fNeedsNextBDLE;
3395}
3396
3397DECLINLINE(void) hdaStreamTransferUpdate(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbInc)
3398{
3399 AssertPtrReturnVoid(pThis);
3400 AssertPtrReturnVoid(pStream);
3401
3402 LogFlowFunc(("[SD%RU8]: cbInc=%RU32\n", pStream->u8SD, cbInc));
3403
3404 //Assert(cbInc <= pStream->u16FIFOS);
3405
3406 if (!cbInc) /* Nothing to do? Bail out early. */
3407 return;
3408
3409 PHDABDLE pBDLE = &pStream->State.BDLE;
3410
3411 /*
3412 * If we're below the FIFO watermark (SDFIFOW), it's expected that HDA
3413 * doesn't fetch anything via DMA, so just update LPIB.
3414 * (ICH6 datasheet 18.2.38).
3415 */
3416 if (pBDLE->State.cbBelowFIFOW == 0) /* Did we hit (or exceed) the watermark? */
3417 {
3418 uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
3419
3420 AssertMsg(((u32LPIB + cbInc) <= pStream->u32CBL),
3421 ("[SD%RU8] Increment (%RU32) exceeds CBL (%RU32): LPIB (%RU32)\n",
3422 pStream->u8SD, cbInc, pStream->u32CBL, u32LPIB));
3423
3424 u32LPIB = RT_MIN(u32LPIB + cbInc, pStream->u32CBL);
3425
3426 LogFlowFunc(("[SD%RU8]: LPIB: %RU32 -> %RU32, CBL=%RU32\n",
3427 pStream->u8SD,
3428 HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) + cbInc,
3429 pStream->u32CBL));
3430
3431 hdaStreamUpdateLPIB(pThis, pStream, u32LPIB);
3432 }
3433}
3434
3435static bool hdaStreamTransferIsComplete(PHDASTATE pThis, PHDASTREAM pStream, bool *pfInterrupt)
3436{
3437 AssertPtrReturn(pThis, true);
3438 AssertPtrReturn(pStream, true);
3439
3440 bool fInterrupt = false;
3441 bool fIsComplete = false;
3442
3443 PHDABDLE pBDLE = &pStream->State.BDLE;
3444 const uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
3445
3446 /* Check if the current BDLE entry is complete (full). */
3447 if (pBDLE->State.u32BufOff >= pBDLE->u32BufSize)
3448 {
3449 Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
3450
3451 if (/* IOC (Interrupt On Completion) bit set? */
3452 pBDLE->fIntOnCompletion
3453 /* All data put into the DMA FIFO? */
3454 && pBDLE->State.cbBelowFIFOW == 0
3455 )
3456 {
3457 LogFlowFunc(("[SD%RU8]: %R[bdle] => COMPLETE\n", pStream->u8SD, pBDLE));
3458
3459 /*
3460 * If the ICE (IOCE, "Interrupt On Completion Enable") bit of the SDCTL register is set
3461 * we need to generate an interrupt.
3462 */
3463 if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
3464 fInterrupt = true;
3465 }
3466
3467 fIsComplete = true;
3468 }
3469
3470 if (pfInterrupt)
3471 *pfInterrupt = fInterrupt;
3472
3473 LogFlowFunc(("[SD%RU8]: u32LPIB=%RU32, CBL=%RU32, fIsComplete=%RTbool, fInterrupt=%RTbool, %R[bdle]\n",
3474 pStream->u8SD, u32LPIB, pStream->u32CBL, fIsComplete, fInterrupt, pBDLE));
3475
3476 return fIsComplete;
3477}
3478
3479/**
3480 * hdaReadAudio - copies samples from audio backend to DMA.
3481 * Note: This function writes to the DMA buffer immediately,
3482 * but "reports bytes" when all conditions are met (FIFOW).
3483 */
3484static int hdaReadAudio(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcess, uint32_t *pcbProcessed)
3485{
3486 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3487 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
3488 /* pcbProcessed is optional. */
3489
3490 int rc;
3491 uint32_t cbRead = 0;
3492
3493 do
3494 {
3495 PHDABDLE pBDLE = &pStream->State.BDLE;
3496
3497 if (!cbToProcess)
3498 {
3499 rc = VINF_EOF;
3500 break;
3501 }
3502
3503 AssertPtr(pStream->pMixSink);
3504 AssertPtr(pStream->pMixSink->pMixSink);
3505 rc = AudioMixerSinkRead(pStream->pMixSink->pMixSink, AUDMIXOP_BLEND, pBDLE->State.au8FIFO, cbToProcess, &cbRead);
3506 if (RT_FAILURE(rc))
3507 break;
3508
3509 if (!cbRead)
3510 {
3511 rc = VINF_EOF;
3512 break;
3513 }
3514
3515 /* Sanity checks. */
3516 Assert(cbRead <= cbToProcess);
3517 Assert(cbRead <= sizeof(pBDLE->State.au8FIFO));
3518 Assert(cbRead <= pBDLE->u32BufSize - pBDLE->State.u32BufOff);
3519
3520 /*
3521 * Write to the BDLE's DMA buffer.
3522 */
3523 rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
3524 pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
3525 pBDLE->State.au8FIFO, cbRead);
3526 AssertRC(rc);
3527
3528 if (pBDLE->State.cbBelowFIFOW + cbRead > hdaStreamGetFIFOW(pThis, pStream))
3529 {
3530 Assert(pBDLE->State.u32BufOff + cbRead <= pBDLE->u32BufSize);
3531 pBDLE->State.u32BufOff += cbRead;
3532 pBDLE->State.cbBelowFIFOW = 0;
3533 //hdaBackendReadTransferReported(pBDLE, cbDMAData, cbRead, &cbRead, pcbAvail);
3534 }
3535 else
3536 {
3537 Assert(pBDLE->State.u32BufOff + cbRead <= pBDLE->u32BufSize);
3538 pBDLE->State.u32BufOff += cbRead;
3539 pBDLE->State.cbBelowFIFOW += cbRead;
3540 Assert(pBDLE->State.cbBelowFIFOW <= hdaStreamGetFIFOW(pThis, pStream));
3541 //hdaBackendTransferUnreported(pThis, pBDLE, pStreamDesc, cbRead, pcbAvail);
3542
3543 rc = VERR_NO_DATA;
3544 }
3545
3546 } while (0);
3547
3548 if (RT_SUCCESS(rc))
3549 {
3550 if (pcbProcessed)
3551 *pcbProcessed = cbRead;
3552 }
3553
3554 if (RT_FAILURE(rc))
3555 LogFlowFunc(("Failed with %Rrc\n", rc));
3556
3557 return rc;
3558}
3559
3560static int hdaWriteAudio(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcess, uint32_t *pcbProcessed)
3561{
3562 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3563 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
3564 /* pcbWritten is optional. */
3565
3566 PHDABDLE pBDLE = &pStream->State.BDLE;
3567
3568 uint32_t cbWritten = 0;
3569
3570 /*
3571 * Copy from DMA to the corresponding stream buffer (if there are any bytes from the
3572 * previous unreported transfer we write at offset 'pBDLE->State.cbUnderFifoW').
3573 */
3574 int rc;
3575 if (!cbToProcess)
3576 {
3577 rc = VINF_EOF;
3578 }
3579 else
3580 {
3581 void *pvBuf = pBDLE->State.au8FIFO + pBDLE->State.cbBelowFIFOW;
3582 Assert(cbToProcess >= pBDLE->State.cbBelowFIFOW);
3583 uint32_t cbBuf = cbToProcess - pBDLE->State.cbBelowFIFOW;
3584
3585 /*
3586 * Read from the current BDLE's DMA buffer.
3587 */
3588 rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
3589 pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
3590 pvBuf, cbBuf);
3591 AssertRC(rc);
3592
3593#ifdef HDA_DEBUG_DUMP_PCM_DATA
3594 RTFILE fh;
3595 RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaWriteAudio-hda.pcm",
3596 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
3597 RTFileWrite(fh, pvBuf, cbBuf, NULL);
3598 RTFileClose(fh);
3599#endif
3600
3601#ifdef VBOX_WITH_STATISTICS
3602 STAM_COUNTER_ADD(&pThis->StatBytesRead, cbBuf);
3603#endif
3604 /*
3605 * Write to audio backend. We should ensure that we have enough bytes to copy to the backend.
3606 */
3607 if (cbBuf >= hdaStreamGetFIFOW(pThis, pStream))
3608 {
3609 PHDASTREAMMAPPING pMapping = &pStream->State.Mapping;
3610
3611 /** @todo Which channel is which? */
3612#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
3613 PPDMAUDIOSTREAMCHANNEL pChanFront = &pMapping->paChannels[0];
3614#endif
3615#ifdef VBOX_WITH_HDA_51_SURROUND
3616 PPDMAUDIOSTREAMCHANNEL pChanCenterLFE = &pMapping->paChannels[2]; /** @todo FIX! */
3617 PPDMAUDIOSTREAMCHANNEL pChanRear = &pMapping->paChannels[4]; /** @todo FIX! */
3618#endif
3619 int rc2;
3620
3621 void *pvDataFront = NULL;
3622 size_t cbDataFront;
3623#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
3624 rc2 = hdaStreamChannelExtract(pChanFront, pvBuf, cbBuf);
3625 AssertRC(rc2);
3626
3627 rc2 = hdaStreamChannelAcquireData(&pChanFront->Data, pvDataFront, &cbDataFront);
3628 AssertRC(rc2);
3629#else
3630 /* Use stuff in the whole FIFO to use for the channel data. */
3631 pvDataFront = pvBuf;
3632 cbDataFront = cbBuf;
3633#endif
3634#ifdef VBOX_WITH_HDA_51_SURROUND
3635 void *pvDataCenterLFE;
3636 size_t cbDataCenterLFE;
3637 rc2 = hdaStreamChannelExtract(pChanCenterLFE, pvBuf, cbBuf);
3638 AssertRC(rc2);
3639
3640 rc2 = hdaStreamChannelAcquireData(&pChanCenterLFE->Data, pvDataCenterLFE, &cbDataCenterLFE);
3641 AssertRC(rc2);
3642
3643 void *pvDataRear;
3644 size_t cbDataRear;
3645 rc2 = hdaStreamChannelExtract(pChanRear, pvBuf, cbBuf);
3646 AssertRC(rc2);
3647
3648 rc2 = hdaStreamChannelAcquireData(&pChanRear->Data, pvDataRear, &cbDataRear);
3649 AssertRC(rc2);
3650#endif
3651 /*
3652 * Write data to according mixer sinks.
3653 */
3654 rc2 = AudioMixerSinkWrite(pThis->SinkFront.pMixSink, AUDMIXOP_COPY, pvDataFront, cbDataFront,
3655 NULL /* pcbWritten */);
3656 AssertRC(rc2);
3657#ifdef VBOX_WITH_HDA_51_SURROUND
3658 rc2 = AudioMixerSinkWrite(pThis->SinkCenterLFE, AUDMIXOP_COPY, pvDataCenterLFE, cbDataCenterLFE,
3659 NULL /* pcbWritten */);
3660 AssertRC(rc2);
3661 rc2 = AudioMixerSinkWrite(pThis->SinkRear, AUDMIXOP_COPY, pvDataRear, cbDataRear,
3662 NULL /* pcbWritten */);
3663 AssertRC(rc2);
3664#endif
3665
3666#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
3667 hdaStreamChannelReleaseData(&pChanFront->Data);
3668#endif
3669#ifdef VBOX_WITH_HDA_51_SURROUND
3670 hdaStreamChannelReleaseData(&pChanCenterLFE->Data);
3671 hdaStreamChannelReleaseData(&pChanRear->Data);
3672#endif
3673
3674 /* Always report all data as being written;
3675 * backends who were not able to catch up have to deal with it themselves. */
3676 cbWritten = cbToProcess;
3677
3678 hdaBDLEUpdate(pBDLE, cbToProcess, cbWritten);
3679 }
3680 else
3681 {
3682 Assert(pBDLE->State.u32BufOff + cbWritten <= pBDLE->u32BufSize);
3683 pBDLE->State.u32BufOff += cbWritten;
3684 pBDLE->State.cbBelowFIFOW += cbWritten;
3685 Assert(pBDLE->State.cbBelowFIFOW <= hdaStreamGetFIFOW(pThis, pStream));
3686
3687 /* Not enough bytes to be processed and reported, we'll try our luck next time around. */
3688 //hdaBackendTransferUnreported(pThis, pBDLE, pStreamDesc, cbAvail, NULL);
3689 rc = VINF_EOF;
3690 }
3691 }
3692
3693 //Assert(cbWritten <= pStream->u16FIFOS);
3694
3695 if (RT_SUCCESS(rc))
3696 {
3697 if (pcbProcessed)
3698 *pcbProcessed = cbWritten;
3699 }
3700
3701 if (RT_FAILURE(rc))
3702 LogFlowFunc(("Failed with %Rrc\n", rc));
3703
3704 return rc;
3705}
3706
3707/**
3708 * @interface_method_impl{HDACODEC,pfnReset}
3709 */
3710static DECLCALLBACK(int) hdaCodecReset(PHDACODEC pCodec)
3711{
3712 PHDASTATE pThis = pCodec->pHDAState;
3713 NOREF(pThis);
3714 return VINF_SUCCESS;
3715}
3716
3717/**
3718 * Retrieves a corresponding sink for a given mixer control.
3719 * Returns NULL if no sink is found.
3720 *
3721 * @return PHDAMIXERSINK
3722 * @param pThis HDA state.
3723 * @param enmMixerCtl Mixer control to get the corresponding sink for.
3724 */
3725static PHDAMIXERSINK hdaMixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
3726{
3727 PHDAMIXERSINK pSink;
3728
3729 switch (enmMixerCtl)
3730 {
3731 case PDMAUDIOMIXERCTL_VOLUME:
3732 /* Fall through is intentional. */
3733 case PDMAUDIOMIXERCTL_FRONT:
3734 pSink = &pThis->SinkFront;
3735 break;
3736#ifdef VBOX_WITH_HDA_51_SURROUND
3737 case PDMAUDIOMIXERCTL_CENTER_LFE:
3738 pSink = &pThis->SinkCenterLFE;
3739 break;
3740 case PDMAUDIOMIXERCTL_REAR:
3741 pSink = &pThis->SinkRear;
3742 break;
3743#endif
3744 case PDMAUDIOMIXERCTL_LINE_IN:
3745 pSink = &pThis->SinkLineIn;
3746 break;
3747#ifdef VBOX_WITH_HDA_MIC_IN
3748 case PDMAUDIOMIXERCTL_MIC_IN:
3749 pSink = &pThis->SinkMicIn;
3750 break;
3751#endif
3752 default:
3753 pSink = NULL;
3754 AssertMsgFailed(("Unhandled mixer control\n"));
3755 break;
3756 }
3757
3758 return pSink;
3759}
3760
3761static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PHDAMIXERSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
3762{
3763 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3764 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
3765 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
3766
3767 LogFunc(("Sink=%s, Stream=%s\n", pSink->pMixSink->pszName, pCfg->szName));
3768
3769 /* Update the sink's format. */
3770 PDMPCMPROPS PCMProps;
3771 int rc = DrvAudioHlpStreamCfgToProps(pCfg, &PCMProps);
3772 if (RT_SUCCESS(rc))
3773 rc = AudioMixerSinkSetFormat(pSink->pMixSink, &PCMProps);
3774
3775 if (RT_FAILURE(rc))
3776 return rc;
3777
3778 PHDADRIVER pDrv;
3779 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
3780 {
3781 int rc2 = VINF_SUCCESS;
3782 PHDAMIXERSTREAM pStream;
3783
3784 if (pCfg->enmDir == PDMAUDIODIR_IN)
3785 {
3786 switch (pCfg->DestSource.Source)
3787 {
3788 case PDMAUDIORECSOURCE_LINE:
3789 pStream = &pDrv->LineIn;
3790 break;
3791#ifdef VBOX_WITH_HDA_MIC_IN
3792 case PDMAUDIORECSOURCE_MIC:
3793 pStream = &pDrv->MicIn;
3794 break;
3795#endif
3796 default:
3797 rc2 = VERR_NOT_SUPPORTED;
3798 break;
3799 }
3800 }
3801 else if (pCfg->enmDir == PDMAUDIODIR_OUT)
3802 {
3803 switch (pCfg->DestSource.Dest)
3804 {
3805 case PDMAUDIOPLAYBACKDEST_FRONT:
3806 pStream = &pDrv->Front;
3807 break;
3808#ifdef VBOX_WITH_HDA_51_SURROUND
3809 case PDMAUDIOPLAYBACKDEST_CENTER_LFE:
3810 pStream = &pDrv->CenterLFE;
3811 break;
3812 case PDMAUDIOPLAYBACKDEST_REAR:
3813 pStream = &pDrv->Rear;
3814 break;
3815#endif
3816 default:
3817 rc2 = VERR_NOT_SUPPORTED;
3818 break;
3819 }
3820 }
3821 else
3822 rc2 = VERR_NOT_SUPPORTED;
3823
3824 if (RT_SUCCESS(rc2))
3825 {
3826 AudioMixerSinkRemoveStream(pSink->pMixSink, pStream->pMixStrm);
3827
3828 AudioMixerStreamDestroy(pStream->pMixStrm);
3829 pStream->pMixStrm = NULL;
3830
3831 PAUDMIXSTREAM pMixStrm;
3832 rc2 = AudioMixerSinkCreateStream(pSink->pMixSink, pDrv->pConnector, pCfg, 0 /* fFlags */, &pMixStrm);
3833 if (RT_SUCCESS(rc2))
3834 {
3835 rc2 = AudioMixerSinkAddStream(pSink->pMixSink, pMixStrm);
3836 LogFlowFunc(("LUN#%RU8: Added \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, pCfg->szName , rc2));
3837 }
3838
3839 if (RT_SUCCESS(rc2))
3840 pStream->pMixStrm = pMixStrm;
3841 }
3842
3843 if (RT_SUCCESS(rc))
3844 rc = rc2;
3845 }
3846
3847 LogFlowFuncLeaveRC(rc);
3848 return rc;
3849}
3850
3851/**
3852 * Adds a new audio stream to a specific mixer control.
3853 * Depending on the mixer control the stream then gets assigned to one of the internal
3854 * mixer sinks, which in turn then handle the mixing of all connected streams to that sink.
3855 *
3856 * @return IPRT status code.
3857 * @param pThis HDA state.
3858 * @param enmMixerCtl Mixer control to assign new stream to.
3859 * @param pCfg Stream configuration for the new stream.
3860 */
3861static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
3862{
3863 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3864 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
3865
3866 int rc;
3867
3868 PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
3869 if (pSink)
3870 {
3871 rc = hdaMixerAddStream(pThis, pSink, pCfg);
3872
3873 AssertPtr(pSink->pMixSink);
3874 LogFlowFunc(("Sink=%s, enmMixerCtl=%ld\n", pSink->pMixSink->pszName, enmMixerCtl));
3875 }
3876 else
3877 rc = VERR_NOT_FOUND;
3878
3879 LogFlowFuncLeaveRC(rc);
3880 return rc;
3881}
3882
3883/**
3884 * Removes a specified mixer control from the HDA's mixer.
3885 *
3886 * @return IPRT status code.
3887 * @param pThis HDA state.
3888 * @param enmMixerCtl Mixer control to remove.
3889 */
3890static DECLCALLBACK(int) hdaMixerRemoveStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
3891{
3892 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3893
3894 int rc;
3895
3896 PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
3897 if (pSink)
3898 {
3899 PHDADRIVER pDrv;
3900 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
3901 {
3902 PAUDMIXSTREAM pMixStream = NULL;
3903 switch (enmMixerCtl)
3904 {
3905 /*
3906 * Input.
3907 */
3908 case PDMAUDIOMIXERCTL_LINE_IN:
3909 pMixStream = pDrv->LineIn.pMixStrm;
3910 pDrv->LineIn.pMixStrm = NULL;
3911 break;
3912#ifdef VBOX_WITH_HDA_MIC_IN
3913 case PDMAUDIOMIXERCTL_MIC_IN:
3914 pMixStream = pDrv->MicIn.pMixStrm;
3915 pDrv->MicIn.pMixStrm = NULL;
3916 break;
3917#endif
3918 /*
3919 * Output.
3920 */
3921 case PDMAUDIOMIXERCTL_FRONT:
3922 pMixStream = pDrv->Front.pMixStrm;
3923 pDrv->Front.pMixStrm = NULL;
3924 break;
3925#ifdef VBOX_WITH_HDA_51_SURROUND
3926 case PDMAUDIOMIXERCTL_CENTER_LFE:
3927 pMixStream = pDrv->CenterLFE.pMixStrm;
3928 pDrv->CenterLFE.pMixStrm = NULL;
3929 break;
3930 case PDMAUDIOMIXERCTL_REAR:
3931 pMixStream = pDrv->Rear.pMixStrm;
3932 pDrv->Rear.pMixStrm = NULL;
3933 break;
3934#endif
3935 default:
3936 AssertMsgFailed(("Mixer control %ld not implemented\n", enmMixerCtl));
3937 break;
3938 }
3939
3940 AssertPtr(pMixStream);
3941
3942 AudioMixerSinkRemoveStream(pSink->pMixSink, pMixStream);
3943 AudioMixerStreamDestroy(pMixStream);
3944 }
3945
3946 AudioMixerSinkRemoveAllStreams(pSink->pMixSink);
3947 rc = VINF_SUCCESS;
3948 }
3949 else
3950 rc = VERR_NOT_FOUND;
3951
3952 LogFlowFunc(("enmMixerCtl=%ld, rc=%Rrc\n", enmMixerCtl, rc));
3953 return rc;
3954}
3955
3956/**
3957 * Sets a SDn stream number and channel to a particular mixer control.
3958 *
3959 * @returns IPRT status code.
3960 * @param pThis HDA State.
3961 * @param enmMixerCtl Mixer control to set SD stream number and channel for.
3962 * @param uSD SD stream number (number + 1) to set. Set to 0 for unassign.
3963 * @param uChannel Channel to set. Only valid if a valid SD stream number is specified.
3964 */
3965static DECLCALLBACK(int) hdaMixerSetStream(PHDASTATE pThis,
3966 PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
3967{
3968 LogFlowFunc(("enmMixerCtl=%RU32, uSD=%RU8, uChannel=%RU8\n", enmMixerCtl, uSD, uChannel));
3969
3970 if (uSD == 0) /* Stream number 0 is reserved. */
3971 {
3972 LogFlowFunc(("Invalid SDn (%RU8) number for mixer control %ld, ignoring\n", uSD, enmMixerCtl));
3973 return VINF_SUCCESS;
3974 }
3975 /* uChannel is optional. */
3976
3977 /* SDn0 starts as 1. */
3978 Assert(uSD);
3979 uSD--;
3980
3981 int rc;
3982
3983 PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
3984 if (pSink)
3985 {
3986 if ( (uSD < HDA_MAX_SDI)
3987 && AudioMixerSinkGetDir(pSink->pMixSink) == AUDMIXSINKDIR_OUTPUT)
3988 {
3989 uSD += HDA_MAX_SDI;
3990 }
3991
3992 LogFlowFunc(("%s: Setting to stream ID=%RU8, channel=%RU8, enmMixerCtl=%RU32\n",
3993 pSink->pMixSink->pszName, uSD, uChannel, enmMixerCtl));
3994
3995 Assert(uSD < HDA_MAX_STREAMS);
3996
3997 PHDASTREAM pStream = hdaStreamFromSD(pThis, uSD);
3998 if (pStream)
3999 {
4000 pSink->uSD = uSD;
4001 pSink->uChannel = uChannel;
4002
4003 /* Make sure that the stream also has this sink set. */
4004 hdaStreamAssignToSink(pStream, pSink);
4005
4006 rc = VINF_SUCCESS;
4007 }
4008 else
4009 {
4010 LogRel(("HDA: Guest wanted to assign invalid stream ID=%RU8 (channel %RU8) to mixer control %RU32, skipping\n",
4011 uSD, uChannel, enmMixerCtl));
4012 rc = VERR_INVALID_PARAMETER;
4013 }
4014 }
4015 else
4016 rc = VERR_NOT_FOUND;
4017
4018 LogFlowFuncLeaveRC(rc);
4019 return rc;
4020}
4021
4022/**
4023 * Sets the volume of a specified mixer control.
4024 *
4025 * @return IPRT status code.
4026 * @param pThis HDA State.
4027 * @param enmMixerCtl Mixer control to set volume for.
4028 * @param pVol Pointer to volume data to set.
4029 */
4030static DECLCALLBACK(int) hdaMixerSetVolume(PHDASTATE pThis,
4031 PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol)
4032{
4033 int rc;
4034
4035 PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
4036 if (pSink)
4037 {
4038 /* Set the volume.
4039 * We assume that the codec already converted it to the correct range. */
4040 rc = AudioMixerSinkSetVolume(pSink->pMixSink, pVol);
4041 }
4042 else
4043 rc = VERR_NOT_FOUND;
4044
4045 LogFlowFuncLeaveRC(rc);
4046 return rc;
4047}
4048
4049#ifndef VBOX_WITH_AUDIO_CALLBACKS
4050
4051static void hdaTimerMaybeStart(PHDASTATE pThis)
4052{
4053 LogFlowFunc(("cStreamsActive=%RU8\n", pThis->cStreamsActive));
4054
4055 if (pThis->cStreamsActive == 0) /* Only start the timer if there are no active streams. */
4056 return;
4057
4058 if (!pThis->pTimer)
4059 return;
4060
4061 LogFlowFuncEnter();
4062
4063 /* Set timer flag. */
4064 ASMAtomicXchgBool(&pThis->fTimerActive, true);
4065
4066 /* Update current time timestamp. */
4067 pThis->uTimerTS = TMTimerGet(pThis->pTimer);
4068
4069 /* Fire off timer. */
4070 TMTimerSet(pThis->pTimer, TMTimerGet(pThis->pTimer) + pThis->cTimerTicks);
4071}
4072
4073static void hdaTimerMaybeStop(PHDASTATE pThis)
4074{
4075 LogFlowFunc(("cStreamsActive=%RU8\n", pThis->cStreamsActive));
4076
4077 if (pThis->cStreamsActive) /* Some streams still active? Bail out. */
4078 return;
4079
4080 if (!pThis->pTimer)
4081 return;
4082
4083 LogFlowFuncEnter();
4084
4085 /* Set timer flag. */
4086 ASMAtomicXchgBool(&pThis->fTimerActive, false);
4087}
4088
4089static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
4090{
4091 PHDASTATE pThis = (PHDASTATE)pvUser;
4092 Assert(pThis == PDMINS_2_DATA(pDevIns, PHDASTATE));
4093 AssertPtr(pThis);
4094
4095 STAM_PROFILE_START(&pThis->StatTimer, a);
4096
4097 uint32_t cbInMax = 0;
4098 uint32_t cbOutMin = UINT32_MAX;
4099
4100 uint64_t cTicksNow = TMTimerGet(pTimer);
4101 uint64_t cTicksElapsed = cTicksNow - pThis->uTimerTS;
4102
4103 LogFlowFuncEnter();
4104
4105 /* Update current time timestamp. */
4106 pThis->uTimerTS = cTicksNow;
4107
4108 /* Flag indicating whether to kick the timer again for a
4109 * new data processing round. */
4110 bool fKickTimer = false;
4111
4112 PHDASTREAM pStreamLineIn = hdaGetStreamFromSink(pThis, &pThis->SinkLineIn);
4113#ifdef VBOX_WITH_HDA_MIC_IN
4114 PHDASTREAM pStreamMicIn = hdaGetStreamFromSink(pThis, &pThis->SinkMicIn);
4115#endif
4116 PHDASTREAM pStreamFront = hdaGetStreamFromSink(pThis, &pThis->SinkFront);
4117#ifdef VBOX_WITH_HDA_51_SURROUND
4118 /** @todo See note below. */
4119#endif
4120
4121 AudioMixerSinkTimerUpdate(pThis->SinkLineIn.pMixSink, pThis->cTimerTicks, cTicksElapsed);
4122 hdaTransfer(pThis, pStreamLineIn);
4123
4124 if (AudioMixerSinkGetStatus(pThis->SinkLineIn.pMixSink) & AUDMIXSINK_STS_DIRTY)
4125 fKickTimer = true;
4126
4127#ifdef VBOX_WITH_HDA_MIC_IN
4128 AudioMixerSinkTimerUpdate(pThis->SinkMicIn.pMixSink, pThis->cTimerTicks, cTicksElapsed);
4129 hdaTransfer(pThis, pStreamMicIn);
4130
4131 if (AudioMixerSinkGetStatus(pThis->SinkLineIn.pMixSink) & AUDMIXSINK_STS_DIRTY)
4132 fKickTimer = true;
4133#endif
4134
4135 AudioMixerSinkTimerUpdate(pThis->SinkFront.pMixSink, pThis->cTimerTicks, cTicksElapsed);
4136 hdaTransfer(pThis, pStreamFront);
4137
4138 if (AudioMixerSinkGetStatus(pThis->SinkFront.pMixSink) & AUDMIXSINK_STS_DIRTY)
4139 fKickTimer = true;
4140
4141#ifdef VBOX_WITH_HDA_51_SURROUND
4142 AudioMixerSinkTimerUpdate(pThis->SinkCenterLFE.pMixSink, pThis->cTimerTicks, cTicksElapsed);
4143 AudioMixerSinkTimerUpdate(pThis->SinkRear.pMixSink, pThis->cTimerTicks, cTicksElapsed);
4144
4145 /** @todo Check for stream interleaving and only call hdaTransfer() if required! */
4146#endif
4147
4148#ifdef VBOX_WITH_HDA_51_SURROUND
4149 /*
4150 * Only call hdaTransfer if CenterLFE and/or Rear are on different SDs,
4151 * otherwise we have to use the interleaved streams support for getting the data
4152 * out of the Front sink (depending on the mapping layout).
4153 */
4154#endif
4155
4156 if ( ASMAtomicReadBool(&pThis->fTimerActive)
4157 || fKickTimer)
4158 {
4159 /* Kick the timer again. */
4160 uint64_t cTicks = pThis->cTimerTicks;
4161 /** @todo adjust cTicks down by now much cbOutMin represents. */
4162 TMTimerSet(pThis->pTimer, cTicksNow + cTicks);
4163 }
4164
4165 LogFlowFuncLeave();
4166
4167 STAM_PROFILE_STOP(&pThis->StatTimer, a);
4168}
4169
4170#else /* VBOX_WITH_AUDIO_CALLBACKS */
4171
4172static DECLCALLBACK(int) hdaCallbackInput(PDMAUDIOCALLBACKTYPE enmType, void *pvCtx, size_t cbCtx, void *pvUser, size_t cbUser)
4173{
4174 Assert(enmType == PDMAUDIOCALLBACKTYPE_INPUT);
4175 AssertPtrReturn(pvCtx, VERR_INVALID_POINTER);
4176 AssertReturn(cbCtx, VERR_INVALID_PARAMETER);
4177 AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
4178 AssertReturn(cbUser, VERR_INVALID_PARAMETER);
4179
4180 PHDACALLBACKCTX pCtx = (PHDACALLBACKCTX)pvCtx;
4181 AssertReturn(cbCtx == sizeof(HDACALLBACKCTX), VERR_INVALID_PARAMETER);
4182
4183 PPDMAUDIOCALLBACKDATAIN pData = (PPDMAUDIOCALLBACKDATAIN)pvUser;
4184 AssertReturn(cbUser == sizeof(PDMAUDIOCALLBACKDATAIN), VERR_INVALID_PARAMETER);
4185
4186 return hdaTransfer(pCtx->pThis, PI_INDEX, UINT32_MAX, &pData->cbOutRead);
4187}
4188
4189static DECLCALLBACK(int) hdaCallbackOutput(PDMAUDIOCALLBACKTYPE enmType, void *pvCtx, size_t cbCtx, void *pvUser, size_t cbUser)
4190{
4191 Assert(enmType == PDMAUDIOCALLBACKTYPE_OUTPUT);
4192 AssertPtrReturn(pvCtx, VERR_INVALID_POINTER);
4193 AssertReturn(cbCtx, VERR_INVALID_PARAMETER);
4194 AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
4195 AssertReturn(cbUser, VERR_INVALID_PARAMETER);
4196
4197 PHDACALLBACKCTX pCtx = (PHDACALLBACKCTX)pvCtx;
4198 AssertReturn(cbCtx == sizeof(HDACALLBACKCTX), VERR_INVALID_PARAMETER);
4199
4200 PPDMAUDIOCALLBACKDATAOUT pData = (PPDMAUDIOCALLBACKDATAOUT)pvUser;
4201 AssertReturn(cbUser == sizeof(PDMAUDIOCALLBACKDATAOUT), VERR_INVALID_PARAMETER);
4202
4203 PHDASTATE pThis = pCtx->pThis;
4204
4205 int rc = hdaTransfer(pCtx->pThis, PO_INDEX, UINT32_MAX, &pData->cbOutWritten);
4206 if ( RT_SUCCESS(rc)
4207 && pData->cbOutWritten)
4208 {
4209 PHDADRIVER pDrv;
4210 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
4211 {
4212 uint32_t cSamplesPlayed;
4213 int rc2 = pDrv->pConnector->pfnPlay(pDrv->pConnector, &cSamplesPlayed);
4214 LogFlowFunc(("LUN#%RU8: cSamplesPlayed=%RU32, rc=%Rrc\n", pDrv->uLUN, cSamplesPlayed, rc2));
4215 }
4216 }
4217}
4218#endif /* VBOX_WITH_AUDIO_CALLBACKS */
4219
4220static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStream)
4221{
4222 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
4223 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
4224
4225 if (ASMAtomicReadBool(&pThis->fInReset)) /* HDA controller in reset mode? Bail out. */
4226 {
4227 LogFlowFunc(("HDA in reset mode, skipping\n"));
4228 return VINF_SUCCESS;
4229 }
4230
4231 bool fProceed = true;
4232 int rc = RTSemMutexRequest(pStream->State.hMtx, RT_INDEFINITE_WAIT);
4233 if (RT_FAILURE(rc))
4234 return rc;
4235
4236 Log3Func(("[SD%RU8] fActive=%RTbool\n", pStream->u8SD, pStream->State.fActive));
4237
4238 /* Stop request received? */
4239 if ( !pStream->State.fActive
4240 || pStream->State.fDoStop)
4241 {
4242 pStream->State.fActive = false;
4243
4244 rc = RTSemEventSignal(pStream->State.hStateChangedEvent);
4245 AssertRC(rc);
4246
4247 fProceed = false;
4248 }
4249 /* Is the stream not in a running state currently? */
4250 else if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
4251 fProceed = false;
4252
4253 if ((HDA_STREAM_REG(pThis, STS, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
4254 {
4255 Log3Func(("[SD%RU8]: BCIS set\n", pStream->u8SD));
4256 fProceed = false;
4257 }
4258
4259 if (!fProceed)
4260 {
4261 Log3Func(("[SD%RU8]: Skipping\n", pStream->u8SD));
4262
4263 rc = RTSemMutexRelease(pStream->State.hMtx);
4264 AssertRC(rc);
4265
4266 return VINF_SUCCESS;
4267 }
4268
4269 /* Sanity checks. */
4270 Assert(pStream->u8SD <= HDA_MAX_STREAMS);
4271 Assert(pStream->u64BDLBase);
4272 Assert(pStream->u32CBL);
4273
4274 /* State sanity checks. */
4275 Assert(pStream->State.fInReset == false);
4276
4277 uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
4278 Assert(u32LPIB <= pStream->u32CBL);
4279
4280 bool fInterrupt = false;
4281
4282#ifdef DEBUG_andy
4283# define DEBUG_SIMPLE
4284#endif
4285
4286#ifdef DEBUG_SIMPLE
4287 uint8_t u8FIFO[_16K+1];
4288 size_t u8FIFOff = 0;
4289#endif
4290
4291 uint32_t cbToProcess = 0;
4292 uint32_t cbProcessed = 0;
4293 uint32_t cbProcessedTotal = 0;
4294
4295 /* Set the FIFORDY bit on the stream while doing the transfer. */
4296 HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
4297
4298 do
4299 {
4300 /* Do we need to fetch the next Buffer Descriptor Entry (BDLE)? */
4301 if (hdaStreamNeedsNextBDLE(pThis, pStream))
4302 {
4303 rc = hdaStreamGetNextBDLE(pThis, pStream);
4304 if (RT_FAILURE(rc))
4305 break;
4306 }
4307
4308 cbToProcess = hdaStreamGetTransferSize(pThis, pStream, _4K /** @todo Fix this */);
4309 cbProcessed = 0;
4310
4311 if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
4312 rc = hdaReadAudio(pThis, pStream, cbToProcess, &cbProcessed);
4313 else
4314 {
4315#ifndef DEBUG_SIMPLE
4316 rc = hdaWriteAudio(pThis, pStream, cbToProcess, &cbProcessed);
4317#else
4318 uint32_t cbToWrite = hdaStreamGetTransferSize(pThis, pStream, cbToProcess);
4319
4320 void *pvBuf = u8FIFO + u8FIFOff;
4321 int32_t cbBuf = cbToWrite;
4322
4323 PHDABDLE pBDLE = &pStream->State.BDLE;
4324
4325 rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
4326 pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
4327 pvBuf, cbBuf);
4328
4329 hdaBDLEUpdate(pBDLE, cbToWrite, cbToWrite);
4330
4331 u8FIFOff += cbToWrite;
4332 Assert((u8FIFOff & 1) == 0);
4333 Assert(u8FIFOff <= sizeof(u8FIFO));
4334
4335 cbProcessed = cbToWrite;
4336#endif
4337 }
4338
4339 if (RT_FAILURE(rc))
4340 break;
4341
4342 hdaStreamTransferUpdate(pThis, pStream, cbProcessed);
4343
4344 cbProcessedTotal += cbProcessed;
4345
4346 if (rc == VINF_EOF)
4347 break;
4348
4349 if (hdaStreamTransferIsComplete(pThis, pStream, &fInterrupt))
4350 break;
4351
4352 } while (RT_SUCCESS(rc));
4353
4354 /* Remove the FIFORDY bit again. */
4355 HDA_STREAM_REG(pThis, STS, pStream->u8SD) &= ~HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
4356
4357 LogFlowFunc(("[SD%RU8]: %RU32 / %RU32, rc=%Rrc\n", pStream->u8SD, cbProcessedTotal, cbToProcess, rc));
4358
4359#ifdef DEBUG_SIMPLE
4360# ifdef HDA_DEBUG_DUMP_PCM_DATA
4361 RTFILE fh;
4362 RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaWriteAudio.pcm",
4363 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
4364 RTFileWrite(fh, u8FIFO, u8FIFOff, NULL);
4365 RTFileClose(fh);
4366# endif
4367
4368 AudioMixerSinkWrite(pThis->SinkFront.pMixSink, AUDMIXOP_COPY, u8FIFO, u8FIFOff,
4369 NULL /* pcbWritten */);
4370#endif /* DEBUG_SIMPLE */
4371
4372 if (fInterrupt)
4373 {
4374 /**
4375 * Set the BCIS (Buffer Completion Interrupt Status) flag as the
4376 * last byte of data for the current descriptor has been fetched
4377 * from memory and put into the DMA FIFO.
4378 *
4379 * Speech synthesis works fine on Mac Guest if this bit isn't set
4380 * but in general sound quality gets worse.
4381 *
4382 * This must be set in *any* case.
4383 */
4384 HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
4385 Log3Func(("[SD%RU8]: BCIS: Set\n", pStream->u8SD));
4386
4387 hdaProcessInterrupt(pThis);
4388 }
4389
4390 int rc2 = RTSemMutexRelease(pStream->State.hMtx);
4391 if (RT_SUCCESS(rc))
4392 rc = rc2;
4393
4394 return rc;
4395}
4396#endif /* IN_RING3 */
4397
4398/* MMIO callbacks */
4399
4400/**
4401 * @callback_method_impl{FNIOMMMIOREAD, Looks up and calls the appropriate handler.}
4402 *
4403 * @note During implementation, we discovered so-called "forgotten" or "hole"
4404 * registers whose description is not listed in the RPM, datasheet, or
4405 * spec.
4406 */
4407PDMBOTHCBDECL(int) hdaMMIORead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
4408{
4409 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
4410 int rc;
4411
4412 /*
4413 * Look up and log.
4414 */
4415 uint32_t offReg = GCPhysAddr - pThis->MMIOBaseAddr;
4416 int idxRegDsc = hdaRegLookup(pThis, offReg); /* Register descriptor index. */
4417#ifdef LOG_ENABLED
4418 unsigned const cbLog = cb;
4419 uint32_t offRegLog = offReg;
4420#endif
4421
4422 Log3Func(("offReg=%#x cb=%#x\n", offReg, cb));
4423 Assert(cb == 4); Assert((offReg & 3) == 0);
4424
4425 if (pThis->fInReset && idxRegDsc != HDA_REG_GCTL)
4426 LogFunc(("Access to registers except GCTL is blocked while reset\n"));
4427
4428 if (idxRegDsc == -1)
4429 LogRel(("HDA: Invalid read access @0x%x (bytes=%u)\n", offReg, cb));
4430
4431 if (idxRegDsc != -1)
4432 {
4433 /* ASSUMES gapless DWORD at end of map. */
4434 if (g_aHdaRegMap[idxRegDsc].size == 4)
4435 {
4436 /*
4437 * Straight forward DWORD access.
4438 */
4439 rc = g_aHdaRegMap[idxRegDsc].pfnRead(pThis, idxRegDsc, (uint32_t *)pv);
4440 Log3Func(("\tRead %s => %x (%Rrc)\n", g_aHdaRegMap[idxRegDsc].abbrev, *(uint32_t *)pv, rc));
4441 }
4442 else
4443 {
4444 /*
4445 * Multi register read (unless there are trailing gaps).
4446 * ASSUMES that only DWORD reads have sideeffects.
4447 */
4448 uint32_t u32Value = 0;
4449 unsigned cbLeft = 4;
4450 do
4451 {
4452 uint32_t const cbReg = g_aHdaRegMap[idxRegDsc].size;
4453 uint32_t u32Tmp = 0;
4454
4455 rc = g_aHdaRegMap[idxRegDsc].pfnRead(pThis, idxRegDsc, &u32Tmp);
4456 Log3Func(("\tRead %s[%db] => %x (%Rrc)*\n", g_aHdaRegMap[idxRegDsc].abbrev, cbReg, u32Tmp, rc));
4457 if (rc != VINF_SUCCESS)
4458 break;
4459 u32Value |= (u32Tmp & g_afMasks[cbReg]) << ((4 - cbLeft) * 8);
4460
4461 cbLeft -= cbReg;
4462 offReg += cbReg;
4463 idxRegDsc++;
4464 } while (cbLeft > 0 && g_aHdaRegMap[idxRegDsc].offset == offReg);
4465
4466 if (rc == VINF_SUCCESS)
4467 *(uint32_t *)pv = u32Value;
4468 else
4469 Assert(!IOM_SUCCESS(rc));
4470 }
4471 }
4472 else
4473 {
4474 rc = VINF_IOM_MMIO_UNUSED_FF;
4475 Log3Func(("\tHole at %x is accessed for read\n", offReg));
4476 }
4477
4478 /*
4479 * Log the outcome.
4480 */
4481#ifdef LOG_ENABLED
4482 if (cbLog == 4)
4483 Log3Func(("\tReturning @%#05x -> %#010x %Rrc\n", offRegLog, *(uint32_t *)pv, rc));
4484 else if (cbLog == 2)
4485 Log3Func(("\tReturning @%#05x -> %#06x %Rrc\n", offRegLog, *(uint16_t *)pv, rc));
4486 else if (cbLog == 1)
4487 Log3Func(("\tReturning @%#05x -> %#04x %Rrc\n", offRegLog, *(uint8_t *)pv, rc));
4488#endif
4489 return rc;
4490}
4491
4492
4493DECLINLINE(int) hdaWriteReg(PHDASTATE pThis, int idxRegDsc, uint32_t u32Value, char const *pszLog)
4494{
4495 if (pThis->fInReset && idxRegDsc != HDA_REG_GCTL)
4496 {
4497 LogRel2(("HDA: Warning: Access to register 0x%x is blocked while reset\n", idxRegDsc));
4498 return VINF_SUCCESS;
4499 }
4500
4501 uint32_t idxRegMem = g_aHdaRegMap[idxRegDsc].mem_idx;
4502#ifdef LOG_ENABLED
4503 uint32_t const u32CurValue = pThis->au32Regs[idxRegMem];
4504#endif
4505 int rc = g_aHdaRegMap[idxRegDsc].pfnWrite(pThis, idxRegDsc, u32Value);
4506 Log3Func(("Written value %#x to %s[%d byte]; %x => %x%s\n", u32Value, g_aHdaRegMap[idxRegDsc].abbrev,
4507 g_aHdaRegMap[idxRegDsc].size, u32CurValue, pThis->au32Regs[idxRegMem], pszLog));
4508 return rc;
4509}
4510
4511
4512/**
4513 * @callback_method_impl{FNIOMMMIOWRITE, Looks up and calls the appropriate handler.}
4514 */
4515PDMBOTHCBDECL(int) hdaMMIOWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void const *pv, unsigned cb)
4516{
4517 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
4518 int rc;
4519
4520 /*
4521 * The behavior of accesses that aren't aligned on natural boundraries is
4522 * undefined. Just reject them outright.
4523 */
4524 /** @todo IOM could check this, it could also split the 8 byte accesses for us. */
4525 Assert(cb == 1 || cb == 2 || cb == 4 || cb == 8);
4526 if (GCPhysAddr & (cb - 1))
4527 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "misaligned write access: GCPhysAddr=%RGp cb=%u\n", GCPhysAddr, cb);
4528
4529 /*
4530 * Look up and log the access.
4531 */
4532 uint32_t offReg = GCPhysAddr - pThis->MMIOBaseAddr;
4533 int idxRegDsc = hdaRegLookup(pThis, offReg);
4534 uint32_t idxRegMem = idxRegDsc != -1 ? g_aHdaRegMap[idxRegDsc].mem_idx : UINT32_MAX;
4535 uint64_t u64Value;
4536 if (cb == 4) u64Value = *(uint32_t const *)pv;
4537 else if (cb == 2) u64Value = *(uint16_t const *)pv;
4538 else if (cb == 1) u64Value = *(uint8_t const *)pv;
4539 else if (cb == 8) u64Value = *(uint64_t const *)pv;
4540 else
4541 {
4542 u64Value = 0; /* shut up gcc. */
4543 AssertReleaseMsgFailed(("%u\n", cb));
4544 }
4545
4546#ifdef LOG_ENABLED
4547 uint32_t const u32LogOldValue = idxRegDsc >= 0 ? pThis->au32Regs[idxRegMem] : UINT32_MAX;
4548 if (idxRegDsc == -1)
4549 Log3Func(("@%#05x u32=%#010x cb=%d\n", offReg, *(uint32_t const *)pv, cb));
4550 else if (cb == 4)
4551 Log3Func(("@%#05x u32=%#010x %s\n", offReg, *(uint32_t *)pv, g_aHdaRegMap[idxRegDsc].abbrev));
4552 else if (cb == 2)
4553 Log3Func(("@%#05x u16=%#06x (%#010x) %s\n", offReg, *(uint16_t *)pv, *(uint32_t *)pv, g_aHdaRegMap[idxRegDsc].abbrev));
4554 else if (cb == 1)
4555 Log3Func(("@%#05x u8=%#04x (%#010x) %s\n", offReg, *(uint8_t *)pv, *(uint32_t *)pv, g_aHdaRegMap[idxRegDsc].abbrev));
4556
4557 if (idxRegDsc >= 0 && g_aHdaRegMap[idxRegDsc].size != cb)
4558 Log3Func(("\tsize=%RU32 != cb=%u!!\n", g_aHdaRegMap[idxRegDsc].size, cb));
4559#endif
4560
4561 /*
4562 * Try for a direct hit first.
4563 */
4564 if (idxRegDsc != -1 && g_aHdaRegMap[idxRegDsc].size == cb)
4565 {
4566 rc = hdaWriteReg(pThis, idxRegDsc, u64Value, "");
4567 Log3Func(("\t%#x -> %#x\n", u32LogOldValue, idxRegMem != UINT32_MAX ? pThis->au32Regs[idxRegMem] : UINT32_MAX));
4568 }
4569 /*
4570 * Partial or multiple register access, loop thru the requested memory.
4571 */
4572 else
4573 {
4574 /*
4575 * If it's an access beyond the start of the register, shift the input
4576 * value and fill in missing bits. Natural alignment rules means we
4577 * will only see 1 or 2 byte accesses of this kind, so no risk of
4578 * shifting out input values.
4579 */
4580 if (idxRegDsc == -1 && (idxRegDsc = hdaRegLookupWithin(pThis, offReg)) != -1)
4581 {
4582 uint32_t const cbBefore = offReg - g_aHdaRegMap[idxRegDsc].offset; Assert(cbBefore > 0 && cbBefore < 4);
4583 offReg -= cbBefore;
4584 idxRegMem = g_aHdaRegMap[idxRegDsc].mem_idx;
4585 u64Value <<= cbBefore * 8;
4586 u64Value |= pThis->au32Regs[idxRegMem] & g_afMasks[cbBefore];
4587 Log3Func(("\tWithin register, supplied %u leading bits: %#llx -> %#llx ...\n",
4588 cbBefore * 8, ~g_afMasks[cbBefore] & u64Value, u64Value));
4589 }
4590
4591 /* Loop thru the write area, it may cover multiple registers. */
4592 rc = VINF_SUCCESS;
4593 for (;;)
4594 {
4595 uint32_t cbReg;
4596 if (idxRegDsc != -1)
4597 {
4598 idxRegMem = g_aHdaRegMap[idxRegDsc].mem_idx;
4599 cbReg = g_aHdaRegMap[idxRegDsc].size;
4600 if (cb < cbReg)
4601 {
4602 u64Value |= pThis->au32Regs[idxRegMem] & g_afMasks[cbReg] & ~g_afMasks[cb];
4603 Log3Func(("\tSupplying missing bits (%#x): %#llx -> %#llx ...\n",
4604 g_afMasks[cbReg] & ~g_afMasks[cb], u64Value & g_afMasks[cb], u64Value));
4605 }
4606 uint32_t u32LogOldVal = pThis->au32Regs[idxRegMem];
4607 rc = hdaWriteReg(pThis, idxRegDsc, u64Value, "*");
4608 Log3Func(("\t%#x -> %#x\n", u32LogOldVal, pThis->au32Regs[idxRegMem]));
4609 }
4610 else
4611 {
4612 LogRel(("HDA: Invalid write access @0x%x\n", offReg));
4613 cbReg = 1;
4614 }
4615 if (rc != VINF_SUCCESS)
4616 break;
4617 if (cbReg >= cb)
4618 break;
4619
4620 /* Advance. */
4621 offReg += cbReg;
4622 cb -= cbReg;
4623 u64Value >>= cbReg * 8;
4624 if (idxRegDsc == -1)
4625 idxRegDsc = hdaRegLookup(pThis, offReg);
4626 else
4627 {
4628 idxRegDsc++;
4629 if ( (unsigned)idxRegDsc >= RT_ELEMENTS(g_aHdaRegMap)
4630 || g_aHdaRegMap[idxRegDsc].offset != offReg)
4631 {
4632 idxRegDsc = -1;
4633 }
4634 }
4635 }
4636 }
4637
4638 return rc;
4639}
4640
4641
4642/* PCI callback. */
4643
4644#ifdef IN_RING3
4645/**
4646 * @callback_method_impl{FNPCIIOREGIONMAP}
4647 */
4648static DECLCALLBACK(int) hdaPciIoRegionMap(PPCIDEVICE pPciDev, int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb,
4649 PCIADDRESSSPACE enmType)
4650{
4651 PPDMDEVINS pDevIns = pPciDev->pDevIns;
4652 PHDASTATE pThis = RT_FROM_MEMBER(pPciDev, HDASTATE, PciDev);
4653 RTIOPORT Port = (RTIOPORT)GCPhysAddress;
4654 int rc;
4655
4656 /*
4657 * 18.2 of the ICH6 datasheet defines the valid access widths as byte, word, and double word.
4658 *
4659 * Let IOM talk DWORDs when reading, saves a lot of complications. On
4660 * writing though, we have to do it all ourselves because of sideeffects.
4661 */
4662 Assert(enmType == PCI_ADDRESS_SPACE_MEM);
4663 rc = PDMDevHlpMMIORegister(pDevIns, GCPhysAddress, cb, NULL /*pvUser*/,
4664 IOMMMIO_FLAGS_READ_DWORD
4665 | IOMMMIO_FLAGS_WRITE_PASSTHRU,
4666 hdaMMIOWrite, hdaMMIORead, "HDA");
4667
4668 if (RT_FAILURE(rc))
4669 return rc;
4670
4671 if (pThis->fR0Enabled)
4672 {
4673 rc = PDMDevHlpMMIORegisterR0(pDevIns, GCPhysAddress, cb, NIL_RTR0PTR /*pvUser*/,
4674 "hdaMMIOWrite", "hdaMMIORead");
4675 if (RT_FAILURE(rc))
4676 return rc;
4677 }
4678
4679 if (pThis->fRCEnabled)
4680 {
4681 rc = PDMDevHlpMMIORegisterRC(pDevIns, GCPhysAddress, cb, NIL_RTRCPTR /*pvUser*/,
4682 "hdaMMIOWrite", "hdaMMIORead");
4683 if (RT_FAILURE(rc))
4684 return rc;
4685 }
4686
4687 pThis->MMIOBaseAddr = GCPhysAddress;
4688 return VINF_SUCCESS;
4689}
4690
4691
4692/* Saved state callbacks. */
4693
4694static int hdaSaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStrm)
4695{
4696 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
4697
4698 LogFlowFunc(("[SD%RU8]\n", pStrm->u8SD));
4699
4700 /* Save stream ID. */
4701 int rc = SSMR3PutU8(pSSM, pStrm->u8SD);
4702 AssertRCReturn(rc, rc);
4703 Assert(pStrm->u8SD <= HDA_MAX_STREAMS);
4704
4705 rc = SSMR3PutStructEx(pSSM, &pStrm->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields6, NULL);
4706 AssertRCReturn(rc, rc);
4707
4708#ifdef DEBUG /* Sanity checks. */
4709 uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStrm->u8SD),
4710 HDA_STREAM_REG(pThis, BDPU, pStrm->u8SD));
4711 uint16_t u16LVI = HDA_STREAM_REG(pThis, LVI, pStrm->u8SD);
4712 uint32_t u32CBL = HDA_STREAM_REG(pThis, CBL, pStrm->u8SD);
4713
4714 hdaBDLEDumpAll(pThis, u64BaseDMA, u16LVI + 1);
4715
4716 Assert(u64BaseDMA == pStrm->u64BDLBase);
4717 Assert(u16LVI == pStrm->u16LVI);
4718 Assert(u32CBL == pStrm->u32CBL);
4719#endif
4720
4721 rc = SSMR3PutStructEx(pSSM, &pStrm->State.BDLE, sizeof(HDABDLE),
4722 0 /*fFlags*/, g_aSSMBDLEFields6, NULL);
4723 AssertRCReturn(rc, rc);
4724
4725 rc = SSMR3PutStructEx(pSSM, &pStrm->State.BDLE.State, sizeof(HDABDLESTATE),
4726 0 /*fFlags*/, g_aSSMBDLEStateFields6, NULL);
4727 AssertRCReturn(rc, rc);
4728
4729#ifdef DEBUG /* Sanity checks. */
4730 PHDABDLE pBDLE = &pStrm->State.BDLE;
4731 if (u64BaseDMA)
4732 {
4733 Assert(pStrm->State.uCurBDLE <= u16LVI + 1);
4734
4735 HDABDLE curBDLE;
4736 rc = hdaBDLEFetch(pThis, &curBDLE, u64BaseDMA, pStrm->State.uCurBDLE);
4737 AssertRC(rc);
4738
4739 Assert(curBDLE.u32BufSize == pBDLE->u32BufSize);
4740 Assert(curBDLE.u64BufAdr == pBDLE->u64BufAdr);
4741 Assert(curBDLE.fIntOnCompletion == pBDLE->fIntOnCompletion);
4742 }
4743 else
4744 {
4745 Assert(pBDLE->u64BufAdr == 0);
4746 Assert(pBDLE->u32BufSize == 0);
4747 }
4748#endif
4749 return rc;
4750}
4751
4752/**
4753 * @callback_method_impl{FNSSMDEVSAVEEXEC}
4754 */
4755static DECLCALLBACK(int) hdaSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
4756{
4757 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
4758
4759 /* Save Codec nodes states. */
4760 hdaCodecSaveState(pThis->pCodec, pSSM);
4761
4762 /* Save MMIO registers. */
4763 SSMR3PutU32(pSSM, RT_ELEMENTS(pThis->au32Regs));
4764 SSMR3PutMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
4765
4766 /* Save number of streams. */
4767 SSMR3PutU32(pSSM, HDA_MAX_STREAMS);
4768
4769 /* Save stream states. */
4770 int rc;
4771 for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
4772 {
4773 rc = hdaSaveStream(pDevIns, pSSM, &pThis->aStreams[i]);
4774 AssertRCReturn(rc, rc);
4775 }
4776
4777 return rc;
4778}
4779
4780
4781/**
4782 * @callback_method_impl{FNSSMDEVLOADEXEC}
4783 */
4784static DECLCALLBACK(int) hdaLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
4785{
4786 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
4787
4788 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
4789
4790 LogRel2(("hdaLoadExec: uVersion=%RU32, uPass=0x%x\n", uVersion, uPass));
4791
4792 /*
4793 * Load Codec nodes states.
4794 */
4795 int rc = hdaCodecLoadState(pThis->pCodec, pSSM, uVersion);
4796 if (RT_FAILURE(rc))
4797 {
4798 LogRel(("HDA: Failed loading codec state (version %RU32, pass 0x%x), rc=%Rrc\n", uVersion, uPass, rc));
4799 return rc;
4800 }
4801
4802 /*
4803 * Load MMIO registers.
4804 */
4805 uint32_t cRegs;
4806 switch (uVersion)
4807 {
4808 case HDA_SSM_VERSION_1:
4809 /* Starting with r71199, we would save 112 instead of 113
4810 registers due to some code cleanups. This only affected trunk
4811 builds in the 4.1 development period. */
4812 cRegs = 113;
4813 if (SSMR3HandleRevision(pSSM) >= 71199)
4814 {
4815 uint32_t uVer = SSMR3HandleVersion(pSSM);
4816 if ( VBOX_FULL_VERSION_GET_MAJOR(uVer) == 4
4817 && VBOX_FULL_VERSION_GET_MINOR(uVer) == 0
4818 && VBOX_FULL_VERSION_GET_BUILD(uVer) >= 51)
4819 cRegs = 112;
4820 }
4821 break;
4822
4823 case HDA_SSM_VERSION_2:
4824 case HDA_SSM_VERSION_3:
4825 cRegs = 112;
4826 AssertCompile(RT_ELEMENTS(pThis->au32Regs) >= 112);
4827 break;
4828
4829 /* Since version 4 we store the register count to stay flexible. */
4830 case HDA_SSM_VERSION_4:
4831 case HDA_SSM_VERSION_5:
4832 case HDA_SSM_VERSION:
4833 rc = SSMR3GetU32(pSSM, &cRegs); AssertRCReturn(rc, rc);
4834 if (cRegs != RT_ELEMENTS(pThis->au32Regs))
4835 LogRel(("HDA: SSM version cRegs is %RU32, expected %RU32\n", cRegs, RT_ELEMENTS(pThis->au32Regs)));
4836 break;
4837
4838 default:
4839 LogRel(("HDA: Unsupported / too new saved state version (%RU32)\n", uVersion));
4840 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
4841 }
4842
4843 if (cRegs >= RT_ELEMENTS(pThis->au32Regs))
4844 {
4845 SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
4846 SSMR3Skip(pSSM, sizeof(uint32_t) * (cRegs - RT_ELEMENTS(pThis->au32Regs)));
4847 }
4848 else
4849 SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(uint32_t) * cRegs);
4850
4851 /*
4852 * Note: Saved states < v5 store LVI (u32BdleMaxCvi) for
4853 * *every* BDLE state, whereas it only needs to be stored
4854 * *once* for every stream. Most of the BDLE state we can
4855 * get out of the registers anyway, so just ignore those values.
4856 *
4857 * Also, only the current BDLE was saved, regardless whether
4858 * there were more than one (and there are at least two entries,
4859 * according to the spec).
4860 */
4861#define HDA_SSM_LOAD_BDLE_STATE_PRE_V5(v, x) \
4862 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* Begin marker */ \
4863 AssertRCReturn(rc, rc); \
4864 rc = SSMR3GetU64(pSSM, &x.u64BufAdr); /* u64BdleCviAddr */ \
4865 AssertRCReturn(rc, rc); \
4866 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* u32BdleMaxCvi */ \
4867 AssertRCReturn(rc, rc); \
4868 rc = SSMR3GetU32(pSSM, &x.State.u32BDLIndex); /* u32BdleCvi */ \
4869 AssertRCReturn(rc, rc); \
4870 rc = SSMR3GetU32(pSSM, &x.u32BufSize); /* u32BdleCviLen */ \
4871 AssertRCReturn(rc, rc); \
4872 rc = SSMR3GetU32(pSSM, &x.State.u32BufOff); /* u32BdleCviPos */ \
4873 AssertRCReturn(rc, rc); \
4874 rc = SSMR3GetBool(pSSM, &x.fIntOnCompletion); /* fBdleCviIoc */ \
4875 AssertRCReturn(rc, rc); \
4876 rc = SSMR3GetU32(pSSM, &x.State.cbBelowFIFOW); /* cbUnderFifoW */ \
4877 AssertRCReturn(rc, rc); \
4878 rc = SSMR3GetMem(pSSM, &x.State.au8FIFO, sizeof(x.State.au8FIFO)); \
4879 AssertRCReturn(rc, rc); \
4880 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* End marker */ \
4881 AssertRCReturn(rc, rc); \
4882
4883 /*
4884 * Load BDLEs (Buffer Descriptor List Entries) and DMA counters.
4885 */
4886 switch (uVersion)
4887 {
4888 case HDA_SSM_VERSION_1:
4889 case HDA_SSM_VERSION_2:
4890 case HDA_SSM_VERSION_3:
4891 case HDA_SSM_VERSION_4:
4892 {
4893 /* Only load the internal states.
4894 * The rest will be initialized from the saved registers later. */
4895
4896 /* Note 1: Only the *current* BDLE for a stream was saved! */
4897 /* Note 2: The stream's saving order is/was fixed, so don't touch! */
4898
4899 /* Output */
4900 PHDASTREAM pStream = &pThis->aStreams[4];
4901 rc = hdaStreamInit(pThis, pStream, 4 /* Stream descriptor, hardcoded */);
4902 if (RT_FAILURE(rc))
4903 break;
4904 HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
4905 pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
4906
4907 /* Microphone-In */
4908 pStream = &pThis->aStreams[2];
4909 rc = hdaStreamInit(pThis, pStream, 2 /* Stream descriptor, hardcoded */);
4910 if (RT_FAILURE(rc))
4911 break;
4912 HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
4913 pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
4914
4915 /* Line-In */
4916 pStream = &pThis->aStreams[0];
4917 rc = hdaStreamInit(pThis, pStream, 0 /* Stream descriptor, hardcoded */);
4918 if (RT_FAILURE(rc))
4919 break;
4920 HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
4921 pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
4922 break;
4923 }
4924
4925 /* Since v5 we support flexible stream and BDLE counts. */
4926 case HDA_SSM_VERSION_5:
4927 case HDA_SSM_VERSION:
4928 {
4929 uint32_t cStreams;
4930 rc = SSMR3GetU32(pSSM, &cStreams);
4931 if (RT_FAILURE(rc))
4932 break;
4933
4934 LogRel2(("hdaLoadExec: cStreams=%RU32\n", cStreams));
4935
4936 /* Load stream states. */
4937 for (uint32_t i = 0; i < cStreams; i++)
4938 {
4939 uint8_t uSD;
4940 rc = SSMR3GetU8(pSSM, &uSD);
4941 if (RT_FAILURE(rc))
4942 break;
4943
4944 PHDASTREAM pStrm = hdaStreamFromSD(pThis, uSD);
4945 HDASTREAM StreamDummy;
4946
4947 if (!pStrm)
4948 {
4949 RT_ZERO(StreamDummy);
4950 pStrm = &StreamDummy;
4951 LogRel2(("HDA: Warning: Stream ID=%RU32 not supported, skipping to load ...\n", uSD));
4952 break;
4953 }
4954
4955 rc = hdaStreamInit(pThis, pStrm, uSD);
4956 if (RT_FAILURE(rc))
4957 {
4958 LogRel(("HDA: Stream #%RU32: Initialization of stream %RU8 failed, rc=%Rrc\n", i, uSD, rc));
4959 break;
4960 }
4961
4962 if (uVersion == HDA_SSM_VERSION_5)
4963 {
4964 /* Get the current BDLE entry and skip the rest. */
4965 uint16_t cBDLE;
4966
4967 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* Begin marker */
4968 AssertRC(rc);
4969 rc = SSMR3GetU16(pSSM, &cBDLE); /* cBDLE */
4970 AssertRC(rc);
4971 rc = SSMR3GetU16(pSSM, &pStrm->State.uCurBDLE); /* uCurBDLE */
4972 AssertRC(rc);
4973 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* End marker */
4974 AssertRC(rc);
4975
4976 uint32_t u32BDLEIndex;
4977 for (uint16_t a = 0; a < cBDLE; a++)
4978 {
4979 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* Begin marker */
4980 AssertRC(rc);
4981 rc = SSMR3GetU32(pSSM, &u32BDLEIndex); /* u32BDLIndex */
4982 AssertRC(rc);
4983
4984 /* Does the current BDLE index match the current BDLE to process? */
4985 if (u32BDLEIndex == pStrm->State.uCurBDLE)
4986 {
4987 rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.cbBelowFIFOW); /* cbBelowFIFOW */
4988 AssertRC(rc);
4989 rc = SSMR3GetMem(pSSM,
4990 &pStrm->State.BDLE.State.au8FIFO,
4991 sizeof(pStrm->State.BDLE.State.au8FIFO)); /* au8FIFO */
4992 AssertRC(rc);
4993 rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.u32BufOff); /* u32BufOff */
4994 AssertRC(rc);
4995 rc = SSMR3Skip(pSSM, sizeof(uint32_t)); /* End marker */
4996 AssertRC(rc);
4997 }
4998 else /* Skip not current BDLEs. */
4999 {
5000 rc = SSMR3Skip(pSSM, sizeof(uint32_t) /* cbBelowFIFOW */
5001 + sizeof(uint8_t) * 256 /* au8FIFO */
5002 + sizeof(uint32_t) /* u32BufOff */
5003 + sizeof(uint32_t)); /* End marker */
5004 AssertRC(rc);
5005 }
5006 }
5007 }
5008 else
5009 {
5010 rc = SSMR3GetStructEx(pSSM, &pStrm->State, sizeof(HDASTREAMSTATE),
5011 0 /* fFlags */, g_aSSMStreamStateFields6, NULL);
5012 if (RT_FAILURE(rc))
5013 break;
5014
5015 rc = SSMR3GetStructEx(pSSM, &pStrm->State.BDLE, sizeof(HDABDLE),
5016 0 /* fFlags */, g_aSSMBDLEFields6, NULL);
5017 if (RT_FAILURE(rc))
5018 break;
5019
5020 rc = SSMR3GetStructEx(pSSM, &pStrm->State.BDLE.State, sizeof(HDABDLESTATE),
5021 0 /* fFlags */, g_aSSMBDLEStateFields6, NULL);
5022 if (RT_FAILURE(rc))
5023 break;
5024 }
5025 }
5026 break;
5027 }
5028
5029 default:
5030 AssertReleaseFailed(); /* Never reached. */
5031 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
5032 }
5033
5034#undef HDA_SSM_LOAD_BDLE_STATE_PRE_V5
5035
5036 if (RT_SUCCESS(rc))
5037 {
5038 pThis->u64CORBBase = RT_MAKE_U64(HDA_REG(pThis, CORBLBASE), HDA_REG(pThis, CORBUBASE));
5039 pThis->u64RIRBBase = RT_MAKE_U64(HDA_REG(pThis, RIRBLBASE), HDA_REG(pThis, RIRBUBASE));
5040 pThis->u64DPBase = RT_MAKE_U64(HDA_REG(pThis, DPLBASE), HDA_REG(pThis, DPUBASE));
5041
5042 /* Also make sure to update the DMA position bit if this was enabled when saving the state. */
5043 pThis->fDMAPosition = RT_BOOL(pThis->u64DPBase & RT_BIT_64(0));
5044 }
5045
5046 if (RT_SUCCESS(rc))
5047 {
5048 for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
5049 {
5050 PHDASTREAM pStream = hdaStreamFromSD(pThis, i);
5051 if (pStream)
5052 {
5053 bool fActive = RT_BOOL(HDA_STREAM_REG(pThis, CTL, i) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
5054 LogFlowFunc(("[SD%RU8]: fActive=%RTbool\n", i, fActive));
5055 int rc2 = hdaStreamSetActive(pThis, pStream, fActive);
5056 AssertRC(rc2);
5057 }
5058 }
5059 }
5060
5061 if (RT_FAILURE(rc))
5062 LogRel(("HDA: Failed loading device state (version %RU32, pass 0x%x), rc=%Rrc\n", uVersion, uPass, rc));
5063
5064 LogFlowFuncLeaveRC(rc);
5065 return rc;
5066}
5067
5068#ifdef DEBUG
5069/* Debug and log type formatters. */
5070
5071/**
5072 * @callback_method_impl{FNRTSTRFORMATTYPE}
5073 */
5074static DECLCALLBACK(size_t) hdaDbgFmtBDLE(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
5075 const char *pszType, void const *pvValue,
5076 int cchWidth, int cchPrecision, unsigned fFlags,
5077 void *pvUser)
5078{
5079 PHDABDLE pBDLE = (PHDABDLE)pvValue;
5080 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
5081 "BDLE(idx:%RU32, off:%RU32, fifow:%RU32, IOC:%RTbool, DMA[%RU32 bytes @ 0x%x])",
5082 pBDLE->State.u32BDLIndex, pBDLE->State.u32BufOff, pBDLE->State.cbBelowFIFOW, pBDLE->fIntOnCompletion,
5083 pBDLE->u32BufSize, pBDLE->u64BufAdr);
5084}
5085
5086/**
5087 * @callback_method_impl{FNRTSTRFORMATTYPE}
5088 */
5089static DECLCALLBACK(size_t) hdaDbgFmtSDCTL(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
5090 const char *pszType, void const *pvValue,
5091 int cchWidth, int cchPrecision, unsigned fFlags,
5092 void *pvUser)
5093{
5094 uint32_t uSDCTL = (uint32_t)(uintptr_t)pvValue;
5095 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
5096 "SDCTL(raw:%#x, DIR:%s, TP:%RTbool, STRIPE:%x, DEIE:%RTbool, FEIE:%RTbool, IOCE:%RTbool, RUN:%RTbool, RESET:%RTbool)",
5097 uSDCTL,
5098 (uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, DIR)) ? "OUT" : "IN",
5099 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, TP)),
5100 (uSDCTL & HDA_REG_FIELD_MASK(SDCTL, STRIPE)) >> HDA_SDCTL_STRIPE_SHIFT,
5101 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, DEIE)),
5102 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, FEIE)),
5103 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE)),
5104 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
5105 RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST)));
5106}
5107
5108/**
5109 * @callback_method_impl{FNRTSTRFORMATTYPE}
5110 */
5111static DECLCALLBACK(size_t) hdaDbgFmtSDFIFOS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
5112 const char *pszType, void const *pvValue,
5113 int cchWidth, int cchPrecision, unsigned fFlags,
5114 void *pvUser)
5115{
5116 uint32_t uSDFIFOS = (uint32_t)(uintptr_t)pvValue;
5117 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOS(raw:%#x, sdfifos:%RU8 B)", uSDFIFOS, hdaSDFIFOSToBytes(uSDFIFOS));
5118}
5119
5120/**
5121 * @callback_method_impl{FNRTSTRFORMATTYPE}
5122 */
5123static DECLCALLBACK(size_t) hdaDbgFmtSDFIFOW(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
5124 const char *pszType, void const *pvValue,
5125 int cchWidth, int cchPrecision, unsigned fFlags,
5126 void *pvUser)
5127{
5128 uint32_t uSDFIFOW = (uint32_t)(uintptr_t)pvValue;
5129 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOW(raw: %#0x, sdfifow:%d B)", uSDFIFOW, hdaSDFIFOWToBytes(uSDFIFOW));
5130}
5131
5132/**
5133 * @callback_method_impl{FNRTSTRFORMATTYPE}
5134 */
5135static DECLCALLBACK(size_t) hdaDbgFmtSDSTS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
5136 const char *pszType, void const *pvValue,
5137 int cchWidth, int cchPrecision, unsigned fFlags,
5138 void *pvUser)
5139{
5140 uint32_t uSdSts = (uint32_t)(uintptr_t)pvValue;
5141 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
5142 "SDSTS(raw:%#0x, fifordy:%RTbool, dese:%RTbool, fifoe:%RTbool, bcis:%RTbool)",
5143 uSdSts,
5144 RT_BOOL(uSdSts & HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY)),
5145 RT_BOOL(uSdSts & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE)),
5146 RT_BOOL(uSdSts & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE)),
5147 RT_BOOL(uSdSts & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)));
5148}
5149
5150static int hdaDbgLookupRegByName(PHDASTATE pThis, const char *pszArgs)
5151{
5152 int iReg = 0;
5153 for (; iReg < HDA_NUM_REGS; ++iReg)
5154 if (!RTStrICmp(g_aHdaRegMap[iReg].abbrev, pszArgs))
5155 return iReg;
5156 return -1;
5157}
5158
5159
5160static void hdaDbgPrintRegister(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iHdaIndex)
5161{
5162 Assert( pThis
5163 && iHdaIndex >= 0
5164 && iHdaIndex < HDA_NUM_REGS);
5165 pHlp->pfnPrintf(pHlp, "%s: 0x%x\n", g_aHdaRegMap[iHdaIndex].abbrev, pThis->au32Regs[g_aHdaRegMap[iHdaIndex].mem_idx]);
5166}
5167
5168/**
5169 * @callback_method_impl{FNDBGFHANDLERDEV}
5170 */
5171static DECLCALLBACK(void) hdaDbgInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5172{
5173 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5174 int iHdaRegisterIndex = hdaDbgLookupRegByName(pThis, pszArgs);
5175 if (iHdaRegisterIndex != -1)
5176 hdaDbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
5177 else
5178 {
5179 for(iHdaRegisterIndex = 0; (unsigned int)iHdaRegisterIndex < HDA_NUM_REGS; ++iHdaRegisterIndex)
5180 hdaDbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
5181 }
5182}
5183
5184static void hdaDbgPrintStream(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
5185{
5186 Assert( pThis
5187 && iIdx >= 0
5188 && iIdx < HDA_MAX_STREAMS);
5189
5190 const PHDASTREAM pStrm = &pThis->aStreams[iIdx];
5191
5192 pHlp->pfnPrintf(pHlp, "Stream #%d:\n", iIdx);
5193 pHlp->pfnPrintf(pHlp, "\tSD%dCTL : %R[sdctl]\n", iIdx, HDA_STREAM_REG(pThis, CTL, iIdx));
5194 pHlp->pfnPrintf(pHlp, "\tSD%dCTS : %R[sdsts]\n", iIdx, HDA_STREAM_REG(pThis, STS, iIdx));
5195 pHlp->pfnPrintf(pHlp, "\tSD%dFIFOS: %R[sdfifos]\n", iIdx, HDA_STREAM_REG(pThis, FIFOS, iIdx));
5196 pHlp->pfnPrintf(pHlp, "\tSD%dFIFOW: %R[sdfifow]\n", iIdx, HDA_STREAM_REG(pThis, FIFOW, iIdx));
5197 pHlp->pfnPrintf(pHlp, "\tBDLE : %R[bdle]\n", &pStrm->State.BDLE);
5198}
5199
5200static void hdaDbgPrintBDLE(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
5201{
5202 Assert( pThis
5203 && iIdx >= 0
5204 && iIdx < HDA_MAX_STREAMS);
5205
5206 const PHDASTREAM pStrm = &pThis->aStreams[iIdx];
5207 const PHDABDLE pBDLE = &pStrm->State.BDLE;
5208
5209 pHlp->pfnPrintf(pHlp, "Stream #%d BDLE:\n", iIdx);
5210 pHlp->pfnPrintf(pHlp, "\t%R[bdle]\n", pBDLE);
5211
5212 uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, iIdx),
5213 HDA_STREAM_REG(pThis, BDPU, iIdx));
5214 uint16_t u16LVI = HDA_STREAM_REG(pThis, LVI, iIdx);
5215 uint32_t u32CBL = HDA_STREAM_REG(pThis, CBL, iIdx);
5216
5217 if (!u64BaseDMA)
5218 return;
5219
5220 uint32_t cbBDLE = 0;
5221 for (uint16_t i = 0; i < u16LVI + 1; i++)
5222 {
5223 uint8_t bdle[16]; /** @todo Use a define. */
5224 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BaseDMA + i * 16, bdle, 16); /** @todo Use a define. */
5225
5226 uint64_t addr = *(uint64_t *)bdle;
5227 uint32_t len = *(uint32_t *)&bdle[8];
5228 uint32_t ioc = *(uint32_t *)&bdle[12];
5229
5230 pHlp->pfnPrintf(pHlp, "\t#%03d BDLE(adr:0x%llx, size:%RU32, ioc:%RTbool)\n",
5231 i, addr, len, RT_BOOL(ioc & 0x1));
5232
5233 cbBDLE += len;
5234 }
5235
5236 pHlp->pfnPrintf(pHlp, "Total: %RU32 bytes\n", cbBDLE);
5237
5238 pHlp->pfnPrintf(pHlp, "DMA counters (base @ 0x%llx):\n", pThis->u64DPBase);
5239 if (!pThis->u64DPBase) /* No DMA base given? Bail out. */
5240 {
5241 pHlp->pfnPrintf(pHlp, "No counters found\n");
5242 return;
5243 }
5244
5245 for (int i = 0; i < u16LVI + 1; i++)
5246 {
5247 uint32_t uDMACnt;
5248 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
5249 &uDMACnt, sizeof(uDMACnt));
5250
5251 pHlp->pfnPrintf(pHlp, "\t#%03d DMA @ 0x%x\n", i , uDMACnt);
5252 }
5253}
5254
5255static int hdaDbgLookupStrmIdx(PHDASTATE pThis, const char *pszArgs)
5256{
5257 /** @todo Add args parsing. */
5258 return -1;
5259}
5260
5261/**
5262 * @callback_method_impl{FNDBGFHANDLERDEV}
5263 */
5264static DECLCALLBACK(void) hdaDbgInfoStream(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5265{
5266 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5267 int iHdaStreamdex = hdaDbgLookupStrmIdx(pThis, pszArgs);
5268 if (iHdaStreamdex != -1)
5269 hdaDbgPrintStream(pThis, pHlp, iHdaStreamdex);
5270 else
5271 for(iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
5272 hdaDbgPrintStream(pThis, pHlp, iHdaStreamdex);
5273}
5274
5275/**
5276 * @callback_method_impl{FNDBGFHANDLERDEV}
5277 */
5278static DECLCALLBACK(void) hdaDbgInfoBDLE(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5279{
5280 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5281 int iHdaStreamdex = hdaDbgLookupStrmIdx(pThis, pszArgs);
5282 if (iHdaStreamdex != -1)
5283 hdaDbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
5284 else
5285 for(iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
5286 hdaDbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
5287}
5288
5289/**
5290 * @callback_method_impl{FNDBGFHANDLERDEV}
5291 */
5292static DECLCALLBACK(void) hdaDbgInfoCodecNodes(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5293{
5294 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5295
5296 if (pThis->pCodec->pfnDbgListNodes)
5297 pThis->pCodec->pfnDbgListNodes(pThis->pCodec, pHlp, pszArgs);
5298 else
5299 pHlp->pfnPrintf(pHlp, "Codec implementation doesn't provide corresponding callback\n");
5300}
5301
5302/**
5303 * @callback_method_impl{FNDBGFHANDLERDEV}
5304 */
5305static DECLCALLBACK(void) hdaDbgInfoCodecSelector(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5306{
5307 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5308
5309 if (pThis->pCodec->pfnDbgSelector)
5310 pThis->pCodec->pfnDbgSelector(pThis->pCodec, pHlp, pszArgs);
5311 else
5312 pHlp->pfnPrintf(pHlp, "Codec implementation doesn't provide corresponding callback\n");
5313}
5314
5315/**
5316 * @callback_method_impl{FNDBGFHANDLERDEV}
5317 */
5318static DECLCALLBACK(void) hdaDbgInfoMixer(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
5319{
5320 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5321
5322 if (pThis->pMixer)
5323 AudioMixerDebug(pThis->pMixer, pHlp, pszArgs);
5324 else
5325 pHlp->pfnPrintf(pHlp, "Mixer not available\n");
5326}
5327#endif /* DEBUG */
5328
5329/* PDMIBASE */
5330
5331/**
5332 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
5333 */
5334static DECLCALLBACK(void *) hdaQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
5335{
5336 PHDASTATE pThis = RT_FROM_MEMBER(pInterface, HDASTATE, IBase);
5337 Assert(&pThis->IBase == pInterface);
5338
5339 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
5340 return NULL;
5341}
5342
5343
5344/* PDMDEVREG */
5345
5346/**
5347 * Reset notification.
5348 *
5349 * @returns VBox status code.
5350 * @param pDevIns The device instance data.
5351 *
5352 * @remark The original sources didn't install a reset handler, but it seems to
5353 * make sense to me so we'll do it.
5354 */
5355static DECLCALLBACK(void) hdaReset(PPDMDEVINS pDevIns)
5356{
5357 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5358
5359 LogFlowFuncEnter();
5360
5361# ifndef VBOX_WITH_AUDIO_CALLBACKS
5362 /*
5363 * Stop the timer, if any.
5364 */
5365 hdaTimerMaybeStop(pThis);
5366# endif
5367
5368 /* See 6.2.1. */
5369 HDA_REG(pThis, GCAP) = HDA_MAKE_GCAP(HDA_MAX_SDO /* Ouput streams */,
5370 HDA_MAX_SDI /* Input streams */,
5371 0 /* Bidirectional output streams */,
5372 0 /* Serial data out signals */,
5373 1 /* 64-bit */);
5374 HDA_REG(pThis, VMIN) = 0x00; /* see 6.2.2 */
5375 HDA_REG(pThis, VMAJ) = 0x01; /* see 6.2.3 */
5376 /* Announce the full 60 words output payload. */
5377 HDA_REG(pThis, OUTPAY) = 0x003C; /* see 6.2.4 */
5378 /* Announce the full 29 words input payload. */
5379 HDA_REG(pThis, INPAY) = 0x001D; /* see 6.2.5 */
5380 HDA_REG(pThis, CORBSIZE) = 0x42; /* see 6.2.1 */
5381 HDA_REG(pThis, RIRBSIZE) = 0x42; /* see 6.2.1 */
5382 HDA_REG(pThis, CORBRP) = 0x0;
5383 HDA_REG(pThis, RIRBWP) = 0x0;
5384
5385 /*
5386 * Stop any audio currently playing and/or recording.
5387 */
5388 AudioMixerSinkCtl(pThis->SinkFront.pMixSink, AUDMIXSINKCMD_DISABLE);
5389# ifdef VBOX_WITH_HDA_MIC_IN
5390 AudioMixerSinkCtl(pThis->SinkMicIn.pMixSink, AUDMIXSINKCMD_DISABLE);
5391# endif
5392 AudioMixerSinkCtl(pThis->SinkLineIn.pMixSink, AUDMIXSINKCMD_DISABLE);
5393# ifdef VBOX_WITH_HDA_51_SURROUND
5394 AudioMixerSinkCtl(pThis->SinkCenterLFE.pMixSink, AUDMIXSINKCMD_DISABLE);
5395 AudioMixerSinkCtl(pThis->SinkRear.pMixSink, AUDMIXSINKCMD_DISABLE);
5396# endif
5397
5398 /*
5399 * Set some sensible defaults for which HDA sinks
5400 * are connected to which stream number.
5401 *
5402 * We use SD0 for input and SD4 for output by default.
5403 * These stream numbers can be changed by the guest dynamically lateron.
5404 */
5405#ifdef VBOX_WITH_HDA_MIC_IN
5406 hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_MIC_IN , 1 /* SD0 */, 0 /* Channel */);
5407#endif
5408 hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_LINE_IN , 1 /* SD0 */, 0 /* Channel */);
5409
5410 hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_FRONT , 5 /* SD4 */, 0 /* Channel */);
5411#ifdef VBOX_WITH_HDA_51_SURROUND
5412 hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
5413 hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_REAR , 5 /* SD4 */, 0 /* Channel */);
5414#endif
5415
5416 pThis->cbCorbBuf = 256 * sizeof(uint32_t); /** @todo Use a define here. */
5417
5418 if (pThis->pu32CorbBuf)
5419 RT_BZERO(pThis->pu32CorbBuf, pThis->cbCorbBuf);
5420 else
5421 pThis->pu32CorbBuf = (uint32_t *)RTMemAllocZ(pThis->cbCorbBuf);
5422
5423 pThis->cbRirbBuf = 256 * sizeof(uint64_t); /** @todo Use a define here. */
5424 if (pThis->pu64RirbBuf)
5425 RT_BZERO(pThis->pu64RirbBuf, pThis->cbRirbBuf);
5426 else
5427 pThis->pu64RirbBuf = (uint64_t *)RTMemAllocZ(pThis->cbRirbBuf);
5428
5429 pThis->u64BaseTS = PDMDevHlpTMTimeVirtGetNano(pDevIns);
5430
5431 for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
5432 {
5433 /* Remove the RUN bit from SDnCTL in case the stream was in a running state before. */
5434 HDA_STREAM_REG(pThis, CTL, i) &= ~HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN);
5435 hdaStreamReset(pThis, &pThis->aStreams[i]);
5436 }
5437
5438 /* Clear stream tags <-> objects mapping table. */
5439 RT_ZERO(pThis->aTags);
5440
5441 /* Emulation of codec "wake up" (HDA spec 5.5.1 and 6.5). */
5442 HDA_REG(pThis, STATESTS) = 0x1;
5443
5444# ifndef VBOX_WITH_AUDIO_CALLBACKS
5445 hdaTimerMaybeStart(pThis);
5446# endif
5447
5448 LogFlowFuncLeave();
5449 LogRel(("HDA: Reset\n"));
5450}
5451
5452/**
5453 * @interface_method_impl{PDMDEVREG,pfnDestruct}
5454 */
5455static DECLCALLBACK(int) hdaDestruct(PPDMDEVINS pDevIns)
5456{
5457 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5458
5459 PHDADRIVER pDrv;
5460 while (!RTListIsEmpty(&pThis->lstDrv))
5461 {
5462 pDrv = RTListGetFirst(&pThis->lstDrv, HDADRIVER, Node);
5463
5464 RTListNodeRemove(&pDrv->Node);
5465 RTMemFree(pDrv);
5466 }
5467
5468 if (pThis->pCodec)
5469 {
5470 hdaCodecDestruct(pThis->pCodec);
5471
5472 RTMemFree(pThis->pCodec);
5473 pThis->pCodec = NULL;
5474 }
5475
5476 RTMemFree(pThis->pu32CorbBuf);
5477 pThis->pu32CorbBuf = NULL;
5478
5479 RTMemFree(pThis->pu64RirbBuf);
5480 pThis->pu64RirbBuf = NULL;
5481
5482 for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
5483 hdaStreamDestroy(&pThis->aStreams[i]);
5484
5485 return VINF_SUCCESS;
5486}
5487
5488
5489/**
5490 * Attach command, internal version.
5491 *
5492 * This is called to let the device attach to a driver for a specified LUN
5493 * during runtime. This is not called during VM construction, the device
5494 * constructor has to attach to all the available drivers.
5495 *
5496 * @returns VBox status code.
5497 * @param pDevIns The device instance.
5498 * @param pDrv Driver to (re-)use for (re-)attaching to.
5499 * If NULL is specified, a new driver will be created and appended
5500 * to the driver list.
5501 * @param uLUN The logical unit which is being detached.
5502 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
5503 */
5504static int hdaAttachInternal(PPDMDEVINS pDevIns, PHDADRIVER pDrv, unsigned uLUN, uint32_t fFlags)
5505{
5506 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5507
5508 /*
5509 * Attach driver.
5510 */
5511 char *pszDesc = NULL;
5512 if (RTStrAPrintf(&pszDesc, "Audio driver port (HDA) for LUN#%u", uLUN) <= 0)
5513 AssertReleaseMsgReturn(pszDesc,
5514 ("Not enough memory for HDA driver port description of LUN #%u\n", uLUN),
5515 VERR_NO_MEMORY);
5516
5517 PPDMIBASE pDrvBase;
5518 int rc = PDMDevHlpDriverAttach(pDevIns, uLUN,
5519 &pThis->IBase, &pDrvBase, pszDesc);
5520 if (RT_SUCCESS(rc))
5521 {
5522 if (pDrv == NULL)
5523 pDrv = (PHDADRIVER)RTMemAllocZ(sizeof(HDADRIVER));
5524 if (pDrv)
5525 {
5526 pDrv->pDrvBase = pDrvBase;
5527 pDrv->pConnector = PDMIBASE_QUERY_INTERFACE(pDrvBase, PDMIAUDIOCONNECTOR);
5528 AssertMsg(pDrv->pConnector != NULL, ("Configuration error: LUN#%u has no host audio interface, rc=%Rrc\n", uLUN, rc));
5529 pDrv->pHDAState = pThis;
5530 pDrv->uLUN = uLUN;
5531
5532 /*
5533 * For now we always set the driver at LUN 0 as our primary
5534 * host backend. This might change in the future.
5535 */
5536 if (pDrv->uLUN == 0)
5537 pDrv->Flags |= PDMAUDIODRVFLAG_PRIMARY;
5538
5539 LogFunc(("LUN#%u: pCon=%p, drvFlags=0x%x\n", uLUN, pDrv->pConnector, pDrv->Flags));
5540
5541 /* Attach to driver list if not attached yet. */
5542 if (!pDrv->fAttached)
5543 {
5544 RTListAppend(&pThis->lstDrv, &pDrv->Node);
5545 pDrv->fAttached = true;
5546 }
5547 }
5548 else
5549 rc = VERR_NO_MEMORY;
5550 }
5551 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
5552 LogFunc(("No attached driver for LUN #%u\n", uLUN));
5553
5554 if (RT_FAILURE(rc))
5555 {
5556 /* Only free this string on failure;
5557 * must remain valid for the live of the driver instance. */
5558 RTStrFree(pszDesc);
5559 }
5560
5561 LogFunc(("uLUN=%u, fFlags=0x%x, rc=%Rrc\n", uLUN, fFlags, rc));
5562 return rc;
5563}
5564
5565/**
5566 * Attach command.
5567 *
5568 * This is called to let the device attach to a driver for a specified LUN
5569 * during runtime. This is not called during VM construction, the device
5570 * constructor has to attach to all the available drivers.
5571 *
5572 * @returns VBox status code.
5573 * @param pDevIns The device instance.
5574 * @param uLUN The logical unit which is being detached.
5575 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
5576 */
5577static DECLCALLBACK(int) hdaAttach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
5578{
5579 return hdaAttachInternal(pDevIns, NULL /* pDrv */, uLUN, fFlags);
5580}
5581
5582static DECLCALLBACK(void) hdaDetach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
5583{
5584 LogFunc(("iLUN=%u, fFlags=0x%x\n", uLUN, fFlags));
5585}
5586
5587/**
5588 * Powers off the device.
5589 *
5590 * @param pDevIns Device instance to power off.
5591 */
5592static DECLCALLBACK(void) hdaPowerOff(PPDMDEVINS pDevIns)
5593{
5594 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5595
5596 LogRel2(("HDA: Powering off ...\n"));
5597
5598 /* Ditto goes for the codec, which in turn uses the mixer. */
5599 hdaCodecPowerOff(pThis->pCodec);
5600
5601 /**
5602 * Note: Destroy the mixer while powering off and *not* in hdaDestruct,
5603 * giving the mixer the chance to release any references held to
5604 * PDM audio streams it maintains.
5605 */
5606 if (pThis->pMixer)
5607 {
5608 AudioMixerDestroy(pThis->pMixer);
5609 pThis->pMixer = NULL;
5610 }
5611}
5612
5613/**
5614 * Re-attaches a new driver to the device's driver chain.
5615 *
5616 * @returns VBox status code.
5617 * @param pThis Device instance to re-attach driver to.
5618 * @param pDrv Driver instance used for attaching to.
5619 * If NULL is specified, a new driver will be created and appended
5620 * to the driver list.
5621 * @param uLUN The logical unit which is being re-detached.
5622 * @param pszDriver Driver name.
5623 */
5624static int hdaReattach(PHDASTATE pThis, PHDADRIVER pDrv, uint8_t uLUN, const char *pszDriver)
5625{
5626 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
5627 AssertPtrReturn(pszDriver, VERR_INVALID_POINTER);
5628
5629 PVM pVM = PDMDevHlpGetVM(pThis->pDevInsR3);
5630 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
5631 PCFGMNODE pDev0 = CFGMR3GetChild(pRoot, "Devices/hda/0/");
5632
5633 /* Remove LUN branch. */
5634 CFGMR3RemoveNode(CFGMR3GetChildF(pDev0, "LUN#%u/", uLUN));
5635
5636 if (pDrv)
5637 {
5638 /* Re-use a driver instance => detach the driver before. */
5639 int rc = PDMDevHlpDriverDetach(pThis->pDevInsR3, PDMIBASE_2_PDMDRV(pDrv->pDrvBase), 0 /* fFlags */);
5640 if (RT_FAILURE(rc))
5641 return rc;
5642 }
5643
5644#define RC_CHECK() if (RT_FAILURE(rc)) { AssertReleaseRC(rc); break; }
5645
5646 int rc = VINF_SUCCESS;
5647 do
5648 {
5649 PCFGMNODE pLunL0;
5650 rc = CFGMR3InsertNodeF(pDev0, &pLunL0, "LUN#%u/", uLUN); RC_CHECK();
5651 rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); RC_CHECK();
5652 rc = CFGMR3InsertNode(pLunL0, "Config/", NULL); RC_CHECK();
5653
5654 PCFGMNODE pLunL1, pLunL2;
5655 rc = CFGMR3InsertNode (pLunL0, "AttachedDriver/", &pLunL1); RC_CHECK();
5656 rc = CFGMR3InsertNode (pLunL1, "Config/", &pLunL2); RC_CHECK();
5657 rc = CFGMR3InsertString(pLunL1, "Driver", pszDriver); RC_CHECK();
5658
5659 rc = CFGMR3InsertString(pLunL2, "AudioDriver", pszDriver); RC_CHECK();
5660
5661 } while (0);
5662
5663 if (RT_SUCCESS(rc))
5664 rc = hdaAttachInternal(pThis->pDevInsR3, pDrv, uLUN, 0 /* fFlags */);
5665
5666 LogFunc(("pThis=%p, uLUN=%u, pszDriver=%s, rc=%Rrc\n", pThis, uLUN, pszDriver, rc));
5667
5668#undef RC_CHECK
5669
5670 return rc;
5671}
5672
5673/**
5674 * @interface_method_impl{PDMDEVREG,pfnConstruct}
5675 */
5676static DECLCALLBACK(int) hdaConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
5677{
5678 PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
5679 Assert(iInstance == 0);
5680 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
5681
5682 /*
5683 * Validations.
5684 */
5685 if (!CFGMR3AreValuesValid(pCfg, "R0Enabled\0"
5686 "RCEnabled\0"
5687 "TimerHz\0"))
5688 return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
5689 N_ ("Invalid configuration for the Intel HDA device"));
5690
5691 int rc = CFGMR3QueryBoolDef(pCfg, "RCEnabled", &pThis->fRCEnabled, false);
5692 if (RT_FAILURE(rc))
5693 return PDMDEV_SET_ERROR(pDevIns, rc,
5694 N_("HDA configuration error: failed to read RCEnabled as boolean"));
5695 rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &pThis->fR0Enabled, false);
5696 if (RT_FAILURE(rc))
5697 return PDMDEV_SET_ERROR(pDevIns, rc,
5698 N_("HDA configuration error: failed to read R0Enabled as boolean"));
5699#ifndef VBOX_WITH_AUDIO_CALLBACKS
5700 uint16_t uTimerHz;
5701 rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 100 /* Hz */);
5702 if (RT_FAILURE(rc))
5703 return PDMDEV_SET_ERROR(pDevIns, rc,
5704 N_("HDA configuration error: failed to read Hertz (Hz) rate as unsigned integer"));
5705#endif
5706
5707 /*
5708 * Initialize data (most of it anyway).
5709 */
5710 pThis->pDevInsR3 = pDevIns;
5711 pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
5712 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
5713 /* IBase */
5714 pThis->IBase.pfnQueryInterface = hdaQueryInterface;
5715
5716 /* PCI Device */
5717 PCIDevSetVendorId (&pThis->PciDev, HDA_PCI_VENDOR_ID); /* nVidia */
5718 PCIDevSetDeviceId (&pThis->PciDev, HDA_PCI_DEVICE_ID); /* HDA */
5719
5720 PCIDevSetCommand (&pThis->PciDev, 0x0000); /* 04 rw,ro - pcicmd. */
5721 PCIDevSetStatus (&pThis->PciDev, VBOX_PCI_STATUS_CAP_LIST); /* 06 rwc?,ro? - pcists. */
5722 PCIDevSetRevisionId (&pThis->PciDev, 0x01); /* 08 ro - rid. */
5723 PCIDevSetClassProg (&pThis->PciDev, 0x00); /* 09 ro - pi. */
5724 PCIDevSetClassSub (&pThis->PciDev, 0x03); /* 0a ro - scc; 03 == HDA. */
5725 PCIDevSetClassBase (&pThis->PciDev, 0x04); /* 0b ro - bcc; 04 == multimedia. */
5726 PCIDevSetHeaderType (&pThis->PciDev, 0x00); /* 0e ro - headtyp. */
5727 PCIDevSetBaseAddress (&pThis->PciDev, 0, /* 10 rw - MMIO */
5728 false /* fIoSpace */, false /* fPrefetchable */, true /* f64Bit */, 0x00000000);
5729 PCIDevSetInterruptLine (&pThis->PciDev, 0x00); /* 3c rw. */
5730 PCIDevSetInterruptPin (&pThis->PciDev, 0x01); /* 3d ro - INTA#. */
5731
5732#if defined(HDA_AS_PCI_EXPRESS)
5733 PCIDevSetCapabilityList (&pThis->PciDev, 0x80);
5734#elif defined(VBOX_WITH_MSI_DEVICES)
5735 PCIDevSetCapabilityList (&pThis->PciDev, 0x60);
5736#else
5737 PCIDevSetCapabilityList (&pThis->PciDev, 0x50); /* ICH6 datasheet 18.1.16 */
5738#endif
5739
5740 /// @todo r=michaln: If there are really no PCIDevSetXx for these, the meaning
5741 /// of these values needs to be properly documented!
5742 /* HDCTL off 0x40 bit 0 selects signaling mode (1-HDA, 0 - Ac97) 18.1.19 */
5743 PCIDevSetByte(&pThis->PciDev, 0x40, 0x01);
5744
5745 /* Power Management */
5746 PCIDevSetByte(&pThis->PciDev, 0x50 + 0, VBOX_PCI_CAP_ID_PM);
5747 PCIDevSetByte(&pThis->PciDev, 0x50 + 1, 0x0); /* next */
5748 PCIDevSetWord(&pThis->PciDev, 0x50 + 2, VBOX_PCI_PM_CAP_DSI | 0x02 /* version, PM1.1 */ );
5749
5750#ifdef HDA_AS_PCI_EXPRESS
5751 /* PCI Express */
5752 PCIDevSetByte(&pThis->PciDev, 0x80 + 0, VBOX_PCI_CAP_ID_EXP); /* PCI_Express */
5753 PCIDevSetByte(&pThis->PciDev, 0x80 + 1, 0x60); /* next */
5754 /* Device flags */
5755 PCIDevSetWord(&pThis->PciDev, 0x80 + 2,
5756 /* version */ 0x1 |
5757 /* Root Complex Integrated Endpoint */ (VBOX_PCI_EXP_TYPE_ROOT_INT_EP << 4) |
5758 /* MSI */ (100) << 9 );
5759 /* Device capabilities */
5760 PCIDevSetDWord(&pThis->PciDev, 0x80 + 4, VBOX_PCI_EXP_DEVCAP_FLRESET);
5761 /* Device control */
5762 PCIDevSetWord( &pThis->PciDev, 0x80 + 8, 0);
5763 /* Device status */
5764 PCIDevSetWord( &pThis->PciDev, 0x80 + 10, 0);
5765 /* Link caps */
5766 PCIDevSetDWord(&pThis->PciDev, 0x80 + 12, 0);
5767 /* Link control */
5768 PCIDevSetWord( &pThis->PciDev, 0x80 + 16, 0);
5769 /* Link status */
5770 PCIDevSetWord( &pThis->PciDev, 0x80 + 18, 0);
5771 /* Slot capabilities */
5772 PCIDevSetDWord(&pThis->PciDev, 0x80 + 20, 0);
5773 /* Slot control */
5774 PCIDevSetWord( &pThis->PciDev, 0x80 + 24, 0);
5775 /* Slot status */
5776 PCIDevSetWord( &pThis->PciDev, 0x80 + 26, 0);
5777 /* Root control */
5778 PCIDevSetWord( &pThis->PciDev, 0x80 + 28, 0);
5779 /* Root capabilities */
5780 PCIDevSetWord( &pThis->PciDev, 0x80 + 30, 0);
5781 /* Root status */
5782 PCIDevSetDWord(&pThis->PciDev, 0x80 + 32, 0);
5783 /* Device capabilities 2 */
5784 PCIDevSetDWord(&pThis->PciDev, 0x80 + 36, 0);
5785 /* Device control 2 */
5786 PCIDevSetQWord(&pThis->PciDev, 0x80 + 40, 0);
5787 /* Link control 2 */
5788 PCIDevSetQWord(&pThis->PciDev, 0x80 + 48, 0);
5789 /* Slot control 2 */
5790 PCIDevSetWord( &pThis->PciDev, 0x80 + 56, 0);
5791#endif
5792
5793 /*
5794 * Register the PCI device.
5795 */
5796 rc = PDMDevHlpPCIRegister(pDevIns, &pThis->PciDev);
5797 if (RT_FAILURE(rc))
5798 return rc;
5799
5800 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x4000, PCI_ADDRESS_SPACE_MEM, hdaPciIoRegionMap);
5801 if (RT_FAILURE(rc))
5802 return rc;
5803
5804#ifdef VBOX_WITH_MSI_DEVICES
5805 PDMMSIREG MsiReg;
5806 RT_ZERO(MsiReg);
5807 MsiReg.cMsiVectors = 1;
5808 MsiReg.iMsiCapOffset = 0x60;
5809 MsiReg.iMsiNextOffset = 0x50;
5810 rc = PDMDevHlpPCIRegisterMsi(pDevIns, &MsiReg);
5811 if (RT_FAILURE(rc))
5812 {
5813 /* That's OK, we can work without MSI */
5814 PCIDevSetCapabilityList(&pThis->PciDev, 0x50);
5815 }
5816#endif
5817
5818 rc = PDMDevHlpSSMRegister(pDevIns, HDA_SSM_VERSION, sizeof(*pThis), hdaSaveExec, hdaLoadExec);
5819 if (RT_FAILURE(rc))
5820 return rc;
5821
5822 RTListInit(&pThis->lstDrv);
5823
5824 uint8_t uLUN;
5825 for (uLUN = 0; uLUN < UINT8_MAX; ++uLUN)
5826 {
5827 LogFunc(("Trying to attach driver for LUN #%RU32 ...\n", uLUN));
5828 rc = hdaAttachInternal(pDevIns, NULL /* pDrv */, uLUN, 0 /* fFlags */);
5829 if (RT_FAILURE(rc))
5830 {
5831 if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
5832 rc = VINF_SUCCESS;
5833 else if (rc == VERR_AUDIO_BACKEND_INIT_FAILED)
5834 {
5835 hdaReattach(pThis, NULL /* pDrv */, uLUN, "NullAudio");
5836 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
5837 N_("No audio devices could be opened. Selecting the NULL audio backend "
5838 "with the consequence that no sound is audible"));
5839 /* attaching to the NULL audio backend will never fail */
5840 rc = VINF_SUCCESS;
5841 }
5842 break;
5843 }
5844 }
5845
5846 LogFunc(("cLUNs=%RU8, rc=%Rrc\n", uLUN, rc));
5847
5848 if (RT_SUCCESS(rc))
5849 {
5850 rc = AudioMixerCreate("HDA Mixer", 0 /* uFlags */, &pThis->pMixer);
5851 if (RT_SUCCESS(rc))
5852 {
5853 /* Set a default audio format for our mixer. */
5854 PDMAUDIOSTREAMCFG streamCfg;
5855 streamCfg.uHz = 44100;
5856 streamCfg.cChannels = 2;
5857 streamCfg.enmFormat = PDMAUDIOFMT_S16;
5858 streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
5859
5860 rc = AudioMixerSetDeviceFormat(pThis->pMixer, &streamCfg);
5861 AssertRC(rc);
5862
5863 /*
5864 * Add mixer output sinks.
5865 */
5866#ifdef VBOX_WITH_HDA_51_SURROUND
5867 rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Front",
5868 AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
5869 AssertRC(rc);
5870 rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Center / Subwoofer",
5871 AUDMIXSINKDIR_OUTPUT, &pThis->SinkCenterLFE.pMixSink);
5872 AssertRC(rc);
5873 rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Rear",
5874 AUDMIXSINKDIR_OUTPUT, &pThis->SinkRear.pMixSink);
5875 AssertRC(rc);
5876#else
5877 rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output",
5878 AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
5879 AssertRC(rc);
5880#endif
5881 /*
5882 * Add mixer input sinks.
5883 */
5884 rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Line In",
5885 AUDMIXSINKDIR_INPUT, &pThis->SinkLineIn.pMixSink);
5886 AssertRC(rc);
5887#ifdef VBOX_WITH_HDA_MIC_IN
5888 rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Microphone In",
5889 AUDMIXSINKDIR_INPUT, &pThis->SinkMicIn.pMixSink);
5890 AssertRC(rc);
5891#endif
5892 /* There is no master volume control. Set the master to max. */
5893 PDMAUDIOVOLUME vol = { false, 255, 255 };
5894 rc = AudioMixerSetMasterVolume(pThis->pMixer, &vol);
5895 AssertRC(rc);
5896 }
5897 }
5898
5899 if (RT_SUCCESS(rc))
5900 {
5901 /* Construct codec. */
5902 pThis->pCodec = (PHDACODEC)RTMemAllocZ(sizeof(HDACODEC));
5903 if (!pThis->pCodec)
5904 return PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY, N_("Out of memory allocating HDA codec state"));
5905
5906 /* Set codec callbacks. */
5907 pThis->pCodec->pfnMixerAddStream = hdaMixerAddStream;
5908 pThis->pCodec->pfnMixerRemoveStream = hdaMixerRemoveStream;
5909 pThis->pCodec->pfnMixerSetStream = hdaMixerSetStream;
5910 pThis->pCodec->pfnMixerSetVolume = hdaMixerSetVolume;
5911 pThis->pCodec->pfnReset = hdaCodecReset;
5912
5913 pThis->pCodec->pHDAState = pThis; /* Assign HDA controller state to codec. */
5914
5915 /* Construct the codec. */
5916 rc = hdaCodecConstruct(pDevIns, pThis->pCodec, 0 /* Codec index */, pCfg);
5917 if (RT_FAILURE(rc))
5918 AssertRCReturn(rc, rc);
5919
5920 /* ICH6 datasheet defines 0 values for SVID and SID (18.1.14-15), which together with values returned for
5921 verb F20 should provide device/codec recognition. */
5922 Assert(pThis->pCodec->u16VendorId);
5923 Assert(pThis->pCodec->u16DeviceId);
5924 PCIDevSetSubSystemVendorId(&pThis->PciDev, pThis->pCodec->u16VendorId); /* 2c ro - intel.) */
5925 PCIDevSetSubSystemId( &pThis->PciDev, pThis->pCodec->u16DeviceId); /* 2e ro. */
5926 }
5927
5928 if (RT_SUCCESS(rc))
5929 {
5930 /*
5931 * Create all hardware streams.
5932 */
5933 for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
5934 {
5935 rc = hdaStreamCreate(&pThis->aStreams[i], i /* uSD */);
5936 AssertRC(rc);
5937 }
5938
5939 /*
5940 * Initialize the driver chain.
5941 */
5942 PHDADRIVER pDrv;
5943 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
5944 {
5945 /*
5946 * Only primary drivers are critical for the VM to run. Everything else
5947 * might not worth showing an own error message box in the GUI.
5948 */
5949 if (!(pDrv->Flags & PDMAUDIODRVFLAG_PRIMARY))
5950 continue;
5951
5952 PPDMIAUDIOCONNECTOR pCon = pDrv->pConnector;
5953 AssertPtr(pCon);
5954
5955 bool fValidLineIn = AudioMixerStreamIsValid(pDrv->LineIn.pMixStrm);
5956#ifdef VBOX_WITH_HDA_MIC_IN
5957 bool fValidMicIn = AudioMixerStreamIsValid(pDrv->MicIn.pMixStrm);
5958#endif
5959 bool fValidOut = AudioMixerStreamIsValid(pDrv->Front.pMixStrm);
5960#ifdef VBOX_WITH_HDA_51_SURROUND
5961 /** @todo Anything to do here? */
5962#endif
5963
5964 if ( !fValidLineIn
5965#ifdef VBOX_WITH_HDA_MIC_IN
5966 && !fValidMicIn
5967#endif
5968 && !fValidOut)
5969 {
5970 LogRel(("HDA: Falling back to NULL backend (no sound audible)\n"));
5971
5972 hdaReset(pDevIns);
5973 hdaReattach(pThis, pDrv, pDrv->uLUN, "NullAudio");
5974
5975 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
5976 N_("No audio devices could be opened. Selecting the NULL audio backend "
5977 "with the consequence that no sound is audible"));
5978 }
5979 else
5980 {
5981 bool fWarn = false;
5982
5983 PDMAUDIOBACKENDCFG backendCfg;
5984 int rc2 = pCon->pfnGetConfig(pCon, &backendCfg);
5985 if (RT_SUCCESS(rc2))
5986 {
5987 if (backendCfg.cSources)
5988 {
5989#ifdef VBOX_WITH_HDA_MIC_IN
5990 /* If the audio backend supports two or more input streams at once,
5991 * warn if one of our two inputs (microphone-in and line-in) failed to initialize. */
5992 if (backendCfg.cMaxStreamsIn >= 2)
5993 fWarn = !fValidLineIn || !fValidMicIn;
5994 /* If the audio backend only supports one input stream at once (e.g. pure ALSA, and
5995 * *not* ALSA via PulseAudio plugin!), only warn if both of our inputs failed to initialize.
5996 * One of the two simply is not in use then. */
5997 else if (backendCfg.cMaxStreamsIn == 1)
5998 fWarn = !fValidLineIn && !fValidMicIn;
5999 /* Don't warn if our backend is not able of supporting any input streams at all. */
6000#else
6001 /* We only have line-in as input source. */
6002 fWarn = !fValidLineIn;
6003#endif
6004 }
6005
6006 if ( !fWarn
6007 && backendCfg.cSinks)
6008 {
6009 fWarn = !fValidOut;
6010 }
6011 }
6012 else
6013 {
6014 LogRel(("HDA: Unable to retrieve audio backend configuration for LUN #%RU8, rc=%Rrc\n", pDrv->uLUN, rc2));
6015 fWarn = true;
6016 }
6017
6018 if (fWarn)
6019 {
6020 char szMissingStreams[255];
6021 size_t len = 0;
6022 if (!fValidLineIn)
6023 {
6024 LogRel(("HDA: WARNING: Unable to open PCM line input for LUN #%RU8!\n", pDrv->uLUN));
6025 len = RTStrPrintf(szMissingStreams, sizeof(szMissingStreams), "PCM Input");
6026 }
6027#ifdef VBOX_WITH_HDA_MIC_IN
6028 if (!fValidMicIn)
6029 {
6030 LogRel(("HDA: WARNING: Unable to open PCM microphone input for LUN #%RU8!\n", pDrv->uLUN));
6031 len += RTStrPrintf(szMissingStreams + len,
6032 sizeof(szMissingStreams) - len, len ? ", PCM Microphone" : "PCM Microphone");
6033 }
6034#endif
6035 if (!fValidOut)
6036 {
6037 LogRel(("HDA: WARNING: Unable to open PCM output for LUN #%RU8!\n", pDrv->uLUN));
6038 len += RTStrPrintf(szMissingStreams + len,
6039 sizeof(szMissingStreams) - len, len ? ", PCM Output" : "PCM Output");
6040 }
6041
6042 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
6043 N_("Some HDA audio streams (%s) could not be opened. Guest applications generating audio "
6044 "output or depending on audio input may hang. Make sure your host audio device "
6045 "is working properly. Check the logfile for error messages of the audio "
6046 "subsystem"), szMissingStreams);
6047 }
6048 }
6049 }
6050 }
6051
6052 if (RT_SUCCESS(rc))
6053 {
6054 hdaReset(pDevIns);
6055
6056 /*
6057 * 18.2.6,7 defines that values of this registers might be cleared on power on/reset
6058 * hdaReset shouldn't affects these registers.
6059 */
6060 HDA_REG(pThis, WAKEEN) = 0x0;
6061 HDA_REG(pThis, STATESTS) = 0x0;
6062
6063#ifdef DEBUG
6064 /*
6065 * Debug and string formatter types.
6066 */
6067 PDMDevHlpDBGFInfoRegister(pDevIns, "hda", "HDA info. (hda [register case-insensitive])", hdaDbgInfo);
6068 PDMDevHlpDBGFInfoRegister(pDevIns, "hdabdle", "HDA stream BDLE info. (hdabdle [stream number])", hdaDbgInfoBDLE);
6069 PDMDevHlpDBGFInfoRegister(pDevIns, "hdastrm", "HDA stream info. (hdastrm [stream number])", hdaDbgInfoStream);
6070 PDMDevHlpDBGFInfoRegister(pDevIns, "hdcnodes", "HDA codec nodes.", hdaDbgInfoCodecNodes);
6071 PDMDevHlpDBGFInfoRegister(pDevIns, "hdcselector", "HDA codec's selector states [node number].", hdaDbgInfoCodecSelector);
6072 PDMDevHlpDBGFInfoRegister(pDevIns, "hdamixer", "HDA mixer state.", hdaDbgInfoMixer);
6073
6074 rc = RTStrFormatTypeRegister("bdle", hdaDbgFmtBDLE, NULL);
6075 AssertRC(rc);
6076 rc = RTStrFormatTypeRegister("sdctl", hdaDbgFmtSDCTL, NULL);
6077 AssertRC(rc);
6078 rc = RTStrFormatTypeRegister("sdsts", hdaDbgFmtSDSTS, NULL);
6079 AssertRC(rc);
6080 rc = RTStrFormatTypeRegister("sdfifos", hdaDbgFmtSDFIFOS, NULL);
6081 AssertRC(rc);
6082 rc = RTStrFormatTypeRegister("sdfifow", hdaDbgFmtSDFIFOW, NULL);
6083 AssertRC(rc);
6084#endif /* DEBUG */
6085
6086 /*
6087 * Some debug assertions.
6088 */
6089 for (unsigned i = 0; i < RT_ELEMENTS(g_aHdaRegMap); i++)
6090 {
6091 struct HDAREGDESC const *pReg = &g_aHdaRegMap[i];
6092 struct HDAREGDESC const *pNextReg = i + 1 < RT_ELEMENTS(g_aHdaRegMap) ? &g_aHdaRegMap[i + 1] : NULL;
6093
6094 /* binary search order. */
6095 AssertReleaseMsg(!pNextReg || pReg->offset + pReg->size <= pNextReg->offset,
6096 ("[%#x] = {%#x LB %#x} vs. [%#x] = {%#x LB %#x}\n",
6097 i, pReg->offset, pReg->size, i + 1, pNextReg->offset, pNextReg->size));
6098
6099 /* alignment. */
6100 AssertReleaseMsg( pReg->size == 1
6101 || (pReg->size == 2 && (pReg->offset & 1) == 0)
6102 || (pReg->size == 3 && (pReg->offset & 3) == 0)
6103 || (pReg->size == 4 && (pReg->offset & 3) == 0),
6104 ("[%#x] = {%#x LB %#x}\n", i, pReg->offset, pReg->size));
6105
6106 /* registers are packed into dwords - with 3 exceptions with gaps at the end of the dword. */
6107 AssertRelease(((pReg->offset + pReg->size) & 3) == 0 || pNextReg);
6108 if (pReg->offset & 3)
6109 {
6110 struct HDAREGDESC const *pPrevReg = i > 0 ? &g_aHdaRegMap[i - 1] : NULL;
6111 AssertReleaseMsg(pPrevReg, ("[%#x] = {%#x LB %#x}\n", i, pReg->offset, pReg->size));
6112 if (pPrevReg)
6113 AssertReleaseMsg(pPrevReg->offset + pPrevReg->size == pReg->offset,
6114 ("[%#x] = {%#x LB %#x} vs. [%#x] = {%#x LB %#x}\n",
6115 i - 1, pPrevReg->offset, pPrevReg->size, i + 1, pReg->offset, pReg->size));
6116 }
6117#if 0
6118 if ((pReg->offset + pReg->size) & 3)
6119 {
6120 AssertReleaseMsg(pNextReg, ("[%#x] = {%#x LB %#x}\n", i, pReg->offset, pReg->size));
6121 if (pNextReg)
6122 AssertReleaseMsg(pReg->offset + pReg->size == pNextReg->offset,
6123 ("[%#x] = {%#x LB %#x} vs. [%#x] = {%#x LB %#x}\n",
6124 i, pReg->offset, pReg->size, i + 1, pNextReg->offset, pNextReg->size));
6125 }
6126#endif
6127 /* The final entry is a full DWORD, no gaps! Allows shortcuts. */
6128 AssertReleaseMsg(pNextReg || ((pReg->offset + pReg->size) & 3) == 0,
6129 ("[%#x] = {%#x LB %#x}\n", i, pReg->offset, pReg->size));
6130 }
6131 }
6132
6133# ifndef VBOX_WITH_AUDIO_CALLBACKS
6134 if (RT_SUCCESS(rc))
6135 {
6136 /* Start the emulation timer. */
6137 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, hdaTimer, pThis,
6138 TMTIMER_FLAGS_NO_CRIT_SECT, "DevIchHda", &pThis->pTimer);
6139 AssertRCReturn(rc, rc);
6140
6141 if (RT_SUCCESS(rc))
6142 {
6143 pThis->cTimerTicks = TMTimerGetFreq(pThis->pTimer) / uTimerHz;
6144 pThis->uTimerTS = TMTimerGet(pThis->pTimer);
6145 LogFunc(("Timer ticks=%RU64 (%RU16 Hz)\n", pThis->cTimerTicks, uTimerHz));
6146
6147 hdaTimerMaybeStart(pThis);
6148 }
6149 }
6150# else
6151 if (RT_SUCCESS(rc))
6152 {
6153 PHDADRIVER pDrv;
6154 RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
6155 {
6156 /* Only register primary driver.
6157 * The device emulation does the output multiplexing then. */
6158 if (pDrv->Flags != PDMAUDIODRVFLAG_PRIMARY)
6159 continue;
6160
6161 PDMAUDIOCALLBACK AudioCallbacks[2];
6162
6163 HDACALLBACKCTX Ctx = { pThis, pDrv };
6164
6165 AudioCallbacks[0].enmType = PDMAUDIOCALLBACKTYPE_INPUT;
6166 AudioCallbacks[0].pfnCallback = hdaCallbackInput;
6167 AudioCallbacks[0].pvCtx = &Ctx;
6168 AudioCallbacks[0].cbCtx = sizeof(HDACALLBACKCTX);
6169
6170 AudioCallbacks[1].enmType = PDMAUDIOCALLBACKTYPE_OUTPUT;
6171 AudioCallbacks[1].pfnCallback = hdaCallbackOutput;
6172 AudioCallbacks[1].pvCtx = &Ctx;
6173 AudioCallbacks[1].cbCtx = sizeof(HDACALLBACKCTX);
6174
6175 rc = pDrv->pConnector->pfnRegisterCallbacks(pDrv->pConnector, AudioCallbacks, RT_ELEMENTS(AudioCallbacks));
6176 if (RT_FAILURE(rc))
6177 break;
6178 }
6179 }
6180# endif
6181
6182# ifdef VBOX_WITH_STATISTICS
6183 if (RT_SUCCESS(rc))
6184 {
6185 /*
6186 * Register statistics.
6187 */
6188# ifndef VBOX_WITH_AUDIO_CALLBACKS
6189 PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTimer, STAMTYPE_PROFILE, "/Devices/HDA/Timer", STAMUNIT_TICKS_PER_CALL, "Profiling hdaTimer.");
6190# endif
6191 PDMDevHlpSTAMRegister(pDevIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, "/Devices/HDA/BytesRead" , STAMUNIT_BYTES, "Bytes read from HDA emulation.");
6192 PDMDevHlpSTAMRegister(pDevIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, "/Devices/HDA/BytesWritten", STAMUNIT_BYTES, "Bytes written to HDA emulation.");
6193 }
6194# endif
6195
6196 LogFlowFuncLeaveRC(rc);
6197 return rc;
6198}
6199
6200/**
6201 * The device registration structure.
6202 */
6203const PDMDEVREG g_DeviceICH6_HDA =
6204{
6205 /* u32Version */
6206 PDM_DEVREG_VERSION,
6207 /* szName */
6208 "hda",
6209 /* szRCMod */
6210 "VBoxDDRC.rc",
6211 /* szR0Mod */
6212 "VBoxDDR0.r0",
6213 /* pszDescription */
6214 "Intel HD Audio Controller",
6215 /* fFlags */
6216 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0,
6217 /* fClass */
6218 PDM_DEVREG_CLASS_AUDIO,
6219 /* cMaxInstances */
6220 1,
6221 /* cbInstance */
6222 sizeof(HDASTATE),
6223 /* pfnConstruct */
6224 hdaConstruct,
6225 /* pfnDestruct */
6226 hdaDestruct,
6227 /* pfnRelocate */
6228 NULL,
6229 /* pfnMemSetup */
6230 NULL,
6231 /* pfnPowerOn */
6232 NULL,
6233 /* pfnReset */
6234 hdaReset,
6235 /* pfnSuspend */
6236 NULL,
6237 /* pfnResume */
6238 NULL,
6239 /* pfnAttach */
6240 hdaAttach,
6241 /* pfnDetach */
6242 hdaDetach,
6243 /* pfnQueryInterface. */
6244 NULL,
6245 /* pfnInitComplete */
6246 NULL,
6247 /* pfnPowerOff */
6248 hdaPowerOff,
6249 /* pfnSoftReset */
6250 NULL,
6251 /* u32VersionEnd */
6252 PDM_DEVREG_VERSION
6253};
6254
6255#endif /* IN_RING3 */
6256#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette