DevSB16.cpp@ 100444

Last change on this file since 100444 was 98456, checked in by vboxsync, 20 months ago
Audio: Backed out r155649 + r155650, as this needs another approach. The three device emulations are too different wrt locking and stream setup / teardown when it comes to if and when they reset their DMA buffers. Needs more testing first. bugref:10354
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 113.0 KB

Line
1	/* $Id: DevSB16.cpp 98456 2023-02-02 20:23:19Z vboxsync $ */
2	/** @file
3	* DevSB16 - VBox SB16 Audio Controller.
4	*/
5
6	/*
7	* Copyright (C) 2015-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	* --------------------------------------------------------------------
27	*
28	* This code is based on: sb16.c from QEMU AUDIO subsystem (r3917).
29	* QEMU Soundblaster 16 emulation
30	*
31	* Copyright (c) 2003-2005 Vassili Karpov (malc)
32	*
33	* Permission is hereby granted, free of charge, to any person obtaining a copy
34	* of this software and associated documentation files (the "Software"), to deal
35	* in the Software without restriction, including without limitation the rights
36	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
37	* copies of the Software, and to permit persons to whom the Software is
38	* furnished to do so, subject to the following conditions:
39	*
40	* The above copyright notice and this permission notice shall be included in
41	* all copies or substantial portions of the Software.
42	*
43	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
44	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
45	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
46	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
47	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
48	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
49	* THE SOFTWARE.
50	*/
51
52
53	/*********************************************************************************************************************************
54	* Header Files *
55	*********************************************************************************************************************************/
56	#define LOG_GROUP LOG_GROUP_DEV_SB16
57	#include <VBox/log.h>
58	#include <iprt/assert.h>
59	#include <iprt/file.h>
60	#ifdef IN_RING3
61	# include <iprt/mem.h>
62	# include <iprt/string.h>
63	# include <iprt/uuid.h>
64	#endif
65
66	#include <VBox/vmm/pdmdev.h>
67	#include <VBox/vmm/pdmaudioifs.h>
68	#include <VBox/vmm/pdmaudioinline.h>
69	#include <VBox/AssertGuest.h>
70
71	#include "VBoxDD.h"
72
73	#include "AudioMixBuffer.h"
74	#include "AudioMixer.h"
75	#include "AudioHlp.h"
76
77
78	/*********************************************************************************************************************************
79	* Defined Constants And Macros *
80	*********************************************************************************************************************************/
81	/** Default timer frequency (in Hz). */
82	#define SB16_TIMER_HZ_DEFAULT 100
83	/** The maximum number of separate streams we currently implement.
84	* Currently we only support one stream only, namely the output stream. */
85	#define SB16_MAX_STREAMS 1
86	/** The (zero-based) index of the output stream in \a aStreams. */
87	#define SB16_IDX_OUT 0
88
89	/** Current saved state version. */
90	#define SB16_SAVE_STATE_VERSION 2
91	/** The version used in VirtualBox version 3.0 and earlier. This didn't include the config dump. */
92	#define SB16_SAVE_STATE_VERSION_VBOX_30 1
93
94
95	/*********************************************************************************************************************************
96	* Global Variables *
97	*********************************************************************************************************************************/
98	static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
99
100
101
102	/*********************************************************************************************************************************
103	* Structures and Typedefs *
104	*********************************************************************************************************************************/
105	/** Pointer to the SB16 state. */
106	typedef struct SB16STATE *PSB16STATE;
107
108	/**
109	* The internal state of a SB16 stream.
110	*/
111	typedef struct SB16STREAMSTATE
112	{
113	/** Flag indicating whether this stream is in enabled state or not. */
114	bool fEnabled;
115	/** Set if we've registered the asynchronous update job. */
116	bool fRegisteredAsyncUpdateJob;
117	/** DMA cache to read data from / write data to. */
118	PRTCIRCBUF pCircBuf;
119	/** Current circular buffer read offset (for tracing & logging). */
120	uint64_t offRead;
121	/** Current circular buffer write offset (for tracing & logging). */
122	uint64_t offWrite;
123
124	/** Size of the DMA buffer (pCircBuf) in bytes. */
125	uint32_t StatDmaBufSize;
126	/** Number of used bytes in the DMA buffer (pCircBuf). */
127	uint32_t StatDmaBufUsed;
128	} SB16STREAMSTATE;
129	/** Pointer to internal state of an SB16 stream. */
130	typedef SB16STREAMSTATE *PSB16STREAMSTATE;
131
132	/**
133	* Structure defining a (host backend) driver stream.
134	* Each driver has its own instances of audio mixer streams, which then
135	* can go into the same (or even different) audio mixer sinks.
136	*/
137	typedef struct SB16DRIVERSTREAM
138	{
139	/** Associated mixer stream handle. */
140	R3PTRTYPE(PAUDMIXSTREAM) pMixStrm;
141	/** The stream's current configuration. */
142	} SB16DRIVERSTREAM, *PSB16DRIVERSTREAM;
143
144	/**
145	* Struct for tracking a host backend driver, i.e. our per-LUN data.
146	*/
147	typedef struct SB16DRIVER
148	{
149	/** Node for storing this driver in our device driver list of SB16STATE. */
150	RTLISTNODER3 Node;
151	/** Pointer to SB16 controller (state). */
152	R3PTRTYPE(PSB16STATE) pSB16State;
153	/** Pointer to attached driver base interface. */
154	R3PTRTYPE(PPDMIBASE) pDrvBase;
155	/** Audio connector interface to the underlying host backend. */
156	R3PTRTYPE(PPDMIAUDIOCONNECTOR) pConnector;
157	/** Stream for output. */
158	SB16DRIVERSTREAM Out;
159	/** LUN # to which this driver has been assigned. */
160	uint8_t uLUN;
161	/** Whether this driver is in an attached state or not. */
162	bool fAttached;
163	/** The LUN description. */
164	char szDesc[48 - 2];
165	} SB16DRIVER;
166	/** Pointer to the per-LUN data. */
167	typedef SB16DRIVER *PSB16DRIVER;
168
169	/**
170	* Runtime configurable debug stuff for a SB16 stream.
171	*/
172	typedef struct SB16STREAMDEBUGRT
173	{
174	/** Whether debugging is enabled or not. */
175	bool fEnabled;
176	uint8_t Padding[7];
177	/** File for dumping DMA reads / writes.
178	* For input streams, this dumps data being written to the device DMA,
179	* whereas for output streams this dumps data being read from the device DMA. */
180	R3PTRTYPE(PAUDIOHLPFILE) pFileDMA;
181	} SB16STREAMDEBUGRT;
182
183	/**
184	* Debug stuff for a SB16 stream.
185	*/
186	typedef struct SB16STREAMDEBUG
187	{
188	/** Runtime debug stuff. */
189	SB16STREAMDEBUGRT Runtime;
190	} SB16STREAMDEBUG;
191
192	/**
193	* Structure for keeping a SB16 hardware stream configuration.
194	*/
195	typedef struct SB16STREAMHWCFG
196	{
197	/** IRQ # to use. */
198	uint8_t uIrq;
199	/** Low DMA channel to use. */
200	uint8_t uDmaChanLow;
201	/** High DMA channel to use. */
202	uint8_t uDmaChanHigh;
203	/** IO port to use. */
204	RTIOPORT uPort;
205	/** DSP version to expose. */
206	uint16_t uVer;
207	} SB16STREAMHWCFG;
208
209	/**
210	* Structure for a SB16 stream.
211	*/
212	typedef struct SB16STREAM
213	{
214	/** The stream's own index in \a aStreams of SB16STATE.
215	* Set to UINT8_MAX if not set (yet). */
216	uint8_t uIdx;
217	uint16_t uTimerHz;
218	/** The timer for pumping data thru the attached LUN drivers. */
219	TMTIMERHANDLE hTimerIO;
220	/** The timer interval for pumping data thru the LUN drivers in timer ticks. */
221	uint64_t cTicksTimerIOInterval;
222	/** Timestamp of the last timer callback (sb16TimerIO).
223	* Used to calculate thetime actually elapsed between two timer callbacks.
224	* This currently ASSMUMES that we only have one single (output) stream. */
225	uint64_t tsTimerIO; /** @todo Make this a per-stream value. */
226	/** The stream's currentconfiguration. */
227	PDMAUDIOSTREAMCFG Cfg;
228	/** The stream's defaulthardware configuration, mostly done by jumper settings back then. */
229	SB16STREAMHWCFG HwCfgDefault;
230	/** The stream's hardware configuration set at runtime.
231	* Might differ from the default configuration above and is needed for live migration. */
232	SB16STREAMHWCFG HwCfgRuntime;
233
234	int fifo;
235	int dma_auto;
236	/** Whether to use the high (\c true) or the low (\c false) DMA channel. */
237	int fDmaUseHigh;
238	int can_write; /** @todo r=andy BUGBUG Value never gets set to 0! */
239	int time_const;
240	/** The DMA transfer (block)size in bytes. */
241	int32_t cbDmaBlockSize;
242	int32_t cbDmaLeft; /** Note: Can be < 0. Needs to 32-bit for backwards compatibility. */
243	/** Internal state of this stream. */
244	SB16STREAMSTATE State;
245	/** Debug stuff. */
246	SB16STREAMDEBUG Dbg;
247	} SB16STREAM;
248	/** Pointer to a SB16 stream */
249	typedef SB16STREAM *PSB16STREAM;
250
251	/**
252	* SB16 debug settings.
253	*/
254	typedef struct SB16STATEDEBUG
255	{
256	/** Whether debugging is enabled or not. */
257	bool fEnabled;
258	bool afAlignment[7];
259	/** Path where to dump the debug output to.
260	* Can be NULL, in which the system's temporary directory will be used then. */
261	R3PTRTYPE(char *) pszOutPath;
262	} SB16STATEDEBUG;
263
264	/**
265	* The SB16 state.
266	*/
267	typedef struct SB16STATE
268	{
269	/** Pointer to the device instance. */
270	PPDMDEVINSR3 pDevInsR3;
271	/** Pointer to the connector of the attached audio driver. */
272	PPDMIAUDIOCONNECTOR pDrv;
273
274	int dsp_in_idx;
275	int dsp_out_data_len;
276	int dsp_in_needed_bytes;
277	int cmd;
278	int highspeed;
279
280	int v2x6;
281
282	uint8_t csp_param;
283	uint8_t csp_value;
284	uint8_t csp_mode;
285	uint8_t csp_index;
286	uint8_t csp_regs[256];
287	uint8_t csp_reg83[4];
288	int csp_reg83r;
289	int csp_reg83w;
290
291	uint8_t dsp_in_data[10];
292	uint8_t dsp_out_data[50];
293	uint8_t test_reg;
294	uint8_t last_read_byte;
295	int nzero;
296
297	RTLISTANCHOR lstDrv;
298	/** IRQ timer */
299	TMTIMERHANDLE hTimerIRQ;
300	/** The base interface for LUN\#0. */
301	PDMIBASE IBase;
302
303	/** Array of all SB16 hardware audio stream. */
304	SB16STREAM aStreams[SB16_MAX_STREAMS];
305	/** The device's software mixer. */
306	R3PTRTYPE(PAUDIOMIXER) pMixer;
307	/** Audio sink for PCM output. */
308	R3PTRTYPE(PAUDMIXSINK) pSinkOut;
309
310	/** The two mixer I/O ports (port + 4). */
311	IOMIOPORTHANDLE hIoPortsMixer;
312	/** The 10 DSP I/O ports (port + 6). */
313	IOMIOPORTHANDLE hIoPortsDsp;
314
315	/** Debug settings. */
316	SB16STATEDEBUG Dbg;
317
318	/* mixer state */
319	uint8_t mixer_nreg;
320	uint8_t mixer_regs[256];
321
322	#ifdef VBOX_WITH_STATISTICS
323	STAMPROFILE StatTimerIO;
324	STAMCOUNTER StatBytesRead;
325	#endif
326	} SB16STATE;
327
328
329	/*********************************************************************************************************************************
330	* Internal Functions *
331	*********************************************************************************************************************************/
332	DECLINLINE(PDMAUDIODIR) sb16GetDirFromIndex(uint8_t uIdx);
333
334	static int sb16StreamEnable(PSB16STATE pThis, PSB16STREAM pStream, bool fEnable, bool fForce);
335	static void sb16StreamReset(PSB16STATE pThis, PSB16STREAM pStream);
336	static int sb16StreamOpen(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream);
337	static void sb16StreamClose(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream);
338	DECLINLINE(PAUDMIXSINK) sb16StreamIndexToSink(PSB16STATE pThis, uint8_t uIdx);
339	static void sb16StreamTransferScheduleNext(PSB16STATE pThis, PSB16STREAM pStream, uint32_t cSamples);
340	static int sb16StreamDoDmaOutput(PSB16STATE pThis, PSB16STREAM pStream, int uDmaChan, uint32_t offDma, uint32_t cbDma, uint32_t cbToRead, uint32_t *pcbRead);
341	static DECLCALLBACK(void) sb16StreamUpdateAsyncIoJob(PPDMDEVINS pDevIns, PAUDMIXSINK pSink, void *pvUser);
342
343	static DECLCALLBACK(void) sb16TimerIO(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser);
344	static DECLCALLBACK(void) sb16TimerIRQ(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser);
345	DECLINLINE(void) sb16TimerSet(PPDMDEVINS pDevIns, PSB16STREAM pStream, uint64_t cTicksToDeadline);
346
347	static void sb16SpeakerControl(PSB16STATE pThis, bool fOn);
348	static void sb16UpdateVolume(PSB16STATE pThis);
349
350
351
352	static void sb16SpeakerControl(PSB16STATE pThis, bool fOn)
353	{
354	RT_NOREF(pThis, fOn);
355
356	/** @todo This currently does nothing. */
357	}
358
359	static void sb16StreamControl(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream, bool fRun)
360	{
361	unsigned uDmaChan = pStream->fDmaUseHigh ? pStream->HwCfgRuntime.uDmaChanHigh : pStream->HwCfgRuntime.uDmaChanLow;
362
363	LogFunc(("fRun=%RTbool, fDmaUseHigh=%RTbool, uDmaChan=%u\n", fRun, pStream->fDmaUseHigh, uDmaChan));
364
365	PDMDevHlpDMASetDREQ(pThis->pDevInsR3, uDmaChan, fRun ? 1 : 0);
366
367	if (fRun != pStream->State.fEnabled)
368	{
369	if (fRun)
370	{
371	int rc = VINF_SUCCESS;
372
373	if (pStream->Cfg.Props.uHz > 0)
374	{
375	rc = sb16StreamOpen(pDevIns, pThis, pStream);
376	if (RT_SUCCESS(rc))
377	sb16UpdateVolume(pThis);
378	}
379	else
380	AssertFailed(); /** @todo Buggy code? */
381
382	if (RT_SUCCESS(rc))
383	{
384	rc = sb16StreamEnable(pThis, pStream, true /* fEnable /, false / fForce */);
385	if (RT_SUCCESS(rc))
386	{
387	sb16TimerSet(pDevIns, pStream, pStream->cTicksTimerIOInterval);
388
389	PDMDevHlpDMASchedule(pThis->pDevInsR3);
390	}
391	}
392	}
393	else
394	{
395	sb16StreamEnable(pThis, pStream, false /* fEnable /, false / fForce */);
396	}
397	}
398	}
399
400	#define DMA8_AUTO 1
401	#define DMA8_HIGH 2
402
403	static void sb16DmaCmdContinue8(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream)
404	{
405	sb16StreamControl(pDevIns, pThis, pStream, true /* fRun */);
406	}
407
408	static void sb16DmaCmd8(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream,
409	int mask, int dma_len)
410	{
411	pStream->fDmaUseHigh = 0;
412
413	if (-1 == pStream->time_const)
414	{
415	if (pStream->Cfg.Props.uHz == 0)
416	pStream->Cfg.Props.uHz = 11025;
417	}
418	else
419	{
420	int tmp = (256 - pStream->time_const);
421	pStream->Cfg.Props.uHz = (1000000 + (tmp / 2)) / tmp;
422	}
423
424	/** @todo r=bird: Use '(pThis->mixer_regs[0x0e] & 2) == 0 ? 1 : 2' like below? */
425	unsigned cShiftChannels = PDMAudioPropsChannels(&pStream->Cfg.Props) >= 2 ? 1 : 0;
426
427	if (dma_len != -1)
428	{
429	pStream->cbDmaBlockSize = dma_len << cShiftChannels;
430	}
431	else
432	{
433	/* This is apparently the only way to make both Act1/PL
434	and SecondReality/FC work
435
436	r=andy Wow, actually someone who remembers Future Crew :-)
437
438	Act1 sets block size via command 0x48 and it's an odd number
439	SR does the same with even number
440	Both use stereo, and Creatives own documentation states that
441	0x48 sets block size in bytes less one.. go figure */
442	pStream->cbDmaBlockSize &= ~cShiftChannels;
443	}
444
445	pStream->Cfg.Props.uHz >>= cShiftChannels;
446	pStream->cbDmaLeft = pStream->cbDmaBlockSize;
447	/* pThis->highspeed = (mask & DMA8_HIGH) != 0; */
448	pStream->dma_auto = (mask & DMA8_AUTO) != 0;
449
450	PDMAudioPropsInit(&pStream->Cfg.Props, 1 /* 8-bit */,
451	false /* fSigned */,
452	(pThis->mixer_regs[0x0e] & 2) == 0 ? 1 : 2 /* Mono/Stereo */,
453	pStream->Cfg.Props.uHz);
454
455	/** @todo Check if stream's DMA block size is properly aligned to the set PCM props. */
456
457	sb16DmaCmdContinue8(pDevIns, pThis, pStream);
458	sb16SpeakerControl(pThis, true /* fOn */);
459	}
460
461	static void sb16DmaCmd(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream,
462	uint8_t cmd, uint8_t d0, int dma_len)
463	{
464	pStream->fDmaUseHigh = cmd < 0xc0;
465	pStream->fifo = (cmd >> 1) & 1;
466	pStream->dma_auto = (cmd >> 2) & 1;
467
468	pStream->Cfg.Props.fSigned = RT_BOOL(d0 & RT_BIT_32(4));
469	PDMAudioPropsSetChannels(&pStream->Cfg.Props, 1 + ((d0 >> 5) & 1));
470
471	switch (cmd >> 4)
472	{
473	case 11:
474	PDMAudioPropsSetSampleSize(&pStream->Cfg.Props, 2 /16-bit/);
475	break;
476
477	case 12:
478	PDMAudioPropsSetSampleSize(&pStream->Cfg.Props, 1 /8-bit/);
479	break;
480
481	default:
482	AssertFailed();
483	break;
484	}
485
486	if (-1 != pStream->time_const)
487	{
488	#if 1
489	int tmp = 256 - pStream->time_const;
490	pStream->Cfg.Props.uHz = (1000000 + (tmp / 2)) / tmp;
491	#else
492	/* pThis->freq = 1000000 / ((255 - pStream->time_const) << pThis->fmt_stereo); */
493	pThis->freq = 1000000 / ((255 - pStream->time_const));
494	#endif
495	pStream->time_const = -1;
496	}
497
498	pStream->cbDmaBlockSize = dma_len + 1;
499	pStream->cbDmaBlockSize <<= PDMAudioPropsSampleSize(&pStream->Cfg.Props) == 2 ? 1 : 0;
500	if (!pStream->dma_auto)
501	{
502	/*
503	* It is clear that for DOOM and auto-init this value
504	* shouldn't take stereo into account, while Miles Sound Systems
505	* setsound.exe with single transfer mode wouldn't work without it
506	* wonders of SB16 yet again.
507	*/
508	pStream->cbDmaBlockSize <<= PDMAudioPropsSampleSize(&pStream->Cfg.Props) == 2 ? 1 : 0;
509	}
510
511	pStream->cbDmaLeft = pStream->cbDmaBlockSize;
512
513	pThis->highspeed = 0;
514
515	/** @todo Check if stream's DMA block size is properly aligned to the set PCM props. */
516
517	sb16StreamControl(pDevIns, pThis, pStream, true /* fRun */);
518	sb16SpeakerControl(pThis, true /* fOn */);
519	}
520
521	static inline void sb16DspSeData(PSB16STATE pThis, uint8_t val)
522	{
523	LogFlowFunc(("%#x\n", val));
524	if ((size_t) pThis->dsp_out_data_len < sizeof (pThis->dsp_out_data))
525	pThis->dsp_out_data[pThis->dsp_out_data_len++] = val;
526	}
527
528	static inline uint8_t sb16DspGetData(PSB16STATE pThis)
529	{
530	if (pThis->dsp_in_idx)
531	return pThis->dsp_in_data[--pThis->dsp_in_idx];
532	AssertMsgFailed(("DSP input buffer underflow\n"));
533	return 0;
534	}
535
536	static void sb16DspCmdLookup(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream, uint8_t cmd)
537	{
538	LogFlowFunc(("command %#x\n", cmd));
539
540	if (cmd > 0xaf && cmd < 0xd0)
541	{
542	if (cmd & 8) /** @todo Handle recording. */
543	LogFlowFunc(("ADC not yet supported (command %#x)\n", cmd));
544
545	switch (cmd >> 4)
546	{
547	case 11:
548	case 12:
549	break;
550	default:
551	LogFlowFunc(("%#x wrong bits\n", cmd));
552	}
553
554	pThis->dsp_in_needed_bytes = 3;
555	}
556	else
557	{
558	pThis->dsp_in_needed_bytes = 0;
559
560	/** @todo Use a mapping table with
561	* - a command verb (binary search)
562	* - required bytes
563	* - function callback handler
564	*/
565
566	switch (cmd)
567	{
568	case 0x03: /* ASP Status */
569	sb16DspSeData(pThis, 0x10); /* pThis->csp_param); */
570	goto warn;
571
572	case 0x04: /* DSP Status (Obsolete) / ASP ??? */
573	pThis->dsp_in_needed_bytes = 1;
574	goto warn;
575
576	case 0x05: /* ASP ??? */
577	pThis->dsp_in_needed_bytes = 2;
578	goto warn;
579
580	case 0x08: /* ??? */
581	/* __asm__ ("int3"); */
582	goto warn;
583
584	case 0x09: /* ??? */
585	sb16DspSeData(pThis, 0xf8);
586	goto warn;
587
588	case 0x0e: /* ??? */
589	pThis->dsp_in_needed_bytes = 2;
590	goto warn;
591
592	case 0x0f: /* ??? */
593	pThis->dsp_in_needed_bytes = 1;
594	goto warn;
595
596	case 0x10: /* Direct mode DAC */
597	pThis->dsp_in_needed_bytes = 1;
598	goto warn;
599
600	case 0x14: /* DAC DMA, 8-bit, uncompressed */
601	pThis->dsp_in_needed_bytes = 2;
602	pStream->cbDmaBlockSize = 0;
603	break;
604
605	case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
606	sb16DmaCmd8(pDevIns, pThis, pStream, DMA8_AUTO, -1);
607	break;
608
609	case 0x20: /* Direct ADC, Juice/PL */
610	sb16DspSeData(pThis, 0xff);
611	goto warn;
612
613	case 0x35: /* MIDI Read Interrupt + Write Poll (UART) */
614	LogRelMax2(32, ("SB16: MIDI support not implemented yet\n"));
615	break;
616
617	case 0x40: /* Set Time Constant */
618	pStream->time_const = -1;
619	pThis->dsp_in_needed_bytes = 1;
620	break;
621
622	case 0x41: /* Set sample rate for input */
623	pStream->Cfg.Props.uHz = 0; /** @todo r=andy Why do we reset output stuff here? */
624	pStream->time_const = -1;
625	pThis->dsp_in_needed_bytes = 2;
626	break;
627
628	case 0x42: /* Set sample rate for output */
629	pStream->Cfg.Props.uHz = 0;
630	pStream->time_const = -1;
631	pThis->dsp_in_needed_bytes = 2;
632	goto warn;
633
634	case 0x45: /* Continue Auto-Initialize DMA, 8-bit */
635	sb16DspSeData(pThis, 0xaa);
636	goto warn;
637
638	case 0x47: /* Continue Auto-Initialize DMA, 16-bit */
639	break;
640
641	case 0x48: /* Set DMA Block Size */
642	pThis->dsp_in_needed_bytes = 2;
643	break;
644
645	case 0x74: /* DMA DAC, 4-bit ADPCM */
646	pThis->dsp_in_needed_bytes = 2;
647	LogFlowFunc(("4-bit ADPCM not implemented yet\n"));
648	break;
649
650	case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
651	pThis->dsp_in_needed_bytes = 2;
652	LogFlowFunc(("DMA DAC, 4-bit ADPCM Reference not implemented\n"));
653	break;
654
655	case 0x76: /* DMA DAC, 2.6-bit ADPCM */
656	pThis->dsp_in_needed_bytes = 2;
657	LogFlowFunc(("DMA DAC, 2.6-bit ADPCM not implemented yet\n"));
658	break;
659
660	case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
661	pThis->dsp_in_needed_bytes = 2;
662	LogFlowFunc(("ADPCM reference not implemented yet\n"));
663	break;
664
665	case 0x7d: /* Auto-Initialize DMA DAC, 4-bit ADPCM Reference */
666	LogFlowFunc(("Autio-Initialize DMA DAC, 4-bit ADPCM reference not implemented yet\n"));
667	break;
668
669	case 0x7f: /* Auto-Initialize DMA DAC, 16-bit ADPCM Reference */
670	LogFlowFunc(("Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference not implemented yet\n"));
671	break;
672
673	case 0x80: /* Silence DAC */
674	pThis->dsp_in_needed_bytes = 2;
675	break;
676
677	case 0x90: /* Auto-Initialize DMA DAC, 8-bit (High Speed) */
678	RT_FALL_THROUGH();
679	case 0x91: /* Normal DMA DAC, 8-bit (High Speed) */
680	sb16DmaCmd8(pDevIns, pThis, pStream, (((cmd & 1) == 0) ? 1 : 0) \| DMA8_HIGH, -1);
681	break;
682
683	case 0xd0: /* Halt DMA operation. 8bit */
684	sb16StreamControl(pDevIns, pThis, pStream, false /* fRun */);
685	break;
686
687	case 0xd1: /* Speaker on */
688	sb16SpeakerControl(pThis, true /* fOn */);
689	break;
690
691	case 0xd3: /* Speaker off */
692	sb16SpeakerControl(pThis, false /* fOn */);
693	break;
694
695	case 0xd4: /* Continue DMA operation, 8-bit */
696	/* KQ6 (or maybe Sierras audblst.drv in general) resets
697	the frequency between halt/continue */
698	sb16DmaCmdContinue8(pDevIns, pThis, pStream);
699	break;
700
701	case 0xd5: /* Halt DMA operation, 16-bit */
702	sb16StreamControl(pDevIns, pThis, pStream, false /* fRun */);
703	break;
704
705	case 0xd6: /* Continue DMA operation, 16-bit */
706	sb16StreamControl(pDevIns, pThis, pStream, true /* fRun */);
707	break;
708
709	case 0xd9: /* Exit auto-init DMA after this block, 16-bit */
710	pStream->dma_auto = 0;
711	break;
712
713	case 0xda: /* Exit auto-init DMA after this block, 8-bit */
714	pStream->dma_auto = 0;
715	break;
716
717	case 0xe0: /* DSP identification */
718	pThis->dsp_in_needed_bytes = 1;
719	break;
720
721	case 0xe1: /* DSP version */
722	sb16DspSeData(pThis, RT_LO_U8(pStream->HwCfgRuntime.uVer));
723	sb16DspSeData(pThis, RT_HI_U8(pStream->HwCfgRuntime.uVer));
724	break;
725
726	case 0xe2: /* ??? */
727	pThis->dsp_in_needed_bytes = 1;
728	goto warn;
729
730	case 0xe3: /* DSP copyright */
731	{
732	for (int i = sizeof(e3) - 1; i >= 0; --i)
733	sb16DspSeData(pThis, e3[i]);
734	break;
735	}
736
737	case 0xe4: /* Write test register */
738	pThis->dsp_in_needed_bytes = 1;
739	break;
740
741	case 0xe7: /* ??? */
742	LogFlowFunc(("Attempt to probe for ESS (0xe7)?\n"));
743	break;
744
745	case 0xe8: /* Read test register */
746	sb16DspSeData(pThis, pThis->test_reg);
747	break;
748
749	case 0xf2: /* IRQ Request, 8-bit */
750	RT_FALL_THROUGH();
751	case 0xf3: /* IRQ Request, 16-bit */
752	{
753	sb16DspSeData(pThis, 0xaa);
754	pThis->mixer_regs[0x82] \|= (cmd == 0xf2) ? 1 : 2;
755	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 1);
756	break;
757	}
758
759	case 0xf8: /* Undocumented, used by old Creative diagnostic programs */
760	sb16DspSeData(pThis, 0);
761	goto warn;
762
763	case 0xf9: /* ??? */
764	pThis->dsp_in_needed_bytes = 1;
765	goto warn;
766
767	case 0xfa: /* ??? */
768	sb16DspSeData(pThis, 0);
769	goto warn;
770
771	case 0xfc: /* ??? */
772	sb16DspSeData(pThis, 0);
773	goto warn;
774
775	default:
776	LogFunc(("Unrecognized DSP command %#x, ignored\n", cmd));
777	break;
778	}
779	}
780
781	exit:
782
783	if (!pThis->dsp_in_needed_bytes)
784	pThis->cmd = -1;
785	else
786	pThis->cmd = cmd;
787
788	return;
789
790	warn:
791	LogFunc(("warning: command %#x,%d is not truly understood yet\n", cmd, pThis->dsp_in_needed_bytes));
792	goto exit;
793	}
794
795	DECLINLINE(uint16_t) sb16DspGetLoHi(PSB16STATE pThis)
796	{
797	const uint8_t hi = sb16DspGetData(pThis);
798	const uint8_t lo = sb16DspGetData(pThis);
799	return RT_MAKE_U16(lo, hi);
800	}
801
802	DECLINLINE(uint16_t) sb16DspGetHiLo(PSB16STATE pThis)
803	{
804	const uint8_t lo = sb16DspGetData(pThis);
805	const uint8_t hi = sb16DspGetData(pThis);
806	return RT_MAKE_U16(lo, hi);
807	}
808
809	static void sb16DspCmdComplete(PPDMDEVINS pDevIns, PSB16STATE pThis)
810	{
811	LogFlowFunc(("Command %#x, in_index %d, needed_bytes %d\n", pThis->cmd, pThis->dsp_in_idx, pThis->dsp_in_needed_bytes));
812
813	int v0, v1, v2;
814
815	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT]; /** @ŧodo Improve this. */
816
817	if (pThis->cmd > 0xaf && pThis->cmd < 0xd0)
818	{
819	v2 = sb16DspGetData(pThis);
820	v1 = sb16DspGetData(pThis);
821	v0 = sb16DspGetData(pThis);
822
823	if (pThis->cmd & 8)
824	LogFlowFunc(("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", pThis->cmd, v0, v1, v2));
825	else
826	{
827	LogFlowFunc(("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", pThis->cmd, v0, v1, v2));
828	sb16DmaCmd(pDevIns, pThis, pStream, pThis->cmd, v0, v1 + (v2 << 8));
829	}
830	}
831	else
832	{
833	switch (pThis->cmd)
834	{
835	case 0x04:
836	pThis->csp_mode = sb16DspGetData(pThis);
837	pThis->csp_reg83r = 0;
838	pThis->csp_reg83w = 0;
839	LogFlowFunc(("CSP command 0x04: mode=%#x\n", pThis->csp_mode));
840	break;
841
842	case 0x05:
843	pThis->csp_param = sb16DspGetData(pThis);
844	pThis->csp_value = sb16DspGetData(pThis);
845	LogFlowFunc(("CSP command 0x05: param=%#x value=%#x\n", pThis->csp_param, pThis->csp_value));
846	break;
847
848	case 0x0e:
849	v0 = sb16DspGetData(pThis);
850	v1 = sb16DspGetData(pThis);
851	LogFlowFunc(("write CSP register %d <- %#x\n", v1, v0));
852	if (v1 == 0x83)
853	{
854	LogFlowFunc(("0x83[%d] <- %#x\n", pThis->csp_reg83r, v0));
855	pThis->csp_reg83[pThis->csp_reg83r % 4] = v0;
856	pThis->csp_reg83r += 1;
857	}
858	else
859	pThis->csp_regs[v1] = v0;
860	break;
861
862	case 0x0f:
863	v0 = sb16DspGetData(pThis);
864	LogFlowFunc(("read CSP register %#x -> %#x, mode=%#x\n", v0, pThis->csp_regs[v0], pThis->csp_mode));
865	if (v0 == 0x83)
866	{
867	LogFlowFunc(("0x83[%d] -> %#x\n", pThis->csp_reg83w, pThis->csp_reg83[pThis->csp_reg83w % 4]));
868	sb16DspSeData(pThis, pThis->csp_reg83[pThis->csp_reg83w % 4]);
869	pThis->csp_reg83w += 1;
870	}
871	else
872	sb16DspSeData(pThis, pThis->csp_regs[v0]);
873	break;
874
875	case 0x10:
876	v0 = sb16DspGetData(pThis);
877	LogFlowFunc(("cmd 0x10 d0=%#x\n", v0));
878	break;
879
880	case 0x14:
881	sb16DmaCmd8(pDevIns, pThis, pStream, 0, sb16DspGetLoHi(pThis) + 1);
882	break;
883
884	case 0x22: /* Sets the master volume. */
885	/** @todo Setting the master volume is not implemented yet. */
886	break;
887
888	case 0x40: /* Sets the timer constant; SB16 is able to use sample rates via 0x41 instead. */
889	pStream->time_const = sb16DspGetData(pThis);
890	LogFlowFunc(("set time const %d\n", pStream->time_const));
891	break;
892
893	case 0x42: /* Sets the input rate (in Hz). */
894	#if 0
895	LogFlowFunc(("cmd 0x42 might not do what it think it should\n"));
896	#endif
897	RT_FALL_THROUGH(); /** @todo BUGBUG FT2 sets output freq with this, go figure. */
898
899	case 0x41: /* Sets the output rate (in Hz). */
900	pStream->Cfg.Props.uHz = sb16DspGetHiLo(pThis);
901	LogFlowFunc(("set freq to %RU16Hz\n", pStream->Cfg.Props.uHz));
902	break;
903
904	case 0x48:
905	pStream->cbDmaBlockSize = sb16DspGetLoHi(pThis) + 1;
906	LogFlowFunc(("set dma block len %d\n", pStream->cbDmaBlockSize));
907	break;
908
909	case 0x74:
910	case 0x75:
911	case 0x76:
912	case 0x77:
913	/* ADPCM stuff, ignore. */
914	break;
915
916	case 0x80: /* Sets the IRQ. */
917	sb16StreamTransferScheduleNext(pThis, pStream, sb16DspGetLoHi(pThis) + 1);
918	break;
919
920	case 0xe0:
921	v0 = sb16DspGetData(pThis);
922	pThis->dsp_out_data_len = 0;
923	LogFlowFunc(("E0=%#x\n", v0));
924	sb16DspSeData(pThis, ~v0);
925	break;
926
927	case 0xe2:
928	v0 = sb16DspGetData(pThis);
929	LogFlowFunc(("E2=%#x\n", v0));
930	break;
931
932	case 0xe4:
933	pThis->test_reg = sb16DspGetData(pThis);
934	break;
935
936	case 0xf9:
937	v0 = sb16DspGetData(pThis);
938	switch (v0)
939	{
940	case 0x0e:
941	sb16DspSeData(pThis, 0xff);
942	break;
943
944	case 0x0f:
945	sb16DspSeData(pThis, 0x07);
946	break;
947
948	case 0x37:
949	sb16DspSeData(pThis, 0x38);
950	break;
951
952	default:
953	sb16DspSeData(pThis, 0x00);
954	break;
955	}
956	break;
957
958	default:
959	LogRel2(("SB16: Unrecognized command %#x, skipping\n", pThis->cmd));
960	return;
961	}
962	}
963
964	pThis->cmd = -1;
965	return;
966	}
967
968	static void sb16DspCmdResetLegacy(PSB16STATE pThis)
969	{
970	LogFlowFuncEnter();
971
972	/* Disable speaker(s). */
973	sb16SpeakerControl(pThis, false /* fOn */);
974
975	/*
976	* Reset all streams.
977	*/
978	for (unsigned i = 0; i < SB16_MAX_STREAMS; i++)
979	sb16StreamReset(pThis, &pThis->aStreams[i]);
980	}
981
982	static void sb16DspCmdReset(PSB16STATE pThis)
983	{
984	pThis->mixer_regs[0x82] = 0;
985	pThis->dsp_in_idx = 0;
986	pThis->dsp_out_data_len = 0;
987	pThis->dsp_in_needed_bytes = 0;
988	pThis->nzero = 0;
989	pThis->highspeed = 0;
990	pThis->v2x6 = 0;
991	pThis->cmd = -1;
992
993	sb16DspSeData(pThis, 0xaa);
994
995	sb16DspCmdResetLegacy(pThis);
996	}
997
998	/**
999	* @callback_method_impl{PFNIOMIOPORTNEWOUT}
1000	*/
1001	static DECLCALLBACK(VBOXSTRICTRC) sb16IoPortDspWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
1002	{
1003	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1004	RT_NOREF(pvUser, cb);
1005
1006	/** @todo Figure out how we can distinguish between streams. DSP port #, e.g. 0x220? */
1007	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
1008
1009	LogFlowFunc(("write %#x <- %#x\n", offPort, u32));
1010	switch (offPort)
1011	{
1012	case 0:
1013	switch (u32)
1014	{
1015	case 0x00:
1016	{
1017	if (pThis->v2x6 == 1)
1018	{
1019	if (0 && pThis->highspeed)
1020	{
1021	pThis->highspeed = 0;
1022	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 0);
1023	sb16StreamControl(pDevIns, pThis, pStream, false /* fRun */);
1024	}
1025	else
1026	sb16DspCmdReset(pThis);
1027	}
1028	pThis->v2x6 = 0;
1029	break;
1030	}
1031
1032	case 0x01:
1033	case 0x03: /* FreeBSD kludge */
1034	pThis->v2x6 = 1;
1035	break;
1036
1037	case 0xc6:
1038	pThis->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */
1039	break;
1040
1041	case 0xb8: /* Panic */
1042	sb16DspCmdReset(pThis);
1043	break;
1044
1045	case 0x39:
1046	sb16DspSeData(pThis, 0x38);
1047	sb16DspCmdReset(pThis);
1048	pThis->v2x6 = 0x39;
1049	break;
1050
1051	default:
1052	pThis->v2x6 = u32;
1053	break;
1054	}
1055	break;
1056
1057	case 6: /* Write data or command \| write status */
1058	#if 0
1059	if (pThis->highspeed)
1060	break;
1061	#endif
1062	if (0 == pThis->dsp_in_needed_bytes)
1063	{
1064	sb16DspCmdLookup(pDevIns, pThis, pStream, u32);
1065	}
1066	else
1067	{
1068	if (pThis->dsp_in_idx == sizeof (pThis->dsp_in_data))
1069	{
1070	AssertMsgFailed(("DSP input data overrun\n"));
1071	}
1072	else
1073	{
1074	pThis->dsp_in_data[pThis->dsp_in_idx++] = u32;
1075	if (pThis->dsp_in_idx == pThis->dsp_in_needed_bytes)
1076	{
1077	pThis->dsp_in_needed_bytes = 0;
1078	sb16DspCmdComplete(pDevIns, pThis);
1079	}
1080	}
1081	}
1082	break;
1083
1084	default:
1085	LogFlowFunc(("offPort=%#x, u32=%#x)\n", offPort, u32));
1086	break;
1087	}
1088
1089	return VINF_SUCCESS;
1090	}
1091
1092
1093	/**
1094	* @callback_method_impl{PFNIOMIOPORTNEWIN}
1095	*/
1096	static DECLCALLBACK(VBOXSTRICTRC) sb16IoPortDspRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint32_t pu32, unsigned cb)
1097	{
1098	RT_NOREF(pvUser, cb);
1099
1100	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1101
1102	uint32_t retval;
1103	int ack = 0;
1104
1105	/** @todo Figure out how we can distinguish between streams. */
1106	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
1107
1108	/** @todo reject non-byte access?
1109	* The spec does not mention a non-byte access so we should check how real hardware behaves. */
1110
1111	switch (offPort)
1112	{
1113	case 0: /* reset */
1114	retval = 0xff;
1115	break;
1116
1117	case 4: /* read data */
1118	if (pThis->dsp_out_data_len)
1119	{
1120	retval = pThis->dsp_out_data[--pThis->dsp_out_data_len];
1121	pThis->last_read_byte = retval;
1122	}
1123	else
1124	{
1125	if (pThis->cmd != -1)
1126	LogFlowFunc(("empty output buffer for command %#x\n", pThis->cmd));
1127	retval = pThis->last_read_byte;
1128	/* goto error; */
1129	}
1130	break;
1131
1132	case 6: /* 0 can write */
1133	retval = pStream->can_write ? 0 : 0x80;
1134	break;
1135
1136	case 7: /* timer interrupt clear */
1137	/* LogFlowFunc(("timer interrupt clear\n")); */
1138	retval = 0;
1139	break;
1140
1141	case 8: /* data available status \| irq 8 ack */
1142	retval = (!pThis->dsp_out_data_len \|\| pThis->highspeed) ? 0 : 0x80;
1143	if (pThis->mixer_regs[0x82] & 1)
1144	{
1145	ack = 1;
1146	pThis->mixer_regs[0x82] &= ~1;
1147	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 0);
1148	}
1149	break;
1150
1151	case 9: /* irq 16 ack */
1152	retval = 0xff;
1153	if (pThis->mixer_regs[0x82] & 2)
1154	{
1155	ack = 1;
1156	pThis->mixer_regs[0x82] &= ~2;
1157	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 0);
1158	}
1159	break;
1160
1161	default:
1162	LogFlowFunc(("warning: sb16IoPortDspRead %#x error\n", offPort));
1163	return VERR_IOM_IOPORT_UNUSED;
1164	}
1165
1166	if (!ack)
1167	LogFlowFunc(("read %#x -> %#x\n", offPort, retval));
1168
1169	*pu32 = retval;
1170	return VINF_SUCCESS;
1171	}
1172
1173
1174	/*********************************************************************************************************************************
1175	* Mixer functions *
1176	*********************************************************************************************************************************/
1177
1178	static uint8_t sb16MixRegToVol(PSB16STATE pThis, int reg)
1179	{
1180	/* The SB16 mixer has a 0 to -62dB range in 32 levels (2dB each step).
1181	* We use a 0 to -96dB range in 256 levels (0.375dB each step).
1182	* Only the top 5 bits of a mixer register are used.
1183	*/
1184	uint8_t steps = 31 - (pThis->mixer_regs[reg] >> 3);
1185	uint8_t vol = 255 - steps * 16 / 3; /* (2dB8) / (0.375dB8) */
1186	return vol;
1187	}
1188
1189	/**
1190	* Returns the device's current master volume.
1191	*
1192	* @param pThis SB16 state.
1193	* @param pVol Where to store the master volume information.
1194	*/
1195	DECLINLINE(void) sb16GetMasterVolume(PSB16STATE pThis, PPDMAUDIOVOLUME pVol)
1196	{
1197	/* There's no mute switch, only volume controls. */
1198	PDMAudioVolumeInitFromStereo(pVol, false /fMuted/, sb16MixRegToVol(pThis, 0x30), sb16MixRegToVol(pThis, 0x31));
1199	}
1200
1201	/**
1202	* Returns the device's current output stream volume.
1203	*
1204	* @param pThis SB16 state.
1205	* @param pVol Where to store the output stream volume information.
1206	*/
1207	DECLINLINE(void) sb16GetPcmOutVolume(PSB16STATE pThis, PPDMAUDIOVOLUME pVol)
1208	{
1209	/* There's no mute switch, only volume controls. */
1210	PDMAudioVolumeInitFromStereo(pVol, false /fMuted/, sb16MixRegToVol(pThis, 0x32), sb16MixRegToVol(pThis, 0x33));
1211	}
1212
1213	static void sb16UpdateVolume(PSB16STATE pThis)
1214	{
1215	PDMAUDIOVOLUME VolMaster;
1216	sb16GetMasterVolume(pThis, &VolMaster);
1217
1218	PDMAUDIOVOLUME VolOut;
1219	sb16GetPcmOutVolume(pThis, &VolOut);
1220
1221	/* Combine the master + output stream volume. */
1222	PDMAUDIOVOLUME VolCombined;
1223	PDMAudioVolumeCombine(&VolCombined, &VolMaster, &VolOut);
1224
1225	int rc2 = AudioMixerSinkSetVolume(pThis->pSinkOut, &VolCombined);
1226	AssertRC(rc2);
1227	}
1228
1229	static void sb16MixerReset(PSB16STATE pThis)
1230	{
1231	memset(pThis->mixer_regs, 0xff, 0x7f);
1232	memset(pThis->mixer_regs + 0x83, 0xff, sizeof (pThis->mixer_regs) - 0x83);
1233
1234	pThis->mixer_regs[0x02] = 4; /* master volume 3bits */
1235	pThis->mixer_regs[0x06] = 4; /* MIDI volume 3bits */
1236	pThis->mixer_regs[0x08] = 0; /* CD volume 3bits */
1237	pThis->mixer_regs[0x0a] = 0; /* voice volume 2bits */
1238
1239	/* d5=input filt, d3=lowpass filt, d1,d2=input source */
1240	pThis->mixer_regs[0x0c] = 0;
1241
1242	/* d5=output filt, d1=stereo switch */
1243	pThis->mixer_regs[0x0e] = 0;
1244
1245	/* voice volume L d5,d7, R d1,d3 */
1246	pThis->mixer_regs[0x04] = (12 << 4) \| 12;
1247	/* master ... */
1248	pThis->mixer_regs[0x22] = (12 << 4) \| 12;
1249	/* MIDI ... */
1250	pThis->mixer_regs[0x26] = (12 << 4) \| 12;
1251
1252	/* master/voice/MIDI L/R volume */
1253	for (int i = 0x30; i < 0x36; i++)
1254	pThis->mixer_regs[i] = 24 << 3; /* -14 dB */
1255
1256	/* treble/bass */
1257	for (int i = 0x44; i < 0x48; i++)
1258	pThis->mixer_regs[i] = 0x80;
1259
1260	/* Update the master (mixer) and PCM out volumes. */
1261	sb16UpdateVolume(pThis);
1262
1263	/*
1264	* Reset mixer sinks.
1265	*
1266	* Do the reset here instead of in sb16StreamReset();
1267	* the mixer sink(s) might still have data to be processed when an audio stream gets reset.
1268	*/
1269	if (pThis->pSinkOut)
1270	AudioMixerSinkReset(pThis->pSinkOut);
1271	}
1272
1273	static int magic_of_irq(int irq)
1274	{
1275	switch (irq)
1276	{
1277	case 5:
1278	return 2;
1279	case 7:
1280	return 4;
1281	case 9:
1282	return 1;
1283	case 10:
1284	return 8;
1285	default:
1286	break;
1287	}
1288
1289	LogFlowFunc(("bad irq %d\n", irq));
1290	return 2;
1291	}
1292
1293	static int irq_of_magic(int magic)
1294	{
1295	switch (magic)
1296	{
1297	case 1:
1298	return 9;
1299	case 2:
1300	return 5;
1301	case 4:
1302	return 7;
1303	case 8:
1304	return 10;
1305	default:
1306	break;
1307	}
1308
1309	LogFlowFunc(("bad irq magic %d\n", magic));
1310	return -1;
1311	}
1312
1313	static int sb16MixerWriteIndex(PSB16STATE pThis, PSB16STREAM pStream, uint8_t val)
1314	{
1315	RT_NOREF(pStream);
1316	pThis->mixer_nreg = val;
1317	return VINF_SUCCESS;
1318	}
1319
1320	#ifndef VBOX
1321	static uint32_t popcount(uint32_t u)
1322	{
1323	u = ((u&0x55555555) + ((u>>1)&0x55555555));
1324	u = ((u&0x33333333) + ((u>>2)&0x33333333));
1325	u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
1326	u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
1327	u = ( u&0x0000ffff) + (u>>16);
1328	return u;
1329	}
1330	#endif
1331
1332	static uint32_t lsbindex(uint32_t u)
1333	{
1334	#ifdef VBOX
1335	return u ? ASMBitFirstSetU32(u) - 1 : 32;
1336	#else
1337	return popcount((u & -(int32_t)u) - 1);
1338	#endif
1339	}
1340
1341	/* Convert SB16 to SB Pro mixer volume (left). */
1342	static inline void sb16ConvVolumeL(PSB16STATE pThis, unsigned reg, uint8_t val)
1343	{
1344	/* High nibble in SBP mixer. */
1345	pThis->mixer_regs[reg] = (pThis->mixer_regs[reg] & 0x0f) \| (val & 0xf0);
1346	}
1347
1348	/* Convert SB16 to SB Pro mixer volume (right). */
1349	static inline void sb16ConvVolumeR(PSB16STATE pThis, unsigned reg, uint8_t val)
1350	{
1351	/* Low nibble in SBP mixer. */
1352	pThis->mixer_regs[reg] = (pThis->mixer_regs[reg] & 0xf0) \| (val >> 4);
1353	}
1354
1355	/* Convert SB Pro to SB16 mixer volume (left + right). */
1356	static inline void sb16ConvVolumeOldToNew(PSB16STATE pThis, unsigned reg, uint8_t val)
1357	{
1358	/* Left channel. */
1359	pThis->mixer_regs[reg + 0] = (val & 0xf0) \| RT_BIT(3);
1360	/* Right channel (the register immediately following). */
1361	pThis->mixer_regs[reg + 1] = (val << 4) \| RT_BIT(3);
1362	}
1363
1364
1365	static int sb16MixerWriteData(PSB16STATE pThis, PSB16STREAM pStream, uint8_t val)
1366	{
1367	bool fUpdateMaster = false;
1368	bool fUpdateStream = false;
1369
1370	LogFlowFunc(("[%#x] <- %#x\n", pThis->mixer_nreg, val));
1371
1372	switch (pThis->mixer_nreg)
1373	{
1374	case 0x00:
1375	sb16MixerReset(pThis);
1376	/* And update the actual volume, too. */
1377	fUpdateMaster = true;
1378	fUpdateStream = true;
1379	break;
1380
1381	case 0x04: /* Translate from old style voice volume (L/R). */
1382	sb16ConvVolumeOldToNew(pThis, 0x32, val);
1383	fUpdateStream = true;
1384	break;
1385
1386	case 0x22: /* Translate from old style master volume (L/R). */
1387	sb16ConvVolumeOldToNew(pThis, 0x30, val);
1388	fUpdateMaster = true;
1389	break;
1390
1391	case 0x26: /* Translate from old style MIDI volume (L/R). */
1392	sb16ConvVolumeOldToNew(pThis, 0x34, val);
1393	break;
1394
1395	case 0x28: /* Translate from old style CD volume (L/R). */
1396	sb16ConvVolumeOldToNew(pThis, 0x36, val);
1397	break;
1398
1399	case 0x2E: /* Translate from old style line volume (L/R). */
1400	sb16ConvVolumeOldToNew(pThis, 0x38, val);
1401	break;
1402
1403	case 0x30: /* Translate to old style master volume (L). */
1404	sb16ConvVolumeL(pThis, 0x22, val);
1405	fUpdateMaster = true;
1406	break;
1407
1408	case 0x31: /* Translate to old style master volume (R). */
1409	sb16ConvVolumeR(pThis, 0x22, val);
1410	fUpdateMaster = true;
1411	break;
1412
1413	case 0x32: /* Translate to old style voice volume (L). */
1414	sb16ConvVolumeL(pThis, 0x04, val);
1415	fUpdateStream = true;
1416	break;
1417
1418	case 0x33: /* Translate to old style voice volume (R). */
1419	sb16ConvVolumeR(pThis, 0x04, val);
1420	fUpdateStream = true;
1421	break;
1422
1423	case 0x34: /* Translate to old style MIDI volume (L). */
1424	sb16ConvVolumeL(pThis, 0x26, val);
1425	break;
1426
1427	case 0x35: /* Translate to old style MIDI volume (R). */
1428	sb16ConvVolumeR(pThis, 0x26, val);
1429	break;
1430
1431	case 0x36: /* Translate to old style CD volume (L). */
1432	sb16ConvVolumeL(pThis, 0x28, val);
1433	break;
1434
1435	case 0x37: /* Translate to old style CD volume (R). */
1436	sb16ConvVolumeR(pThis, 0x28, val);
1437	break;
1438
1439	case 0x38: /* Translate to old style line volume (L). */
1440	sb16ConvVolumeL(pThis, 0x2E, val);
1441	break;
1442
1443	case 0x39: /* Translate to old style line volume (R). */
1444	sb16ConvVolumeR(pThis, 0x2E, val);
1445	break;
1446
1447	case 0x80:
1448	{
1449	int irq = irq_of_magic(val);
1450	LogRelMax2(64, ("SB16: Setting IRQ to %d\n", irq));
1451	if (irq > 0)
1452	pStream->HwCfgRuntime.uIrq = irq;
1453	break;
1454	}
1455
1456	case 0x81:
1457	{
1458	int dma = lsbindex(val & 0xf);
1459	int hdma = lsbindex(val & 0xf0);
1460	if ( dma != pStream->HwCfgRuntime.uDmaChanLow
1461	\|\| hdma != pStream->HwCfgRuntime.uDmaChanHigh)
1462	{
1463	LogRelMax2(64, ("SB16: Attempt to change DMA 8bit %d(%d), 16bit %d(%d)\n",
1464	dma, pStream->HwCfgRuntime.uDmaChanLow, hdma, pStream->HwCfgRuntime.uDmaChanHigh));
1465	}
1466	#if 0
1467	pStream->dma = dma;
1468	pStream->hdma = hdma;
1469	#endif
1470	break;
1471	}
1472
1473	case 0x82:
1474	LogRelMax2(64, ("SB16: Attempt to write into IRQ status register to %#x\n", val));
1475	return VINF_SUCCESS;
1476
1477	default:
1478	if (pThis->mixer_nreg >= 0x80)
1479	LogFlowFunc(("attempt to write mixer[%#x] <- %#x\n", pThis->mixer_nreg, val));
1480	break;
1481	}
1482
1483	pThis->mixer_regs[pThis->mixer_nreg] = val;
1484
1485	/* Update the master (mixer) volume. */
1486	if ( fUpdateMaster
1487	\|\| fUpdateStream)
1488	{
1489	sb16UpdateVolume(pThis);
1490	}
1491
1492	return VINF_SUCCESS;
1493	}
1494
1495	/**
1496	* @callback_method_impl{PFNIOMIOPORTNEWOUT}
1497	*/
1498	static DECLCALLBACK(VBOXSTRICTRC) sb16IoPortMixerWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
1499	{
1500	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1501	RT_NOREF(pvUser);
1502
1503	/** @todo Figure out how we can distinguish between streams. */
1504	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
1505
1506	switch (cb)
1507	{
1508	case 1:
1509	switch (offPort)
1510	{
1511	case 0:
1512	sb16MixerWriteIndex(pThis, pStream, u32);
1513	break;
1514	case 1:
1515	sb16MixerWriteData(pThis, pStream, u32);
1516	break;
1517	default:
1518	AssertFailed();
1519	}
1520	break;
1521	case 2:
1522	sb16MixerWriteIndex(pThis, pStream, u32 & 0xff);
1523	sb16MixerWriteData(pThis, pStream, (u32 >> 8) & 0xff);
1524	break;
1525	default:
1526	ASSERT_GUEST_MSG_FAILED(("offPort=%#x cb=%d u32=%#x\n", offPort, cb, u32));
1527	break;
1528	}
1529	return VINF_SUCCESS;
1530	}
1531
1532	/**
1533	* @callback_method_impl{PFNIOMIOPORTNEWIN}
1534	*/
1535	static DECLCALLBACK(VBOXSTRICTRC) sb16IoPortMixerRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint32_t pu32, unsigned cb)
1536	{
1537	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1538	RT_NOREF(pvUser, cb, offPort);
1539
1540	#ifndef DEBUG_SB16_MOST
1541	if (pThis->mixer_nreg != 0x82)
1542	LogFlowFunc(("sb16IoPortMixerRead[%#x] -> %#x\n", pThis->mixer_nreg, pThis->mixer_regs[pThis->mixer_nreg]));
1543	#else
1544	LogFlowFunc(("sb16IoPortMixerRead[%#x] -> %#x\n", pThis->mixer_nreg, pThis->mixer_regs[pThis->mixer_nreg]));
1545	#endif
1546	*pu32 = pThis->mixer_regs[pThis->mixer_nreg];
1547	return VINF_SUCCESS;
1548	}
1549
1550
1551	/*********************************************************************************************************************************
1552	* DMA handling *
1553	*********************************************************************************************************************************/
1554
1555	/**
1556	* Worker for sb16DMARead.
1557	*/
1558
1559	/**
1560	* @callback_method_impl{FNDMATRANSFERHANDLER,
1561	* Worker callback for both DMA channels.}
1562	*/
1563	static DECLCALLBACK(uint32_t) sb16DMARead(PPDMDEVINS pDevIns, void *pvUser, unsigned uChannel, uint32_t off, uint32_t cb)
1564
1565	{
1566	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1567	AssertPtr(pThis);
1568	PSB16STREAM pStream = (PSB16STREAM)pvUser;
1569	AssertPtr(pStream);
1570
1571	int till, copy, free;
1572
1573	if (pStream->cbDmaBlockSize <= 0)
1574	{
1575	LogFlowFunc(("invalid block size=%d uChannel=%d off=%d cb=%d\n", pStream->cbDmaBlockSize, uChannel, off, cb));
1576	return off;
1577	}
1578
1579	if (pStream->cbDmaLeft < 0)
1580	pStream->cbDmaLeft = pStream->cbDmaBlockSize;
1581
1582	free = cb;
1583
1584	copy = free;
1585	till = pStream->cbDmaLeft;
1586
1587	Log4Func(("pos=%d %d, till=%d, len=%d\n", off, free, till, cb));
1588
1589	if (copy >= till)
1590	{
1591	if (0 == pStream->dma_auto)
1592	{
1593	copy = till;
1594	}
1595	else
1596	{
1597	if (copy >= till + pStream->cbDmaBlockSize)
1598	copy = till; /* Make sure we won't skip IRQs. */
1599	}
1600	}
1601
1602	STAM_COUNTER_ADD(&pThis->StatBytesRead, copy);
1603
1604	uint32_t written = 0; /* Shut up GCC. */
1605	int rc = sb16StreamDoDmaOutput(pThis, pStream, uChannel, off, cb, copy, &written);
1606	AssertRC(rc);
1607
1608	/** @todo Convert the rest to uin32_t / size_t. */
1609	off = (off + (int)written) % cb;
1610	pStream->cbDmaLeft -= (int)written; /** @todo r=andy left_till_irq can be < 0. Correct? Revisit this. */
1611
1612	Log3Func(("pos %d/%d, free=%d, till=%d, copy=%d, written=%RU32, block_size=%d\n",
1613	off, cb, free, pStream->cbDmaLeft, copy, copy, pStream->cbDmaBlockSize));
1614
1615	if (pStream->cbDmaLeft <= 0)
1616	{
1617	pThis->mixer_regs[0x82] \|= (uChannel & 4) ? 2 : 1;
1618
1619	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 1);
1620
1621	if (0 == pStream->dma_auto) /** @todo r=andy BUGBUG Why do we first assert the IRQ if dma_auto is 0? Revisit this. */
1622	{
1623	sb16StreamControl(pDevIns, pThis, pStream, false /* fRun */);
1624	sb16SpeakerControl(pThis, false /* fOn */);
1625	}
1626	}
1627
1628	while (pStream->cbDmaLeft <= 0)
1629	pStream->cbDmaLeft += pStream->cbDmaBlockSize;
1630
1631	return off;
1632	}
1633
1634
1635	/*********************************************************************************************************************************
1636	* Timer-related code *
1637	*********************************************************************************************************************************/
1638
1639	/**
1640	* @callback_method_impl{PFNTMTIMERDEV}
1641	*/
1642	static DECLCALLBACK(void) sb16TimerIRQ(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
1643	{
1644	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1645	RT_NOREF(hTimer, pThis);
1646
1647	PSB16STREAM pStream = (PSB16STREAM)pvUser;
1648	AssertPtrReturnVoid(pStream);
1649
1650	LogFlowFuncEnter();
1651
1652	pStream->can_write = 1;
1653	PDMDevHlpISASetIrq(pDevIns, pStream->HwCfgRuntime.uIrq, 1);
1654	}
1655
1656	/**
1657	* Sets the stream's I/O timer to a new expiration time.
1658	*
1659	* @param pDevIns The device instance.
1660	* @param pStream SB16 stream to set timer for.
1661	* @param cTicksToDeadline The number of ticks to the new deadline.
1662	*/
1663	DECLINLINE(void) sb16TimerSet(PPDMDEVINS pDevIns, PSB16STREAM pStream, uint64_t cTicksToDeadline)
1664	{
1665	int rc = PDMDevHlpTimerSetRelative(pDevIns, pStream->hTimerIO, cTicksToDeadline, NULL /pu64Now/);
1666	AssertRC(rc);
1667	}
1668
1669	/**
1670	* @callback_method_impl{FNTMTIMERDEV}
1671	*/
1672	static DECLCALLBACK(void) sb16TimerIO(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
1673	{
1674	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
1675	STAM_PROFILE_START(&pThis->StatTimerIO, a);
1676
1677	PSB16STREAM pStream = (PSB16STREAM)pvUser;
1678	AssertPtrReturnVoid(pStream);
1679	AssertReturnVoid(hTimer == pStream->hTimerIO);
1680
1681	const uint64_t cTicksNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimerIO);
1682
1683	pStream->tsTimerIO = cTicksNow;
1684
1685	PAUDMIXSINK pSink = sb16StreamIndexToSink(pThis, pStream->uIdx);
1686	AssertPtrReturnVoid(pSink);
1687
1688	const bool fSinkActive = AudioMixerSinkIsActive(pSink);
1689
1690	LogFlowFunc(("fSinkActive=%RTbool\n", fSinkActive));
1691
1692	/* Schedule the next transfer. */
1693	PDMDevHlpDMASchedule(pDevIns);
1694
1695	if (fSinkActive)
1696	{
1697	/** @todo adjust cTicks down by now much cbOutMin represents. */
1698	sb16TimerSet(pDevIns, pStream, pStream->cTicksTimerIOInterval);
1699	}
1700
1701	AudioMixerSinkSignalUpdateJob(pSink);
1702
1703	STAM_PROFILE_STOP(&pThis->StatTimerIO, a);
1704	}
1705
1706
1707	/*********************************************************************************************************************************
1708	* LUN (driver) management *
1709	*********************************************************************************************************************************/
1710
1711	/**
1712	* Retrieves a specific driver stream of a SB16 driver.
1713	*
1714	* @returns Pointer to driver stream if found, or NULL if not found.
1715	* @param pDrv Driver to retrieve driver stream for.
1716	* @param enmDir Stream direction to retrieve.
1717	* @param enmPath Stream destination / source to retrieve.
1718	*/
1719	static PSB16DRIVERSTREAM sb16GetDrvStream(PSB16DRIVER pDrv, PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
1720	{
1721	PSB16DRIVERSTREAM pDrvStream = NULL;
1722
1723	if (enmDir == PDMAUDIODIR_OUT)
1724	{
1725	LogFunc(("enmPath=%d\n", enmPath));
1726
1727	switch (enmPath)
1728	{
1729	case PDMAUDIOPATH_OUT_FRONT:
1730	pDrvStream = &pDrv->Out;
1731	break;
1732	default:
1733	AssertFailed();
1734	break;
1735	}
1736	}
1737	else
1738	Assert(enmDir == PDMAUDIODIR_IN /** @todo Recording not implemented yet. */);
1739
1740	return pDrvStream;
1741	}
1742
1743	/**
1744	* Adds a driver stream to a specific mixer sink.
1745	*
1746	* @returns VBox status code.
1747	* @param pDevIns The device instance.
1748	* @param pMixSink Mixer sink to add driver stream to.
1749	* @param pCfg Stream configuration to use.
1750	* @param pDrv Driver stream to add.
1751	*/
1752	static int sb16AddDrvStream(PPDMDEVINS pDevIns, PAUDMIXSINK pMixSink, PCPDMAUDIOSTREAMCFG pCfg, PSB16DRIVER pDrv)
1753	{
1754	AssertReturn(pCfg->enmDir == PDMAUDIODIR_OUT, VERR_NOT_IMPLEMENTED); /* We don't support recording for SB16 so far. */
1755	LogFunc(("[LUN#%RU8] %s\n", pDrv->uLUN, pCfg->szName));
1756
1757	int rc;
1758	PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, pCfg->enmDir, pCfg->enmPath);
1759	if (pDrvStream)
1760	{
1761	AssertMsg(pDrvStream->pMixStrm == NULL, ("[LUN#%RU8] Driver stream already present when it must not\n", pDrv->uLUN));
1762
1763	PAUDMIXSTREAM pMixStrm;
1764	rc = AudioMixerSinkCreateStream(pMixSink, pDrv->pConnector, pCfg, pDevIns, &pMixStrm);
1765	LogFlowFunc(("LUN#%RU8: Created stream \"%s\" for sink, rc=%Rrc\n", pDrv->uLUN, pCfg->szName, rc));
1766	if (RT_SUCCESS(rc))
1767	{
1768	rc = AudioMixerSinkAddStream(pMixSink, pMixStrm);
1769	LogFlowFunc(("LUN#%RU8: Added stream \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, pCfg->szName, rc));
1770	if (RT_SUCCESS(rc))
1771	pDrvStream->pMixStrm = pMixStrm;
1772	else
1773	AudioMixerStreamDestroy(pMixStrm, pDevIns, true /fImmediate/);
1774	}
1775	}
1776	else
1777	rc = VERR_INVALID_PARAMETER;
1778
1779	LogFlowFuncLeaveRC(rc);
1780	return rc;
1781	}
1782
1783	/**
1784	* Adds all current driver streams to a specific mixer sink.
1785	*
1786	* @returns VBox status code.
1787	* @param pDevIns The device instance.
1788	* @param pThis The SB16 state.
1789	* @param pMixSink Mixer sink to add stream to.
1790	* @param pCfg Stream configuration to use.
1791	*/
1792	static int sb16AddDrvStreams(PPDMDEVINS pDevIns, PSB16STATE pThis, PAUDMIXSINK pMixSink, PCPDMAUDIOSTREAMCFG pCfg)
1793	{
1794	AssertPtrReturn(pMixSink, VERR_INVALID_POINTER);
1795
1796	int rc;
1797	if (AudioHlpStreamCfgIsValid(pCfg))
1798	{
1799	rc = AudioMixerSinkSetFormat(pMixSink, &pCfg->Props, pCfg->Device.cMsSchedulingHint);
1800	if (RT_SUCCESS(rc))
1801	{
1802	PSB16DRIVER pDrv;
1803	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1804	{
1805	int rc2 = sb16AddDrvStream(pDevIns, pMixSink, pCfg, pDrv);
1806	if (RT_FAILURE(rc2))
1807	LogFunc(("Attaching stream failed with %Rrc\n", rc2));
1808
1809	/* Do not pass failure to rc here, as there might be drivers which aren't
1810	* configured / ready yet. */
1811	}
1812	}
1813	}
1814	else
1815	rc = VERR_INVALID_PARAMETER;
1816
1817	LogFlowFuncLeaveRC(rc);
1818	return rc;
1819	}
1820
1821	/**
1822	* Removes a driver stream from a specific mixer sink.
1823	*
1824	* @param pDevIns The device instance.
1825	* @param pMixSink Mixer sink to remove audio streams from.
1826	* @param enmDir Stream direction to remove.
1827	* @param enmPath Stream destination / source to remove.
1828	* @param pDrv Driver stream to remove.
1829	*/
1830	static void sb16RemoveDrvStream(PPDMDEVINS pDevIns, PAUDMIXSINK pMixSink, PDMAUDIODIR enmDir,
1831	PDMAUDIOPATH enmPath, PSB16DRIVER pDrv)
1832	{
1833	PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, enmDir, enmPath);
1834	if (pDrvStream)
1835	{
1836	if (pDrvStream->pMixStrm)
1837	{
1838	LogFlowFunc(("[LUN#%RU8]\n", pDrv->uLUN));
1839
1840	AudioMixerSinkRemoveStream(pMixSink, pDrvStream->pMixStrm);
1841
1842	AudioMixerStreamDestroy(pDrvStream->pMixStrm, pDevIns, false /fImmediate/);
1843	pDrvStream->pMixStrm = NULL;
1844	}
1845	}
1846	}
1847
1848	/**
1849	* Removes all driver streams from a specific mixer sink.
1850	*
1851	* @param pDevIns The device instance.
1852	* @param pThis The SB16 state.
1853	* @param pMixSink Mixer sink to remove audio streams from.
1854	* @param enmDir Stream direction to remove.
1855	* @param enmPath Stream destination / source to remove.
1856	*/
1857	static void sb16RemoveDrvStreams(PPDMDEVINS pDevIns, PSB16STATE pThis, PAUDMIXSINK pMixSink,
1858	PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
1859	{
1860	AssertPtrReturnVoid(pMixSink);
1861
1862	PSB16DRIVER pDrv;
1863	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1864	{
1865	sb16RemoveDrvStream(pDevIns, pMixSink, enmDir, enmPath, pDrv);
1866	}
1867	}
1868
1869	/**
1870	* Adds a specific SB16 driver to the driver chain.
1871	*
1872	* @returns VBox status code.
1873	* @param pDevIns The device instance.
1874	* @param pThis The SB16 device state.
1875	* @param pDrv The SB16 driver to add.
1876	*/
1877	static int sb16AddDrv(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16DRIVER pDrv)
1878	{
1879	int rc = VINF_SUCCESS;
1880
1881	for (unsigned i = 0; i < SB16_MAX_STREAMS; i++)
1882	{
1883	if (AudioHlpStreamCfgIsValid(&pThis->aStreams[i].Cfg))
1884	{
1885	int rc2 = sb16AddDrvStream(pDevIns, sb16StreamIndexToSink(pThis, pThis->aStreams[i].uIdx),
1886	&pThis->aStreams[i].Cfg, pDrv);
1887	if (RT_SUCCESS(rc))
1888	rc = rc2;
1889	}
1890	}
1891
1892	return rc;
1893	}
1894
1895	/**
1896	* Removes a specific SB16 driver from the driver chain and destroys its
1897	* associated streams.
1898	*
1899	* This is only used by sb16Detach.
1900	*
1901	* @param pDevIns The device instance.
1902	* @param pThis The SB16 device state.
1903	* @param pDrv SB16 driver to remove.
1904	*/
1905	static void sb16RemoveDrv(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16DRIVER pDrv)
1906	{
1907	RT_NOREF(pDevIns);
1908
1909	/** @todo We only implement one single output (playback) stream at the moment. */
1910
1911	if (pDrv->Out.pMixStrm)
1912	{
1913	AudioMixerSinkRemoveStream(pThis->pSinkOut, pDrv->Out.pMixStrm);
1914	AudioMixerStreamDestroy(pDrv->Out.pMixStrm, pDevIns, true /fImmediate/);
1915	pDrv->Out.pMixStrm = NULL;
1916	}
1917
1918	RTListNodeRemove(&pDrv->Node);
1919	}
1920
1921
1922	/*********************************************************************************************************************************
1923	* Stream handling *
1924	*********************************************************************************************************************************/
1925
1926	static int sb16StreamDoDmaOutput(PSB16STATE pThis, PSB16STREAM pStream, int uDmaChan, uint32_t offDma, uint32_t cbDma,
1927	uint32_t cbToRead, uint32_t *pcbRead)
1928	{
1929	uint32_t cbFree = (uint32_t)RTCircBufFree(pStream->State.pCircBuf);
1930	//Assert(cbToRead <= cbFree); /** @todo Add statistics for overflows. */
1931	cbToRead = RT_MIN(cbToRead, cbFree);
1932
1933	uint32_t cbReadTotal = 0;
1934	while (cbToRead)
1935	{
1936	void *pv = NULL;
1937	size_t cb = 0;
1938	RTCircBufAcquireWriteBlock(pStream->State.pCircBuf, RT_MIN(cbDma - offDma, cbToRead), &pv, &cb);
1939
1940	uint32_t cbRead = 0;
1941	int rc = PDMDevHlpDMAReadMemory(pThis->pDevInsR3, uDmaChan, pv, offDma, (uint32_t)cb, &cbRead);
1942	if (RT_SUCCESS(rc))
1943	Assert(cbRead == cb);
1944	else
1945	{
1946	AssertMsgFailed(("Reading from DMA failed: %Rrc (cbReadTotal=%#x)\n", rc, cbReadTotal));
1947	RTCircBufReleaseWriteBlock(pStream->State.pCircBuf, 0);
1948	if (cbReadTotal > 0)
1949	break;
1950	*pcbRead = 0;
1951	return rc;
1952	}
1953
1954	if (RT_LIKELY(!pStream->Dbg.Runtime.pFileDMA))
1955	{ /* likely */ }
1956	else
1957	AudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMA, pv, cbRead);
1958
1959	RTCircBufReleaseWriteBlock(pStream->State.pCircBuf, cbRead);
1960
1961	Assert(cbToRead >= cbRead);
1962	pStream->State.offWrite += cbRead;
1963	offDma = (offDma + cbRead) % cbDma;
1964	cbReadTotal += cbRead;
1965	cbToRead -= cbRead;
1966	}
1967
1968	*pcbRead = cbReadTotal;
1969
1970	/* Update buffer stats. */
1971	pStream->State.StatDmaBufUsed = (uint32_t)RTCircBufUsed(pStream->State.pCircBuf);
1972
1973	return VINF_SUCCESS;
1974	}
1975
1976	/**
1977	* Enables or disables a SB16 audio stream.
1978	*
1979	* @returns VBox status code.
1980	* @param pThis The SB16 state.
1981	* @param pStream The SB16 stream to enable or disable.
1982	* @param fEnable Whether to enable or disable the stream.
1983	* @param fForce Whether to force re-opening the stream or not.
1984	* Otherwise re-opening only will happen if the PCM properties have changed.
1985	*/
1986	static int sb16StreamEnable(PSB16STATE pThis, PSB16STREAM pStream, bool fEnable, bool fForce)
1987	{
1988	if ( !fForce
1989	&& fEnable == pStream->State.fEnabled)
1990	return VINF_SUCCESS;
1991
1992	LogFlowFunc(("fEnable=%RTbool, fForce=%RTbool, fStreamEnabled=%RTbool\n", fEnable, fForce, pStream->State.fEnabled));
1993
1994	PAUDMIXSINK pSink = sb16StreamIndexToSink(pThis, pStream->uIdx);
1995	AssertPtrReturn(pSink, VERR_INTERNAL_ERROR_2);
1996
1997	/* We only need to register the AIO update job the first time around as the requence doesn't change. */
1998	int rc;
1999	if (fEnable && !pStream->State.fRegisteredAsyncUpdateJob)
2000	{
2001	rc = AudioMixerSinkAddUpdateJob(pSink, sb16StreamUpdateAsyncIoJob, pStream, RT_MS_1SEC / pStream->uTimerHz);
2002	AssertRC(rc);
2003	pStream->State.fRegisteredAsyncUpdateJob = RT_SUCCESS(rc) \|\| rc == VERR_ALREADY_EXISTS;
2004	}
2005
2006	/* Tell the mixer. */
2007	if (fEnable)
2008	{
2009	rc = AudioMixerSinkStart(pSink);
2010	AssertRCReturn(rc, rc);
2011	}
2012	else
2013	{
2014	rc = AudioMixerSinkDrainAndStop(pSink, pStream->State.pCircBuf ? (uint32_t)RTCircBufUsed(pStream->State.pCircBuf) : 0);
2015	AssertRCReturn(rc, rc);
2016	}
2017
2018	pStream->State.fEnabled = fEnable;
2019
2020	return rc;
2021	}
2022
2023	/**
2024	* Retrieves the audio mixer sink of a corresponding SB16 stream.
2025	*
2026	* @returns Pointer to audio mixer sink if found, or NULL if not found / invalid.
2027	* @param pThis The SB16 state.
2028	* @param uIdx Stream index to get audio mixer sink for.
2029	*/
2030	DECLINLINE(PAUDMIXSINK) sb16StreamIndexToSink(PSB16STATE pThis, uint8_t uIdx)
2031	{
2032	AssertReturn(uIdx <= SB16_MAX_STREAMS, NULL);
2033
2034	/* Dead simple for now; make this more sophisticated if we have more stuff to cover. */
2035	if (uIdx == SB16_IDX_OUT)
2036	return pThis->pSinkOut; /* Can be NULL if not configured / set up yet. */
2037
2038	AssertMsgFailed(("No sink attached (yet) for index %RU8\n", uIdx));
2039	return NULL;
2040	}
2041
2042	/**
2043	* Returns the audio direction of a specified stream descriptor.
2044	*
2045	* @returns Audio direction.
2046	* @param uIdx Stream index to get audio direction for.
2047	*/
2048	DECLINLINE(PDMAUDIODIR) sb16GetDirFromIndex(uint8_t uIdx)
2049	{
2050	AssertReturn(uIdx <= SB16_MAX_STREAMS, PDMAUDIODIR_INVALID);
2051
2052	/* Dead simple for now; make this more sophisticated if we have more stuff to cover. */
2053	if (uIdx == SB16_IDX_OUT)
2054	return PDMAUDIODIR_OUT;
2055
2056	return PDMAUDIODIR_INVALID;
2057	}
2058
2059	/**
2060	* Creates a SB16 audio stream.
2061	*
2062	* @returns VBox status code.
2063	* @param pThis The SB16 state.
2064	* @param pStream The SB16 stream to create.
2065	* @param uIdx Stream index to assign.
2066	*/
2067	static int sb16StreamCreate(PSB16STATE pThis, PSB16STREAM pStream, uint8_t uIdx)
2068	{
2069	LogFlowFuncEnter();
2070
2071	pStream->Dbg.Runtime.fEnabled = pThis->Dbg.fEnabled;
2072
2073	if (RT_LIKELY(!pStream->Dbg.Runtime.fEnabled))
2074	{ /* likely */ }
2075	else
2076	{
2077	int rc2 = AudioHlpFileCreateF(&pStream->Dbg.Runtime.pFileDMA, AUDIOHLPFILE_FLAGS_NONE, AUDIOHLPFILETYPE_WAV,
2078	pThis->Dbg.pszOutPath, AUDIOHLPFILENAME_FLAGS_NONE, 0 /uInstance/,
2079	sb16GetDirFromIndex(pStream->uIdx) == PDMAUDIODIR_IN
2080	? "sb16StreamWriteSD%RU8" : "sb16StreamReadSD%RU8", pStream->uIdx);
2081	AssertRC(rc2);
2082
2083	/* Delete stale debugging files from a former run. */
2084	AudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMA);
2085	}
2086
2087	pStream->uIdx = uIdx;
2088
2089	return VINF_SUCCESS;
2090	}
2091
2092	/**
2093	* Destroys a SB16 audio stream.
2094	*
2095	* @returns VBox status code.
2096	* @param pDevIns The device instance.
2097	* @param pThis The SB16 state.
2098	* @param pStream The SB16 stream to destroy.
2099	*/
2100	static int sb16StreamDestroy(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream)
2101	{
2102	LogFlowFuncEnter();
2103
2104	sb16StreamClose(pDevIns, pThis, pStream);
2105
2106	if (pStream->State.fRegisteredAsyncUpdateJob)
2107	{
2108	PAUDMIXSINK pSink = sb16StreamIndexToSink(pThis, pStream->uIdx);
2109	if (pSink)
2110	AudioMixerSinkRemoveUpdateJob(pSink, sb16StreamUpdateAsyncIoJob, pStream);
2111	pStream->State.fRegisteredAsyncUpdateJob = false;
2112	}
2113
2114	if (pStream->State.pCircBuf)
2115	{
2116	RTCircBufDestroy(pStream->State.pCircBuf);
2117	pStream->State.pCircBuf = NULL;
2118	}
2119
2120	if (RT_LIKELY(!pStream->Dbg.Runtime.fEnabled))
2121	{ /* likely */ }
2122	else
2123	{
2124	AudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMA);
2125	pStream->Dbg.Runtime.pFileDMA = NULL;
2126	}
2127
2128	pStream->uIdx = UINT8_MAX;
2129
2130	return VINF_SUCCESS;
2131	}
2132
2133	/**
2134	* Resets a SB16 stream.
2135	*
2136	* @param pThis The SB16 state.
2137	* @param pStream The SB16 stream to reset.
2138	*/
2139	static void sb16StreamReset(PSB16STATE pThis, PSB16STREAM pStream)
2140	{
2141	LogFlowFuncEnter();
2142
2143	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 0);
2144	if (pStream->dma_auto)
2145	{
2146	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 1);
2147	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 0);
2148
2149	pStream->dma_auto = 0;
2150	}
2151
2152	sb16StreamControl(pThis->pDevInsR3, pThis, pStream, false /* fRun */);
2153	sb16StreamEnable(pThis, pStream, false /* fEnable /, false / fForce */);
2154
2155	switch (pStream->uIdx)
2156	{
2157	case SB16_IDX_OUT:
2158	{
2159	pStream->Cfg.enmDir = PDMAUDIODIR_OUT;
2160	pStream->Cfg.enmPath = PDMAUDIOPATH_OUT_FRONT;
2161
2162	PDMAudioPropsInit(&pStream->Cfg.Props, 1 /* 8-bit /, false / fSigned /, 1 / Mono /, 11025 / uHz */);
2163	RTStrCopy(pStream->Cfg.szName, sizeof(pStream->Cfg.szName), "Output");
2164	break;
2165	}
2166
2167	default:
2168	AssertFailed();
2169	break;
2170	}
2171
2172	pStream->cbDmaLeft = 0;
2173	pStream->cbDmaBlockSize = 0;
2174	pStream->can_write = 1; /** @ŧodo r=andy BUGBUG Figure out why we (still) need this. */
2175
2176	/** @todo Also reset corresponding DSP values here? */
2177	}
2178
2179	/**
2180	* Opens a SB16 stream with its current mixer settings.
2181	*
2182	* @returns VBox status code.
2183	* @param pDevIns The device instance.
2184	* @param pThis The SB16 device state.
2185	* @param pStream The SB16 stream to open.
2186	*
2187	* @note This currently only supports the one and only output stream.
2188	*/
2189	static int sb16StreamOpen(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream)
2190	{
2191	LogFlowFuncEnter();
2192	AssertLogRelReturn(PDMAudioPropsAreValid(&pStream->Cfg.Props), VERR_INTERNAL_ERROR_5);
2193
2194	switch (pStream->uIdx)
2195	{
2196	case SB16_IDX_OUT:
2197	pStream->Cfg.enmDir = PDMAUDIODIR_OUT;
2198	pStream->Cfg.enmPath = PDMAUDIOPATH_OUT_FRONT;
2199
2200	RTStrCopy(pStream->Cfg.szName, sizeof(pStream->Cfg.szName), "Output");
2201	break;
2202
2203	default:
2204	AssertFailed();
2205	break;
2206	}
2207
2208	LogRel2(("SB16: (Re-)Opening stream '%s' (%RU32Hz, %RU8 channels, %s%RU8)\n", pStream->Cfg.szName, pStream->Cfg.Props.uHz,
2209	PDMAudioPropsChannels(&pStream->Cfg.Props), pStream->Cfg.Props.fSigned ? "S" : "U",
2210	PDMAudioPropsSampleBits(&pStream->Cfg.Props)));
2211
2212	/* (Re-)create the stream's internal ring buffer. */
2213	if (pStream->State.pCircBuf)
2214	{
2215	RTCircBufDestroy(pStream->State.pCircBuf);
2216	pStream->State.pCircBuf = NULL;
2217	}
2218
2219	/** @todo r=bird: two DMA periods is probably too little. */
2220	const uint32_t cbCircBuf = PDMAudioPropsMilliToBytes(&pStream->Cfg.Props,
2221	(RT_MS_1SEC / pStream->uTimerHz) * 2 /* Use double buffering here */);
2222
2223	int rc = RTCircBufCreate(&pStream->State.pCircBuf, cbCircBuf);
2224	AssertRCReturn(rc, rc);
2225	pStream->State.StatDmaBufSize = (uint32_t)RTCircBufSize(pStream->State.pCircBuf);
2226
2227	/* Set scheduling hint. */
2228	pStream->Cfg.Device.cMsSchedulingHint = RT_MS_1SEC / RT_MIN(pStream->uTimerHz, 1);
2229
2230	PAUDMIXSINK pMixerSink = sb16StreamIndexToSink(pThis, pStream->uIdx);
2231	AssertPtrReturn(pMixerSink, VERR_INVALID_POINTER);
2232
2233	sb16RemoveDrvStreams(pDevIns, pThis,
2234	sb16StreamIndexToSink(pThis, pStream->uIdx), pStream->Cfg.enmDir, pStream->Cfg.enmPath);
2235
2236	rc = sb16AddDrvStreams(pDevIns, pThis, pMixerSink, &pStream->Cfg);
2237	if (RT_SUCCESS(rc))
2238	{
2239	if (RT_LIKELY(!pStream->Dbg.Runtime.fEnabled))
2240	{ /* likely */ }
2241	else
2242	{
2243	/* Make sure to close + delete a former debug file, as the PCM format has changed (e.g. U8 -> S16). */
2244	if (AudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMA))
2245	{
2246	AudioHlpFileClose(pStream->Dbg.Runtime.pFileDMA);
2247	AudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMA);
2248	}
2249
2250	int rc2 = AudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMA, AUDIOHLPFILE_DEFAULT_OPEN_FLAGS,
2251	&pStream->Cfg.Props);
2252	AssertRC(rc2);
2253	}
2254	}
2255
2256	LogFlowFuncLeaveRC(rc);
2257	return rc;
2258	}
2259
2260	/**
2261	* Closes a SB16 stream.
2262	*
2263	* @param pDevIns The device instance.
2264	* @param pThis SB16 state.
2265	* @param pStream The SB16 stream to close.
2266	*/
2267	static void sb16StreamClose(PPDMDEVINS pDevIns, PSB16STATE pThis, PSB16STREAM pStream)
2268	{
2269	RT_NOREF(pDevIns, pThis, pStream);
2270
2271	LogFlowFuncEnter();
2272
2273	/* Nothing to do in here right now. */
2274	}
2275
2276	static void sb16StreamTransferScheduleNext(PSB16STATE pThis, PSB16STREAM pStream, uint32_t cbBytes)
2277	{
2278	RT_NOREF(pStream);
2279
2280	uint64_t const uTimerHz = PDMDevHlpTimerGetFreq(pThis->pDevInsR3, pThis->hTimerIRQ);
2281
2282	const uint64_t usBytes = PDMAudioPropsBytesToMicro(&pStream->Cfg.Props, cbBytes);
2283	const uint64_t cTransferTicks = PDMDevHlpTimerFromMicro(pThis->pDevInsR3, pThis->hTimerIRQ, usBytes);
2284
2285	LogFlowFunc(("%RU32 bytes -> %RU64 ticks\n", cbBytes, cTransferTicks));
2286
2287	if (cTransferTicks < uTimerHz / 1024) /** @todo Explain this. */
2288	{
2289	LogFlowFunc(("IRQ\n"));
2290	PDMDevHlpISASetIrq(pThis->pDevInsR3, pStream->HwCfgRuntime.uIrq, 1);
2291	}
2292	else
2293	{
2294	LogFlowFunc(("Scheduled\n"));
2295	PDMDevHlpTimerSetRelative(pThis->pDevInsR3, pThis->hTimerIRQ, cTransferTicks, NULL);
2296	}
2297	}
2298
2299
2300	/**
2301	* Output streams: Pushes data to the mixer.
2302	*
2303	* @param pStream The SB16 stream.
2304	* @param pSink The mixer sink to push to.
2305	*/
2306	static void sb16StreamPushToMixer(PSB16STREAM pStream, PAUDMIXSINK pSink)
2307	{
2308	#ifdef LOG_ENABLED
2309	uint64_t const offReadOld = pStream->State.offRead;
2310	#endif
2311	pStream->State.offRead = AudioMixerSinkTransferFromCircBuf(pSink,
2312	pStream->State.pCircBuf,
2313	pStream->State.offRead,
2314	pStream->uIdx,
2315	/** @todo pStream->Dbg.Runtime.fEnabled
2316	? pStream->Dbg.Runtime.pFileStream :*/ NULL);
2317
2318	Log3Func(("[SD%RU8] transferred=%#RX64 bytes -> @%#RX64\n", pStream->uIdx,
2319	pStream->State.offRead - offReadOld, pStream->State.offRead));
2320
2321	/* Update buffer stats. */
2322	pStream->State.StatDmaBufUsed = (uint32_t)RTCircBufUsed(pStream->State.pCircBuf);
2323	}
2324
2325
2326	/**
2327	* @callback_method_impl{FNAUDMIXSINKUPDATE}
2328	*
2329	* For output streams this moves data from the internal DMA buffer (in which
2330	* ichac97R3StreamUpdateDma put it), thru the mixer and to the various backend
2331	* audio devices.
2332	*/
2333	static DECLCALLBACK(void) sb16StreamUpdateAsyncIoJob(PPDMDEVINS pDevIns, PAUDMIXSINK pSink, void *pvUser)
2334	{
2335	PSB16STATE const pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2336	PSB16STREAM const pStream = (PSB16STREAM)pvUser;
2337	Assert(pStream->uIdx == (uintptr_t)(pStream - &pThis->aStreams[0]));
2338	Assert(pSink == sb16StreamIndexToSink(pThis, pStream->uIdx));
2339	RT_NOREF(pThis);
2340
2341	/*
2342	* Output.
2343	*/
2344	if (sb16GetDirFromIndex(pStream->uIdx) == PDMAUDIODIR_OUT)
2345	sb16StreamPushToMixer(pStream, pSink);
2346	/*
2347	* No input streams at present.
2348	*/
2349	else
2350	AssertFailed();
2351	}
2352
2353
2354	/*********************************************************************************************************************************
2355	* Saved state handling *
2356	*********************************************************************************************************************************/
2357
2358	/**
2359	* @callback_method_impl{FNSSMDEVLIVEEXEC}
2360	*/
2361	static DECLCALLBACK(int) sb16LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
2362	{
2363	RT_NOREF(uPass);
2364
2365	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2366	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2367
2368	/** Currently the saved state only contains the one-and-only output stream. */
2369	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
2370
2371	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgDefault.uIrq);
2372	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgDefault.uDmaChanLow);
2373	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgDefault.uDmaChanHigh);
2374	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgDefault.uPort);
2375	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgDefault.uVer);
2376	return VINF_SSM_DONT_CALL_AGAIN;
2377	}
2378
2379	/**
2380	* Worker for sb16SaveExec.
2381	*/
2382	static int sb16Save(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, PSB16STATE pThis)
2383	{
2384	/* The saved state only contains the one-and-only output stream. */
2385	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
2386
2387	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgRuntime.uIrq);
2388	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgRuntime.uDmaChanLow);
2389	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgRuntime.uDmaChanHigh);
2390	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgRuntime.uPort);
2391	pHlp->pfnSSMPutS32(pSSM, pStream->HwCfgRuntime.uVer);
2392	pHlp->pfnSSMPutS32(pSSM, pThis->dsp_in_idx);
2393	pHlp->pfnSSMPutS32(pSSM, pThis->dsp_out_data_len);
2394
2395	pHlp->pfnSSMPutS32(pSSM, PDMAudioPropsChannels(&pStream->Cfg.Props) >= 2 ? 1 : 0);
2396	pHlp->pfnSSMPutS32(pSSM, PDMAudioPropsIsSigned(&pStream->Cfg.Props) ? 1 : 0);
2397	pHlp->pfnSSMPutS32(pSSM, PDMAudioPropsSampleBits(&pStream->Cfg.Props));
2398	pHlp->pfnSSMPutU32(pSSM, 0); /* Legacy; was PDMAUDIOFMT, unused now. */
2399
2400	pHlp->pfnSSMPutS32(pSSM, pStream->dma_auto);
2401	pHlp->pfnSSMPutS32(pSSM, pStream->cbDmaBlockSize);
2402	pHlp->pfnSSMPutS32(pSSM, pStream->fifo);
2403	pHlp->pfnSSMPutS32(pSSM, PDMAudioPropsHz(&pStream->Cfg.Props));
2404	pHlp->pfnSSMPutS32(pSSM, pStream->time_const);
2405	pHlp->pfnSSMPutS32(pSSM, 0); /* Legacy; was speaker control (on/off) for output stream. */
2406	pHlp->pfnSSMPutS32(pSSM, pThis->dsp_in_needed_bytes);
2407	pHlp->pfnSSMPutS32(pSSM, pThis->cmd);
2408	pHlp->pfnSSMPutS32(pSSM, pStream->fDmaUseHigh);
2409	pHlp->pfnSSMPutS32(pSSM, pThis->highspeed);
2410	pHlp->pfnSSMPutS32(pSSM, pStream->can_write);
2411	pHlp->pfnSSMPutS32(pSSM, pThis->v2x6);
2412
2413	pHlp->pfnSSMPutU8 (pSSM, pThis->csp_param);
2414	pHlp->pfnSSMPutU8 (pSSM, pThis->csp_value);
2415	pHlp->pfnSSMPutU8 (pSSM, pThis->csp_mode);
2416	pHlp->pfnSSMPutU8 (pSSM, pThis->csp_param); /* Bug compatible! */
2417	pHlp->pfnSSMPutMem(pSSM, pThis->csp_regs, 256);
2418	pHlp->pfnSSMPutU8 (pSSM, pThis->csp_index);
2419	pHlp->pfnSSMPutMem(pSSM, pThis->csp_reg83, 4);
2420	pHlp->pfnSSMPutS32(pSSM, pThis->csp_reg83r);
2421	pHlp->pfnSSMPutS32(pSSM, pThis->csp_reg83w);
2422
2423	pHlp->pfnSSMPutMem(pSSM, pThis->dsp_in_data, sizeof(pThis->dsp_in_data));
2424	pHlp->pfnSSMPutMem(pSSM, pThis->dsp_out_data, sizeof(pThis->dsp_out_data));
2425	pHlp->pfnSSMPutU8 (pSSM, pThis->test_reg);
2426	pHlp->pfnSSMPutU8 (pSSM, pThis->last_read_byte);
2427
2428	pHlp->pfnSSMPutS32(pSSM, pThis->nzero);
2429	pHlp->pfnSSMPutS32(pSSM, pStream->cbDmaLeft);
2430	pHlp->pfnSSMPutS32(pSSM, pStream->State.fEnabled ? 1 : 0);
2431	/* The stream's bitrate. Needed for backwards (legacy) compatibility. */
2432	pHlp->pfnSSMPutS32(pSSM, AudioHlpCalcBitrate(PDMAudioPropsSampleBits(&pThis->aStreams[SB16_IDX_OUT].Cfg.Props),
2433	PDMAudioPropsHz(&pThis->aStreams[SB16_IDX_OUT].Cfg.Props),
2434	PDMAudioPropsChannels(&pThis->aStreams[SB16_IDX_OUT].Cfg.Props)));
2435	/* Block size alignment, superfluous and thus not saved anymore. Needed for backwards (legacy) compatibility. */
2436	pHlp->pfnSSMPutS32(pSSM, 0);
2437
2438	pHlp->pfnSSMPutS32(pSSM, pThis->mixer_nreg);
2439	return pHlp->pfnSSMPutMem(pSSM, pThis->mixer_regs, 256);
2440	}
2441
2442	/**
2443	* @callback_method_impl{FNSSMDEVSAVEEXEC}
2444	*/
2445	static DECLCALLBACK(int) sb16SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2446	{
2447	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2448	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2449
2450	sb16LiveExec(pDevIns, pSSM, 0);
2451	return sb16Save(pHlp, pSSM, pThis);
2452	}
2453
2454	/**
2455	* Worker for sb16LoadExec.
2456	*/
2457	static int sb16Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PSB16STATE pThis)
2458	{
2459	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2460	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT]; /* The saved state only contains the one-and-only output stream. */
2461	int rc;
2462
2463	int32_t i32Tmp;
2464	pHlp->pfnSSMGetS32(pSSM, &i32Tmp);
2465	pStream->HwCfgRuntime.uIrq = i32Tmp; /* IRQ. */
2466	pHlp->pfnSSMGetS32(pSSM, &i32Tmp);
2467	pStream->HwCfgRuntime.uDmaChanLow = i32Tmp; /* Low (8-bit) DMA channel. */
2468	pHlp->pfnSSMGetS32(pSSM, &i32Tmp);
2469	pStream->HwCfgRuntime.uDmaChanHigh = i32Tmp; /* High (16-bit) DMA channel. */
2470	pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* Used I/O port. */
2471	pStream->HwCfgRuntime.uPort = i32Tmp;
2472	pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* DSP version running. */
2473	pStream->HwCfgRuntime.uVer = i32Tmp;
2474	pHlp->pfnSSMGetS32(pSSM, &pThis->dsp_in_idx);
2475	pHlp->pfnSSMGetS32(pSSM, &pThis->dsp_out_data_len);
2476
2477	rc = pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* Output stream: Number of channels. */
2478	AssertRCReturn(rc, rc);
2479	AssertReturn((uint32_t)i32Tmp <= 1, VERR_INVALID_PARAMETER); /* Paranoia. */
2480	if (i32Tmp) /* PDMAudioPropsSetChannels() will assert if channels are 0 (will be re-set on DMA run command). */
2481	PDMAudioPropsSetChannels(&pStream->Cfg.Props, (uint8_t)i32Tmp);
2482	pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* Output stream: Signed format bit. */
2483	pStream->Cfg.Props.fSigned = i32Tmp != 0;
2484	rc = pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* Output stream: Sample size in bits. */
2485	AssertRCReturn(rc, rc);
2486	if (i32Tmp) /* PDMAudioPropsSetSampleSize() will assert if sample size is 0 (will be re-set on DMA run command). */
2487	PDMAudioPropsSetSampleSize(&pStream->Cfg.Props, (uint8_t)(i32Tmp / 8));
2488
2489	pHlp->pfnSSMSkip (pSSM, sizeof(int32_t)); /* Legacy; was PDMAUDIOFMT, unused now. */
2490	pHlp->pfnSSMGetS32(pSSM, &pStream->dma_auto);
2491	pHlp->pfnSSMGetS32(pSSM, &pStream->cbDmaBlockSize);
2492	pHlp->pfnSSMGetS32(pSSM, &pStream->fifo);
2493	pHlp->pfnSSMGetS32(pSSM, &i32Tmp); pStream->Cfg.Props.uHz = i32Tmp;
2494	pHlp->pfnSSMGetS32(pSSM, &pStream->time_const);
2495	pHlp->pfnSSMSkip (pSSM, sizeof(int32_t)); /* Legacy; was speaker (on / off) for output stream. */
2496	pHlp->pfnSSMGetS32(pSSM, &pThis->dsp_in_needed_bytes);
2497	pHlp->pfnSSMGetS32(pSSM, &pThis->cmd);
2498	pHlp->pfnSSMGetS32(pSSM, &pStream->fDmaUseHigh); /* Output stream: Whether to use the high or low DMA channel. */
2499	pHlp->pfnSSMGetS32(pSSM, &pThis->highspeed);
2500	pHlp->pfnSSMGetS32(pSSM, &pStream->can_write);
2501	pHlp->pfnSSMGetS32(pSSM, &pThis->v2x6);
2502
2503	pHlp->pfnSSMGetU8 (pSSM, &pThis->csp_param);
2504	pHlp->pfnSSMGetU8 (pSSM, &pThis->csp_value);
2505	pHlp->pfnSSMGetU8 (pSSM, &pThis->csp_mode);
2506	pHlp->pfnSSMGetU8 (pSSM, &pThis->csp_param); /* Bug compatible! */
2507	pHlp->pfnSSMGetMem(pSSM, pThis->csp_regs, 256);
2508	pHlp->pfnSSMGetU8 (pSSM, &pThis->csp_index);
2509	pHlp->pfnSSMGetMem(pSSM, pThis->csp_reg83, 4);
2510	pHlp->pfnSSMGetS32(pSSM, &pThis->csp_reg83r);
2511	pHlp->pfnSSMGetS32(pSSM, &pThis->csp_reg83w);
2512
2513	pHlp->pfnSSMGetMem(pSSM, pThis->dsp_in_data, sizeof(pThis->dsp_in_data));
2514	pHlp->pfnSSMGetMem(pSSM, pThis->dsp_out_data, sizeof(pThis->dsp_out_data));
2515	pHlp->pfnSSMGetU8 (pSSM, &pThis->test_reg);
2516	pHlp->pfnSSMGetU8 (pSSM, &pThis->last_read_byte);
2517
2518	pHlp->pfnSSMGetS32(pSSM, &pThis->nzero);
2519	pHlp->pfnSSMGetS32(pSSM, &pStream->cbDmaLeft);
2520	pHlp->pfnSSMGetS32(pSSM, &i32Tmp); /* Output stream: DMA currently running bit. */
2521	const bool fStreamEnabled = i32Tmp != 0;
2522	pHlp->pfnSSMSkip (pSSM, sizeof(int32_t)); /* Legacy; was the output stream's current bitrate (in bytes). */
2523	pHlp->pfnSSMSkip (pSSM, sizeof(int32_t)); /* Legacy; was the output stream's DMA block alignment. */
2524
2525	int32_t mixer_nreg = 0;
2526	rc = pHlp->pfnSSMGetS32(pSSM, &mixer_nreg);
2527	AssertRCReturn(rc, rc);
2528	pThis->mixer_nreg = (uint8_t)mixer_nreg;
2529	rc = pHlp->pfnSSMGetMem(pSSM, pThis->mixer_regs, 256);
2530	AssertRCReturn(rc, rc);
2531
2532	if (fStreamEnabled)
2533	{
2534	/* Sanity: If stream is going be enabled, PCM props must be valid. Otherwise the saved state is borked somehow. */
2535	AssertMsgReturn(AudioHlpPcmPropsAreValidAndSupported(&pStream->Cfg.Props),
2536	("PCM properties for stream #%RU8 are invalid\n", pStream->uIdx), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2537	sb16StreamControl(pDevIns, pThis, pStream, true /* fRun */);
2538	}
2539
2540	/* Update the master (mixer) and PCM out volumes. */
2541	sb16UpdateVolume(pThis);
2542
2543	return VINF_SUCCESS;
2544	}
2545
2546	/**
2547	* @callback_method_impl{FNSSMDEVLOADEXEC}
2548	*/
2549	static DECLCALLBACK(int) sb16LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2550	{
2551	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2552	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2553
2554	AssertMsgReturn( uVersion == SB16_SAVE_STATE_VERSION
2555	\|\| uVersion == SB16_SAVE_STATE_VERSION_VBOX_30,
2556	("%u\n", uVersion),
2557	VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
2558	if (uVersion > SB16_SAVE_STATE_VERSION_VBOX_30)
2559	{
2560	/** Currently the saved state only contains the one-and-only output stream. */
2561	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
2562
2563	int32_t irq;
2564	pHlp->pfnSSMGetS32(pSSM, &irq);
2565	int32_t dma;
2566	pHlp->pfnSSMGetS32(pSSM, &dma);
2567	int32_t hdma;
2568	pHlp->pfnSSMGetS32(pSSM, &hdma);
2569	int32_t port;
2570	pHlp->pfnSSMGetS32(pSSM, &port);
2571	int32_t ver;
2572	int rc = pHlp->pfnSSMGetS32(pSSM, &ver);
2573	AssertRCReturn (rc, rc);
2574
2575	if ( irq != pStream->HwCfgDefault.uIrq
2576	\|\| dma != pStream->HwCfgDefault.uDmaChanLow
2577	\|\| hdma != pStream->HwCfgDefault.uDmaChanHigh
2578	\|\| port != pStream->HwCfgDefault.uPort
2579	\|\| ver != pStream->HwCfgDefault.uVer)
2580	{
2581	return pHlp->pfnSSMSetCfgError(pSSM, RT_SRC_POS,
2582	N_("config changed: irq=%x/%x dma=%x/%x hdma=%x/%x port=%x/%x ver=%x/%x (saved/config)"),
2583	irq, pStream->HwCfgDefault.uIrq,
2584	dma, pStream->HwCfgDefault.uDmaChanLow,
2585	hdma, pStream->HwCfgDefault.uDmaChanHigh,
2586	port, pStream->HwCfgDefault.uPort,
2587	ver, pStream->HwCfgDefault.uVer);
2588	}
2589	}
2590
2591	if (uPass != SSM_PASS_FINAL)
2592	return VINF_SUCCESS;
2593
2594	return sb16Load(pDevIns, pSSM, pThis);
2595	}
2596
2597
2598	/*********************************************************************************************************************************
2599	* Debug Info Items *
2600	*********************************************************************************************************************************/
2601
2602	/**
2603	* @callback_method_impl{FNDBGFHANDLERDEV, sb16mixer}
2604	*/
2605	static DECLCALLBACK(void) sb16DbgInfoMixer(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
2606	{
2607	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2608	if (pThis->pMixer)
2609	AudioMixerDebug(pThis->pMixer, pHlp, pszArgs);
2610	else
2611	pHlp->pfnPrintf(pHlp, "Mixer not available\n");
2612	}
2613
2614
2615	/*********************************************************************************************************************************
2616	* IBase implementation *
2617	*********************************************************************************************************************************/
2618
2619	/**
2620	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
2621	*/
2622	static DECLCALLBACK(void ) sb16QueryInterface(struct PDMIBASE pInterface, const char *pszIID)
2623	{
2624	PSB16STATE pThis = RT_FROM_MEMBER(pInterface, SB16STATE, IBase);
2625	Assert(&pThis->IBase == pInterface);
2626
2627	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2628	return NULL;
2629	}
2630
2631
2632	/*********************************************************************************************************************************
2633	* Device (PDM) handling *
2634	*********************************************************************************************************************************/
2635
2636	/**
2637	* Worker for sb16Construct() and sb16Attach().
2638	*
2639	* @returns VBox status code.
2640	* @param pThis SB16 state.
2641	* @param uLUN The logical unit which is being detached.
2642	* @param ppDrv Attached driver instance on success. Optional.
2643	*/
2644	static int sb16AttachInternal(PSB16STATE pThis, unsigned uLUN, PSB16DRIVER *ppDrv)
2645	{
2646	/*
2647	* Allocate a new driver structure and try attach the driver.
2648	*/
2649	PSB16DRIVER pDrv = (PSB16DRIVER)RTMemAllocZ(sizeof(SB16DRIVER));
2650	AssertPtrReturn(pDrv, VERR_NO_MEMORY);
2651	RTStrPrintf(pDrv->szDesc, sizeof(pDrv->szDesc), "Audio driver port (SB16) for LUN #%u", uLUN);
2652
2653	PPDMIBASE pDrvBase;
2654	int rc = PDMDevHlpDriverAttach(pThis->pDevInsR3, uLUN, &pThis->IBase, &pDrvBase, pDrv->szDesc);
2655	if (RT_SUCCESS(rc))
2656	{
2657	pDrv->pConnector = PDMIBASE_QUERY_INTERFACE(pDrvBase, PDMIAUDIOCONNECTOR);
2658	AssertPtr(pDrv->pConnector);
2659	if (RT_VALID_PTR(pDrv->pConnector))
2660	{
2661	pDrv->pDrvBase = pDrvBase;
2662	pDrv->pSB16State = pThis;
2663	pDrv->uLUN = uLUN;
2664
2665	/* Attach to driver list if not attached yet. */
2666	if (!pDrv->fAttached)
2667	{
2668	RTListAppend(&pThis->lstDrv, &pDrv->Node);
2669	pDrv->fAttached = true;
2670	}
2671
2672	if (ppDrv)
2673	*ppDrv = pDrv;
2674	LogFunc(("LUN#%u: returns VINF_SUCCESS (pCon=%p)\n", uLUN, pDrv->pConnector));
2675	return VINF_SUCCESS;
2676	}
2677	rc = VERR_PDM_MISSING_INTERFACE_BELOW;
2678	}
2679	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2680	LogFunc(("No attached driver for LUN #%u\n", uLUN));
2681	else
2682	LogFunc(("Failed to attached driver for LUN #%u: %Rrc\n", uLUN, rc));
2683	RTMemFree(pDrv);
2684
2685	LogFunc(("LUN#%u: rc=%Rrc\n", uLUN, rc));
2686	return rc;
2687	}
2688
2689	/**
2690	* @interface_method_impl{PDMDEVREG,pfnAttach}
2691	*/
2692	static DECLCALLBACK(int) sb16Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2693	{
2694	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2695	RT_NOREF(fFlags);
2696	LogFunc(("iLUN=%u, fFlags=%#x\n", iLUN, fFlags));
2697
2698	/** @todo r=andy Any locking required here? */
2699
2700	PSB16DRIVER pDrv;
2701	int rc = sb16AttachInternal(pThis, iLUN, &pDrv);
2702	if (RT_SUCCESS(rc))
2703	{
2704	int rc2 = sb16AddDrv(pDevIns, pThis, pDrv);
2705	if (RT_FAILURE(rc2))
2706	LogFunc(("sb16AddDrv failed with %Rrc (ignored)\n", rc2));
2707	}
2708
2709	return rc;
2710	}
2711
2712	/**
2713	* @interface_method_impl{PDMDEVREG,pfnDetach}
2714	*/
2715	static DECLCALLBACK(void) sb16Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2716	{
2717	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2718	RT_NOREF(fFlags);
2719
2720	LogFunc(("iLUN=%u, fFlags=0x%x\n", iLUN, fFlags));
2721
2722	PSB16DRIVER pDrv;
2723	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
2724	{
2725	if (pDrv->uLUN == iLUN)
2726	{
2727	sb16RemoveDrv(pDevIns, pThis, pDrv);
2728	RTMemFree(pDrv);
2729	return;
2730	}
2731	}
2732	LogFunc(("LUN#%u was not found\n", iLUN));
2733	}
2734
2735
2736	/**
2737	* @interface_method_impl{PDMDEVREG,pfnReset}
2738	*/
2739	static DECLCALLBACK(void) sb16DevReset(PPDMDEVINS pDevIns)
2740	{
2741	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2742
2743	LogRel2(("SB16: Reset\n"));
2744
2745	pThis->mixer_regs[0x82] = 0;
2746	pThis->csp_regs[5] = 1;
2747	pThis->csp_regs[9] = 0xf8;
2748
2749	pThis->dsp_in_idx = 0;
2750	pThis->dsp_out_data_len = 0;
2751	pThis->dsp_in_needed_bytes = 0;
2752	pThis->nzero = 0;
2753	pThis->highspeed = 0;
2754	pThis->v2x6 = 0;
2755	pThis->cmd = -1;
2756
2757	sb16MixerReset(pThis);
2758	sb16SpeakerControl(pThis, false /* fOn */);
2759	sb16DspCmdResetLegacy(pThis);
2760	}
2761
2762	/**
2763	* Powers off the device.
2764	*
2765	* @param pDevIns Device instance to power off.
2766	*/
2767	static DECLCALLBACK(void) sb16PowerOff(PPDMDEVINS pDevIns)
2768	{
2769	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2770
2771	LogRel2(("SB16: Powering off ...\n"));
2772
2773	/*
2774	* Destroy all streams.
2775	*/
2776	for (unsigned i = 0; i < SB16_MAX_STREAMS; i++)
2777	sb16StreamDestroy(pDevIns, pThis, &pThis->aStreams[i]);
2778
2779	/*
2780	* Destroy all sinks.
2781	*/
2782	if (pThis->pSinkOut)
2783	{
2784	AudioMixerSinkDestroy(pThis->pSinkOut, pDevIns);
2785	pThis->pSinkOut = NULL;
2786	}
2787	/** @todo Ditto for sinks. */
2788
2789	/*
2790	* Note: Destroy the mixer while powering off and not in sb16Destruct,
2791	* giving the mixer the chance to release any references held to
2792	* PDM audio streams it maintains.
2793	*/
2794	if (pThis->pMixer)
2795	{
2796	AudioMixerDestroy(pThis->pMixer, pDevIns);
2797	pThis->pMixer = NULL;
2798	}
2799	}
2800
2801	/**
2802	* @interface_method_impl{PDMDEVREG,pfnDestruct}
2803	*/
2804	static DECLCALLBACK(int) sb16Destruct(PPDMDEVINS pDevIns)
2805	{
2806	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns); /* this shall come first */
2807	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2808
2809	LogFlowFuncEnter();
2810
2811	PSB16DRIVER pDrv;
2812	while (!RTListIsEmpty(&pThis->lstDrv))
2813	{
2814	pDrv = RTListGetFirst(&pThis->lstDrv, SB16DRIVER, Node);
2815
2816	RTListNodeRemove(&pDrv->Node);
2817	RTMemFree(pDrv);
2818	}
2819
2820	/* We don't always go via PowerOff, so make sure the mixer is destroyed. */
2821	if (pThis->pMixer)
2822	{
2823	AudioMixerDestroy(pThis->pMixer, pDevIns);
2824	pThis->pMixer = NULL;
2825	}
2826
2827	return VINF_SUCCESS;
2828	}
2829
2830	/**
2831	* @interface_method_impl{PDMDEVREGR3,pfnConstruct}
2832	*/
2833	static DECLCALLBACK(int) sb16Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2834	{
2835	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); /* this shall come first */
2836	PSB16STATE pThis = PDMDEVINS_2_DATA(pDevIns, PSB16STATE);
2837	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2838	RT_NOREF(iInstance);
2839
2840	Assert(iInstance == 0);
2841
2842	/*
2843	* Initialize the data so sb16Destruct runs without a hitch if we return early.
2844	*/
2845	pThis->pDevInsR3 = pDevIns;
2846	pThis->IBase.pfnQueryInterface = sb16QueryInterface;
2847	pThis->cmd = -1;
2848
2849	pThis->csp_regs[5] = 1;
2850	pThis->csp_regs[9] = 0xf8;
2851
2852	RTListInit(&pThis->lstDrv);
2853
2854	/*
2855	* Validate and read config data.
2856	*/
2857	/* Note: For now we only support the one-and-only output stream. */
2858	PSB16STREAM pStream = &pThis->aStreams[SB16_IDX_OUT];
2859
2860	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "IRQ\|DMA\|DMA16\|Port\|Version\|TimerHz\|DebugEnabled\|DebugPathOut", "");
2861	int rc = pHlp->pfnCFGMQueryU8Def(pCfg, "IRQ", &pStream->HwCfgDefault.uIrq, 5);
2862	if (RT_FAILURE(rc))
2863	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Failed to get the \"IRQ\" value"));
2864	/* Sanity-check supported SB16 IRQs. */
2865	if ( 2 != pStream->HwCfgDefault.uIrq
2866	&& 5 != pStream->HwCfgDefault.uIrq
2867	&& 7 != pStream->HwCfgDefault.uIrq
2868	&& 10 != pStream->HwCfgDefault.uIrq)
2869	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Invalid \"IRQ\" value."));
2870	pStream->HwCfgRuntime.uIrq = pStream->HwCfgDefault.uIrq;
2871
2872	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "DMA", &pStream->HwCfgDefault.uDmaChanLow, 1);
2873	if (RT_FAILURE(rc))
2874	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Failed to get the \"DMA\" value"));
2875	if ( 0 != pStream->HwCfgDefault.uDmaChanLow
2876	&& 1 != pStream->HwCfgDefault.uDmaChanLow
2877	&& 3 != pStream->HwCfgDefault.uDmaChanLow)
2878	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Invalid \"DMA\" value."));
2879	pStream->HwCfgRuntime.uDmaChanLow = pStream->HwCfgDefault.uDmaChanLow;
2880
2881	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "DMA16", &pStream->HwCfgDefault.uDmaChanHigh, 5);
2882	if (RT_FAILURE(rc))
2883	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Failed to get the \"DMA16\" value"));
2884	if ( 5 != pStream->HwCfgDefault.uDmaChanHigh
2885	&& 6 != pStream->HwCfgDefault.uDmaChanHigh
2886	&& 7 != pStream->HwCfgDefault.uDmaChanHigh)
2887	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Invalid \"DMA16\" value."));
2888	pStream->HwCfgRuntime.uDmaChanHigh = pStream->HwCfgDefault.uDmaChanHigh;
2889
2890	rc = pHlp->pfnCFGMQueryPortDef(pCfg, "Port", &pStream->HwCfgDefault.uPort, 0x220);
2891	if (RT_FAILURE(rc))
2892	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Failed to get the \"Port\" value"));
2893	/* Sanity-check supported SB16 ports. */
2894	if ( 0x220 != pStream->HwCfgDefault.uPort
2895	&& 0x240 != pStream->HwCfgDefault.uPort
2896	&& 0x260 != pStream->HwCfgDefault.uPort
2897	&& 0x280 != pStream->HwCfgDefault.uPort)
2898	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Invalid \"Port\" value. Did you specify it as a hex value (e.g. 0x220)?"));
2899	pStream->HwCfgRuntime.uPort = pStream->HwCfgDefault.uPort;
2900
2901	rc = pHlp->pfnCFGMQueryU16Def(pCfg, "Version", &pStream->HwCfgDefault.uVer, 0x0405);
2902	if (RT_FAILURE(rc))
2903	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Failed to get the \"Version\" value"));
2904	pStream->HwCfgRuntime.uVer = pStream->HwCfgDefault.uVer;
2905
2906	rc = pHlp->pfnCFGMQueryU16Def(pCfg, "TimerHz", &pStream->uTimerHz, SB16_TIMER_HZ_DEFAULT);
2907	if (RT_FAILURE(rc))
2908	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: failed to read Hertz rate as unsigned integer"));
2909	if (pStream->uTimerHz == 0)
2910	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Hertz rate is invalid"));
2911	if (pStream->uTimerHz > 2048)
2912	return PDMDEV_SET_ERROR(pDevIns, rc, N_("SB16 configuration error: Maximum Hertz rate is 2048"));
2913
2914	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "DebugEnabled", &pThis->Dbg.fEnabled, false);
2915	if (RT_FAILURE(rc))
2916	return PDMDEV_SET_ERROR(pDevIns, rc,
2917	N_("SB16 configuration error: failed to read debugging enabled flag as boolean"));
2918
2919	rc = pHlp->pfnCFGMQueryStringAllocDef(pCfg, "DebugPathOut", &pThis->Dbg.pszOutPath, NULL);
2920	if (RT_FAILURE(rc))
2921	return PDMDEV_SET_ERROR(pDevIns, rc,
2922	N_("SB16 configuration error: failed to read debugging output path flag as string"));
2923
2924	if (pThis->Dbg.fEnabled)
2925	LogRel2(("SB16: Debug output will be saved to '%s'\n", pThis->Dbg.pszOutPath));
2926
2927	/*
2928	* Create internal software mixer.
2929	* Must come before we do the device's mixer reset.
2930	*/
2931	rc = AudioMixerCreate("SB16 Mixer", 0 /* uFlags */, &pThis->pMixer);
2932	AssertRCReturn(rc, rc);
2933
2934	AssertRCReturn(rc, rc);
2935	rc = AudioMixerCreateSink(pThis->pMixer, "PCM Output",
2936	PDMAUDIODIR_OUT, pDevIns, &pThis->pSinkOut);
2937	AssertRCReturn(rc, rc);
2938
2939	/*
2940	* Create all hardware streams.
2941	* For now we have one stream only, namely the output (playback) stream.
2942	*/
2943	AssertCompile(RT_ELEMENTS(pThis->aStreams) == SB16_MAX_STREAMS);
2944	for (unsigned i = 0; i < SB16_MAX_STREAMS; i++)
2945	{
2946	rc = sb16StreamCreate(pThis, &pThis->aStreams[i], i /* uIdx */);
2947	AssertRCReturn(rc, rc);
2948	}
2949
2950	/*
2951	* Setup the mixer now that we've got the irq and dma channel numbers.
2952	*/
2953	pThis->mixer_regs[0x80] = magic_of_irq(pStream->HwCfgRuntime.uIrq);
2954	pThis->mixer_regs[0x81] = (1 << pStream->HwCfgRuntime.uDmaChanLow) \| (1 << pStream->HwCfgRuntime.uDmaChanHigh);
2955	pThis->mixer_regs[0x82] = 2 << 5;
2956
2957	/*
2958	* Perform a device reset before we set up the mixer below,
2959	* to have a defined state. This includes the mixer reset + legacy reset.
2960	*/
2961	sb16DevReset(pThis->pDevInsR3);
2962
2963	/*
2964	* Make sure that the mixer sink(s) have a valid format set.
2965	*
2966	* This is needed in order to make the driver attaching logic working done by Main
2967	* for machine construction. Must come after sb16DevReset().
2968	*/
2969	PSB16STREAM const pStreamOut = &pThis->aStreams[SB16_IDX_OUT];
2970	AudioMixerSinkSetFormat(pThis->pSinkOut, &pStreamOut->Cfg.Props, pStreamOut->Cfg.Device.cMsSchedulingHint);
2971
2972	/*
2973	* Create timers.
2974	*/
2975	rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIRQ, pThis,
2976	TMTIMER_FLAGS_DEFAULT_CRIT_SECT \| TMTIMER_FLAGS_NO_RING0, "SB16 IRQ", &pThis->hTimerIRQ);
2977	AssertRCReturn(rc, rc);
2978
2979	static const char * const s_apszNames[] = { "SB16 OUT" };
2980	AssertCompile(RT_ELEMENTS(s_apszNames) == SB16_MAX_STREAMS);
2981	for (unsigned i = 0; i < SB16_MAX_STREAMS; i++)
2982	{
2983	rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIO, &pThis->aStreams[i],
2984	TMTIMER_FLAGS_DEFAULT_CRIT_SECT \| TMTIMER_FLAGS_NO_RING0, s_apszNames[i], &pThis->aStreams[i].hTimerIO);
2985	AssertRCReturn(rc, rc);
2986
2987	pThis->aStreams[i].cTicksTimerIOInterval = PDMDevHlpTimerGetFreq(pDevIns, pThis->aStreams[i].hTimerIO)
2988	/ pThis->aStreams[i].uTimerHz;
2989	pThis->aStreams[i].tsTimerIO = PDMDevHlpTimerGet(pDevIns, pThis->aStreams[i].hTimerIO);
2990	}
2991
2992	/*
2993	* Register I/O and DMA.
2994	*/
2995	static const IOMIOPORTDESC s_aAllDescs[] =
2996	{
2997	{ "FM Music Status Port", "FM Music Register Address Port", NULL, NULL }, // 00h
2998	{ NULL, "FM Music Data Port", NULL, NULL }, // 01h
2999	{ "Advanced FM Music Status Port", "Advanced FM Music Register Address Port", NULL, NULL }, // 02h
3000	{ NULL, "Advanced FM Music Data Port", NULL, NULL }, // 03h
3001	{ NULL, "Mixer chip Register Address Port", NULL, NULL }, // 04h
3002	{ "Mixer chip Data Port", NULL, NULL, NULL }, // 05h
3003	{ NULL, "DSP Reset", NULL, NULL }, // 06h
3004	{ "Unused7", "Unused7", NULL, NULL }, // 07h
3005	{ "FM Music Status Port", "FM Music Register Port", NULL, NULL }, // 08h
3006	{ NULL, "FM Music Data Port", NULL, NULL }, // 09h
3007	{ "DSP Read Data Port", NULL, NULL, NULL }, // 0Ah
3008	{ "UnusedB", "UnusedB", NULL, NULL }, // 0Bh
3009	{ "DSP Write-Buffer Status", "DSP Write Command/Data", NULL, NULL }, // 0Ch
3010	{ "UnusedD", "UnusedD", NULL, NULL }, // 0Dh
3011	{ "DSP Read-Buffer Status", NULL, NULL, NULL }, // 0Eh
3012	{ "IRQ16ACK", NULL, NULL, NULL }, // 0Fh
3013	{ "CD-ROM Data Register", "CD-ROM Command Register", NULL, NULL }, // 10h
3014	{ "CD-ROM Status Register", NULL, NULL, NULL }, // 11h
3015	{ NULL, "CD-ROM Reset Register", NULL, NULL }, // 12h
3016	{ NULL, "CD-ROM Enable Register", NULL, NULL }, // 13h
3017	{ NULL, NULL, NULL, NULL },
3018	};
3019
3020	rc = PDMDevHlpIoPortCreateAndMap(pDevIns, pStream->HwCfgRuntime.uPort + 0x04 /uPort/, 2 /cPorts/,
3021	sb16IoPortMixerWrite, sb16IoPortMixerRead,
3022	"SB16 - Mixer", &s_aAllDescs[4], &pThis->hIoPortsMixer);
3023	AssertRCReturn(rc, rc);
3024	rc = PDMDevHlpIoPortCreateAndMap(pDevIns, pStream->HwCfgRuntime.uPort + 0x06 /uPort/, 10 /cPorts/,
3025	sb16IoPortDspWrite, sb16IoPortDspRead,
3026	"SB16 - DSP", &s_aAllDescs[6], &pThis->hIoPortsDsp);
3027	AssertRCReturn(rc, rc);
3028
3029	rc = PDMDevHlpDMARegister(pDevIns, pStream->HwCfgRuntime.uDmaChanHigh, sb16DMARead, &pThis->aStreams[SB16_IDX_OUT] /* pvUser */);
3030	AssertRCReturn(rc, rc);
3031	rc = PDMDevHlpDMARegister(pDevIns, pStream->HwCfgRuntime.uDmaChanLow, sb16DMARead, &pThis->aStreams[SB16_IDX_OUT] /* pvUser */);
3032	AssertRCReturn(rc, rc);
3033
3034	/*
3035	* Register Saved state.
3036	*/
3037	rc = PDMDevHlpSSMRegister3(pDevIns, SB16_SAVE_STATE_VERSION, sizeof(SB16STATE), sb16LiveExec, sb16SaveExec, sb16LoadExec);
3038	AssertRCReturn(rc, rc);
3039
3040	LogRel2(("SB16: Using port %#x, DMA%RU8, IRQ%RU8\n",
3041	pStream->HwCfgRuntime.uPort, pStream->HwCfgRuntime.uDmaChanLow, pStream->HwCfgRuntime.uIrq));
3042
3043	/*
3044	* Attach drivers. We ASSUME they are configured consecutively without any
3045	* gaps, so we stop when we hit the first LUN w/o a driver configured.
3046	*/
3047	for (unsigned iLun = 0; ; iLun++)
3048	{
3049	AssertBreak(iLun < UINT8_MAX);
3050	LogFunc(("Trying to attach driver for LUN#%u ...\n", iLun));
3051	rc = sb16AttachInternal(pThis, iLun, NULL /* ppDrv */);
3052	if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3053	{
3054	LogFunc(("cLUNs=%u\n", iLun));
3055	break;
3056	}
3057	AssertLogRelMsgReturn(RT_SUCCESS(rc), ("LUN#%u: rc=%Rrc\n", iLun, rc), rc);
3058	}
3059
3060	/*
3061	* Register statistics.
3062	*/
3063	# ifdef VBOX_WITH_STATISTICS
3064	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTimerIO, STAMTYPE_PROFILE, "Timer", STAMUNIT_TICKS_PER_CALL, "Profiling sb16TimerIO.");
3065	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, "BytesRead", STAMUNIT_BYTES, "Bytes read from SB16 emulation.");
3066	# endif
3067	for (unsigned idxStream = 0; idxStream < RT_ELEMENTS(pThis->aStreams); idxStream++)
3068	{
3069	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStreams[idxStream].State.offRead, STAMTYPE_U64, STAMVISIBILITY_USED, STAMUNIT_BYTES,
3070	"Virtual internal buffer read position.", "Stream%u/offRead", idxStream);
3071	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStreams[idxStream].State.offWrite, STAMTYPE_U64, STAMVISIBILITY_USED, STAMUNIT_BYTES,
3072	"Virtual internal buffer write position.", "Stream%u/offWrite", idxStream);
3073	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStreams[idxStream].State.StatDmaBufSize, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_BYTES,
3074	"Size of the internal DMA buffer.", "Stream%u/DMABufSize", idxStream);
3075	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStreams[idxStream].State.StatDmaBufUsed, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_BYTES,
3076	"Number of bytes used in the internal DMA buffer.", "Stream%u/DMABufUsed", idxStream);
3077	}
3078
3079	/*
3080	* Debug info items.
3081	*/
3082	//PDMDevHlpDBGFInfoRegister(pDevIns, "sb16", "SB16 registers. (sb16 [register case-insensitive])", sb16DbgInfo);
3083	//PDMDevHlpDBGFInfoRegister(pDevIns, "sb16stream", "SB16 stream info. (sb16stream [stream number])", sb16DbgInfoStream);
3084	PDMDevHlpDBGFInfoRegister(pDevIns, "sb16mixer", "SB16 mixer state.", sb16DbgInfoMixer);
3085
3086	return VINF_SUCCESS;
3087	}
3088
3089	const PDMDEVREG g_DeviceSB16 =
3090	{
3091	/* .u32Version = */ PDM_DEVREG_VERSION,
3092	/* .uReserved0 = */ 0,
3093	/* .szName = */ "sb16",
3094	/* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_NEW_STYLE
3095	\| PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION /* stream clearnup with working drivers */,
3096	/* .fClass = */ PDM_DEVREG_CLASS_AUDIO,
3097	/* .cMaxInstances = */ 1,
3098	/* .uSharedVersion = */ 42,
3099	/* .cbInstanceShared = */ sizeof(SB16STATE),
3100	/* .cbInstanceCC = */ 0,
3101	/* .cbInstanceRC = */ 0,
3102	/* .cMaxPciDevices = */ 0,
3103	/* .cMaxMsixVectors = */ 0,
3104	/* .pszDescription = */ "Sound Blaster 16 Controller",
3105	#if defined(IN_RING3)
3106	/* .pszRCMod = */ "",
3107	/* .pszR0Mod = */ "",
3108	/* .pfnConstruct = */ sb16Construct,
3109	/* .pfnDestruct = */ sb16Destruct,
3110	/* .pfnRelocate = */ NULL,
3111	/* .pfnMemSetup = */ NULL,
3112	/* .pfnPowerOn = */ NULL,
3113	/* .pfnReset = */ sb16DevReset,
3114	/* .pfnSuspend = */ NULL,
3115	/* .pfnResume = */ NULL,
3116	/* .pfnAttach = */ sb16Attach,
3117	/* .pfnDetach = */ sb16Detach,
3118	/* .pfnQueryInterface = */ NULL,
3119	/* .pfnInitComplete = */ NULL,
3120	/* .pfnPowerOff = */ sb16PowerOff,
3121	/* .pfnSoftReset = */ NULL,
3122	/* .pfnReserved0 = */ NULL,
3123	/* .pfnReserved1 = */ NULL,
3124	/* .pfnReserved2 = */ NULL,
3125	/* .pfnReserved3 = */ NULL,
3126	/* .pfnReserved4 = */ NULL,
3127	/* .pfnReserved5 = */ NULL,
3128	/* .pfnReserved6 = */ NULL,
3129	/* .pfnReserved7 = */ NULL,
3130	#elif defined(IN_RING0)
3131	/* .pfnEarlyConstruct = */ NULL,
3132	/* .pfnConstruct = */ NULL,
3133	/* .pfnDestruct = */ NULL,
3134	/* .pfnFinalDestruct = */ NULL,
3135	/* .pfnRequest = */ NULL,
3136	/* .pfnReserved0 = */ NULL,
3137	/* .pfnReserved1 = */ NULL,
3138	/* .pfnReserved2 = */ NULL,
3139	/* .pfnReserved3 = */ NULL,
3140	/* .pfnReserved4 = */ NULL,
3141	/* .pfnReserved5 = */ NULL,
3142	/* .pfnReserved6 = */ NULL,
3143	/* .pfnReserved7 = */ NULL,
3144	#elif defined(IN_RC)
3145	/* .pfnConstruct = */ NULL,
3146	/* .pfnReserved0 = */ NULL,
3147	/* .pfnReserved1 = */ NULL,
3148	/* .pfnReserved2 = */ NULL,
3149	/* .pfnReserved3 = */ NULL,
3150	/* .pfnReserved4 = */ NULL,
3151	/* .pfnReserved5 = */ NULL,
3152	/* .pfnReserved6 = */ NULL,
3153	/* .pfnReserved7 = */ NULL,
3154	#else
3155	# error "Not in IN_RING3, IN_RING0 or IN_RC!"
3156	#endif
3157	/* .u32VersionEnd = */ PDM_DEVREG_VERSION
3158	};
3159

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Audio/DevSB16.cpp@ 100444

Download in other formats: