DevSB16.cpp@ 61497

Last change on this file since 61497 was 61413, checked in by vboxsync, 9 years ago
Audio: Use the old audio code for now when doing a release. Set VBOX_WITH_AUDIO_STABLE to an empty value to enable the new audio code (default for non-release builds for now).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.6 KB

Line
1	/* $Id: DevSB16.cpp 61413 2016-06-02 13:24:16Z vboxsync $ */
2	/** @file
3	* DevSB16 - VBox SB16 Audio Controller.
4	*
5	* @todo hiccups on NT4 and Win98.
6	*/
7
8	/*
9	* Copyright (C) 2015-2016 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	* --------------------------------------------------------------------
19	*
20	* This code is based on: sb16.c from QEMU AUDIO subsystem (r3917).
21	* QEMU Soundblaster 16 emulation
22	*
23	* Copyright (c) 2003-2005 Vassili Karpov (malc)
24	*
25	* Permission is hereby granted, free of charge, to any person obtaining a copy
26	* of this software and associated documentation files (the "Software"), to deal
27	* in the Software without restriction, including without limitation the rights
28	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
29	* copies of the Software, and to permit persons to whom the Software is
30	* furnished to do so, subject to the following conditions:
31	*
32	* The above copyright notice and this permission notice shall be included in
33	* all copies or substantial portions of the Software.
34	*
35	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
36	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
37	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
38	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
39	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
40	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
41	* THE SOFTWARE.
42	*/
43	#define LOG_GROUP LOG_GROUP_DEV_SB16
44	#include <VBox/log.h>
45	#include <iprt/assert.h>
46	#ifdef IN_RING3
47	# include <iprt/mem.h>
48	# include <iprt/string.h>
49	# include <iprt/uuid.h>
50	#endif
51
52	#include <VBox/vmm/pdmdev.h>
53	#include <VBox/vmm/pdmaudioifs.h>
54
55	#include "VBoxDD.h"
56
57	#include "AudioMixBuffer.h"
58	#include "AudioMixer.h"
59	#include "DrvAudio.h"
60
61	/** Current saved state version. */
62	#define SB16_SAVE_STATE_VERSION 2
63	/** The version used in VirtualBox version 3.0 and earlier. This didn't include the config dump. */
64	#define SB16_SAVE_STATE_VERSION_VBOX_30 1
65
66	#define IO_READ_PROTO(name) \
67	DECLCALLBACK(int) name (PPDMDEVINS pDevIns, void *opaque, \
68	RTIOPORT nport, uint32_t *pu32, unsigned cb)
69
70	#define IO_WRITE_PROTO(name) \
71	DECLCALLBACK(int) name (PPDMDEVINS pDevIns, void *opaque, \
72	RTIOPORT nport, uint32_t val, unsigned cb)
73
74	static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
75
76	typedef struct SB16OUTPUTSTREAM
77	{
78	/** PCM output stream. */
79	R3PTRTYPE(PPDMAUDIOGSTSTRMOUT) pStrmOut;
80	/** Mixer handle for output stream. */
81	R3PTRTYPE(PAUDMIXSTREAM) phStrmOut;
82	} SB16OUTPUTSTREAM, *PSB16OUTPUTSTREAM;
83
84	/**
85	* Struct for maintaining a host backend driver.
86	*/
87	typedef struct SB16STATE *PSB16STATE;
88	typedef struct SB16DRIVER
89	{
90	/** Node for storing this driver in our device driver list of SB16STATE. */
91	RTLISTNODER3 Node;
92	/** Pointer to SB16 controller (state). */
93	R3PTRTYPE(PSB16STATE) pSB16State;
94	/** Driver flags. */
95	PDMAUDIODRVFLAGS Flags;
96	uint32_t PaddingFlags;
97	/** LUN # to which this driver has been assigned. */
98	uint8_t uLUN;
99	/** Whether this driver is in an attached state or not. */
100	bool fAttached;
101	uint8_t Padding[4];
102	/** Pointer to attached driver base interface. */
103	R3PTRTYPE(PPDMIBASE) pDrvBase;
104	/** Audio connector interface to the underlying host backend. */
105	R3PTRTYPE(PPDMIAUDIOCONNECTOR) pConnector;
106	/** Stream for output. */
107	SB16OUTPUTSTREAM Out;
108	} SB16DRIVER, *PSB16DRIVER;
109
110	typedef struct SB16STATE
111	{
112	#ifdef VBOX
113	/** Pointer to the device instance. */
114	PPDMDEVINSR3 pDevInsR3;
115	/** Pointer to the connector of the attached audio driver. */
116	PPDMIAUDIOCONNECTOR pDrv;
117	int irqCfg;
118	int dmaCfg;
119	int hdmaCfg;
120	int portCfg;
121	int verCfg;
122	#endif
123	int irq;
124	int dma;
125	int hdma;
126	int port;
127	int ver;
128
129	int in_index;
130	int out_data_len;
131	int fmt_stereo;
132	int fmt_signed;
133	int fmt_bits;
134	PDMAUDIOFMT fmt;
135	int dma_auto;
136	int block_size;
137	int fifo;
138	int freq;
139	int time_const;
140	int speaker;
141	int needed_bytes;
142	int cmd;
143	int use_hdma;
144	int highspeed;
145	int can_write; /** @todo Value never gets 0? */
146
147	int v2x6;
148
149	uint8_t csp_param;
150	uint8_t csp_value;
151	uint8_t csp_mode;
152	uint8_t csp_regs[256];
153	uint8_t csp_index;
154	uint8_t csp_reg83[4];
155	int csp_reg83r;
156	int csp_reg83w;
157
158	uint8_t in2_data[10];
159	uint8_t out_data[50];
160	uint8_t test_reg;
161	uint8_t last_read_byte;
162	int nzero;
163
164	int left_till_irq; /** Note: Can be < 0. */
165
166	int dma_running;
167	int bytes_per_second;
168	int align;
169
170	RTLISTANCHOR lstDrv;
171	/** The device' software mixer. */
172	R3PTRTYPE(PAUDIOMIXER) pMixer;
173	/** Audio sink for PCM output. */
174	R3PTRTYPE(PAUDMIXSINK) pSinkOutput;
175	#ifndef VBOX_WITH_AUDIO_CALLBACKS
176	/** The timer for pumping data thru the attached LUN drivers. */
177	PTMTIMERR3 pTimerIO;
178	/** The timer interval for pumping data thru the LUN drivers in timer ticks. */
179	uint64_t cTimerTicksIO;
180	/** Timestamp of the last timer callback (sb16TimerIO).
181	* Used to calculate the time actually elapsed between two timer callbacks. */
182	uint64_t uTimerTSIO;
183	#endif
184	PTMTIMER pTimerIRQ;
185	/** The base interface for LUN\#0. */
186	PDMIBASE IBase;
187
188	/* mixer state */
189	int mixer_nreg;
190	uint8_t mixer_regs[256];
191	} SB16STATE, *PSB16STATE;
192
193	static int sb16OpenOut(PSB16STATE pThis, PPDMAUDIOSTREAMCFG pCfg);
194
195	/**
196	* Attach command, internal version.
197	*
198	* This is called to let the device attach to a driver for a specified LUN
199	* during runtime. This is not called during VM construction, the device
200	* constructor has to attach to all the available drivers.
201	*
202	* @returns VBox status code.
203	* @param pDevIns The device instance.
204	* @param pDrv Driver to (re-)use for (re-)attaching to.
205	* If NULL is specified, a new driver will be created and appended
206	* to the driver list.
207	* @param uLUN The logical unit which is being detached.
208	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
209	*/
210	static DECLCALLBACK(int) sb16AttachInternal(PPDMDEVINS pDevIns, PSB16DRIVER pDrv, unsigned uLUN, uint32_t fFlags)
211	{
212	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
213
214	/*
215	* Attach driver.
216	*/
217	char *pszDesc = NULL;
218	if (RTStrAPrintf(&pszDesc, "Audio driver port (SB16) for LUN #%u", uLUN) <= 0)
219	AssertReleaseMsgReturn(pszDesc,
220	("Not enough memory for SB16 driver port description of LUN #%u\n", uLUN),
221	VERR_NO_MEMORY);
222
223	PPDMIBASE pDrvBase;
224	int rc = PDMDevHlpDriverAttach(pDevIns, uLUN,
225	&pThis->IBase, &pDrvBase, pszDesc);
226	if (RT_SUCCESS(rc))
227	{
228	if (pDrv == NULL)
229	pDrv = (PSB16DRIVER)RTMemAllocZ(sizeof(SB16DRIVER));
230	if (pDrv)
231	{
232	pDrv->pDrvBase = pDrvBase;
233	pDrv->pConnector = PDMIBASE_QUERY_INTERFACE(pDrvBase, PDMIAUDIOCONNECTOR);
234	AssertMsg(pDrv->pConnector != NULL, ("Configuration error: LUN #%u has no host audio interface, rc=%Rrc\n", uLUN, rc));
235	pDrv->pSB16State = pThis;
236	pDrv->uLUN = uLUN;
237
238	/*
239	* For now we always set the driver at LUN 0 as our primary
240	* host backend. This might change in the future.
241	*/
242	if (pDrv->uLUN == 0)
243	pDrv->Flags \|= PDMAUDIODRVFLAG_PRIMARY;
244
245	LogFunc(("LUN#%RU8: pCon=%p, drvFlags=0x%x\n", uLUN, pDrv->pConnector, pDrv->Flags));
246
247	/* Attach to driver list if not attached yet. */
248	if (!pDrv->fAttached)
249	{
250	RTListAppend(&pThis->lstDrv, &pDrv->Node);
251	pDrv->fAttached = true;
252	}
253	}
254	else
255	rc = VERR_NO_MEMORY;
256	}
257	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
258	{
259	LogFunc(("No attached driver for LUN #%u\n", uLUN));
260	}
261	else if (RT_FAILURE(rc))
262	AssertMsgFailed(("Failed to attach SB16 LUN #%u (\"%s\"), rc=%Rrc\n",
263	uLUN, pszDesc, rc));
264
265	if (RT_FAILURE(rc))
266	{
267	/* Only free this string on failure;
268	* must remain valid for the live of the driver instance. */
269	RTStrFree(pszDesc);
270	}
271
272	LogFunc(("iLUN=%u, fFlags=0x%x, rc=%Rrc\n", uLUN, fFlags, rc));
273	return rc;
274	}
275
276	/**
277	* Attach command.
278	*
279	* This is called to let the device attach to a driver for a specified LUN
280	* during runtime. This is not called during VM construction, the device
281	* constructor has to attach to all the available drivers.
282	*
283	* @returns VBox status code.
284	* @param pDevIns The device instance.
285	* @param uLUN The logical unit which is being detached.
286	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
287	*/
288	static DECLCALLBACK(int) sb16Attach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
289	{
290	return sb16AttachInternal(pDevIns, NULL /* pDrv */, uLUN, fFlags);
291	}
292
293	static DECLCALLBACK(void) sb16Detach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
294	{
295	LogFunc(("iLUN=%u, fFlags=0x%x\n", uLUN, fFlags));
296	}
297
298	/**
299	* Re-attach.
300	*
301	* @returns VBox status code.
302	* @param pThis Device instance.
303	* @param pDrv Driver instance used for attaching to.
304	* If NULL is specified, a new driver will be created and appended
305	* to the driver list.
306	* @param uLUN The logical unit which is being re-detached.
307	* @param pszDriver Driver name.
308	*/
309	static int sb16Reattach(PSB16STATE pThis, PSB16DRIVER pDrv, uint8_t uLUN, const char *pszDriver)
310	{
311	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
312	AssertPtrReturn(pszDriver, VERR_INVALID_POINTER);
313
314	PVM pVM = PDMDevHlpGetVM(pThis->pDevInsR3);
315	PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
316	PCFGMNODE pDev0 = CFGMR3GetChild(pRoot, "Devices/sb16/0/");
317
318	/* Remove LUN branch. */
319	CFGMR3RemoveNode(CFGMR3GetChildF(pDev0, "LUN#%u/", uLUN));
320
321	if (pDrv)
322	{
323	/* Re-use the driver instance so detach it before. */
324	int rc = PDMDevHlpDriverDetach(pThis->pDevInsR3, PDMIBASE_2_PDMDRV(pDrv->pDrvBase), 0 /* fFlags */);
325	if (RT_FAILURE(rc))
326	return rc;
327	}
328
329	#define RC_CHECK() if (RT_FAILURE(rc)) { AssertReleaseRC(rc); break; }
330
331	int rc = VINF_SUCCESS;
332	do
333	{
334	PCFGMNODE pLunL0;
335	rc = CFGMR3InsertNodeF(pDev0, &pLunL0, "LUN#%u/", uLUN); RC_CHECK();
336	rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); RC_CHECK();
337	rc = CFGMR3InsertNode(pLunL0, "Config/", NULL); RC_CHECK();
338
339	PCFGMNODE pLunL1, pLunL2;
340	rc = CFGMR3InsertNode (pLunL0, "AttachedDriver/", &pLunL1); RC_CHECK();
341	rc = CFGMR3InsertNode (pLunL1, "Config/", &pLunL2); RC_CHECK();
342	rc = CFGMR3InsertString(pLunL1, "Driver", pszDriver); RC_CHECK();
343
344	rc = CFGMR3InsertString(pLunL2, "AudioDriver", pszDriver); RC_CHECK();
345
346	} while (0);
347
348	if (RT_SUCCESS(rc))
349	rc = sb16AttachInternal(pThis->pDevInsR3, pDrv, uLUN, 0 /* fFlags */);
350
351	LogFunc(("pThis=%p, uLUN=%u, pszDriver=%s, rc=%Rrc\n", pThis, uLUN, pszDriver, rc));
352
353	#undef RC_CHECK
354
355	return rc;
356	}
357
358	static void sb16AudioCallback(void *pvContext, uint32_t cbFree);
359
360	static int magic_of_irq(int irq)
361	{
362	switch (irq)
363	{
364	case 5:
365	return 2;
366	case 7:
367	return 4;
368	case 9:
369	return 1;
370	case 10:
371	return 8;
372	default:
373	break;
374	}
375
376	LogFlowFunc(("bad irq %d\n", irq));
377	return 2;
378	}
379
380	static int irq_of_magic(int magic)
381	{
382	switch (magic)
383	{
384	case 1:
385	return 9;
386	case 2:
387	return 5;
388	case 4:
389	return 7;
390	case 8:
391	return 10;
392	default:
393	break;
394	}
395
396	LogFlowFunc(("bad irq magic %d\n", magic));
397	return -1;
398	}
399
400	#ifdef DEBUG
401	static inline void log_dsp(PSB16STATE pThis)
402	{
403	LogFlowFunc(("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
404	pThis->fmt_stereo ? "Stereo" : "Mono",
405	pThis->fmt_signed ? "Signed" : "Unsigned",
406	pThis->fmt_bits,
407	pThis->dma_auto ? "Auto" : "Single",
408	pThis->block_size,
409	pThis->freq,
410	pThis->time_const,
411	pThis->speaker));
412	}
413	#endif
414
415	static void sb16SpeakerControl(PSB16STATE pThis, int on)
416	{
417	pThis->speaker = on;
418	/* AUD_enable (pThis->voice, on); */
419	}
420
421	static void sb16Control(PSB16STATE pThis, int hold)
422	{
423	int dma = pThis->use_hdma ? pThis->hdma : pThis->dma;
424	pThis->dma_running = hold;
425
426	LogFlowFunc(("hold %d high %d dma %d\n", hold, pThis->use_hdma, dma));
427
428	PSB16DRIVER pDrv;
429	if (hold)
430	{
431	PDMDevHlpDMASetDREQ (pThis->pDevInsR3, dma, 1);
432	PDMDevHlpDMASchedule (pThis->pDevInsR3);
433	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
434	pDrv->pConnector->pfnEnableOut(pDrv->pConnector,
435	pDrv->Out.pStrmOut, true /* fEnable */);
436	}
437	else
438	{
439	PDMDevHlpDMASetDREQ (pThis->pDevInsR3, dma, 0);
440	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
441	pDrv->pConnector->pfnEnableOut(pDrv->pConnector,
442	pDrv->Out.pStrmOut, false /* fEnable */);
443	}
444	}
445
446	static DECLCALLBACK(void) sb16TimerIRQ(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvThis)
447	{
448	PSB16STATE pThis = (PSB16STATE)pvThis;
449	pThis->can_write = 1;
450	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 1);
451	}
452
453	#define DMA8_AUTO 1
454	#define DMA8_HIGH 2
455
456	static void continue_dma8(PSB16STATE pThis)
457	{
458	if (pThis->freq > 0)
459	{
460	PDMAUDIOSTREAMCFG streamCfg;
461	streamCfg.uHz = pThis->freq;
462	streamCfg.cChannels = 1 << pThis->fmt_stereo;
463	streamCfg.enmFormat = pThis->fmt;
464	streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
465
466	int rc = sb16OpenOut(pThis, &streamCfg);
467	AssertRC(rc);
468	}
469
470	sb16Control(pThis, 1);
471	}
472
473	static void dma_cmd8(PSB16STATE pThis, int mask, int dma_len)
474	{
475	pThis->fmt = AUD_FMT_U8;
476	pThis->use_hdma = 0;
477	pThis->fmt_bits = 8;
478	pThis->fmt_signed = 0;
479	pThis->fmt_stereo = (pThis->mixer_regs[0x0e] & 2) != 0;
480
481	if (-1 == pThis->time_const)
482	{
483	if (pThis->freq <= 0)
484	pThis->freq = 11025;
485	}
486	else
487	{
488	int tmp = (256 - pThis->time_const);
489	pThis->freq = (1000000 + (tmp / 2)) / tmp;
490	}
491
492	if (dma_len != -1)
493	{
494	pThis->block_size = dma_len << pThis->fmt_stereo;
495	}
496	else
497	{
498	/* This is apparently the only way to make both Act1/PL
499	and SecondReality/FC work
500
501	r=andy Wow, actually someone who remembers Future Crew :-)
502
503	Act1 sets block size via command 0x48 and it's an odd number
504	SR does the same with even number
505	Both use stereo, and Creatives own documentation states that
506	0x48 sets block size in bytes less one.. go figure */
507	pThis->block_size &= ~pThis->fmt_stereo;
508	}
509
510	pThis->freq >>= pThis->fmt_stereo;
511	pThis->left_till_irq = pThis->block_size;
512	pThis->bytes_per_second = (pThis->freq << pThis->fmt_stereo);
513	/* pThis->highspeed = (mask & DMA8_HIGH) != 0; */
514	pThis->dma_auto = (mask & DMA8_AUTO) != 0;
515	pThis->align = (1 << pThis->fmt_stereo) - 1;
516
517	if (pThis->block_size & pThis->align)
518	LogFlowFunc(("warning: misaligned block size %d, alignment %d\n",
519	pThis->block_size, pThis->align + 1));
520
521	LogFlowFunc(("freq %d, stereo %d, sign %d, bits %d, dma %d, auto %d, fifo %d, high %d\n",
522	pThis->freq, pThis->fmt_stereo, pThis->fmt_signed, pThis->fmt_bits,
523	pThis->block_size, pThis->dma_auto, pThis->fifo, pThis->highspeed));
524
525	continue_dma8(pThis);
526	sb16SpeakerControl(pThis, 1);
527	}
528
529	static void dma_cmd(PSB16STATE pThis, uint8_t cmd, uint8_t d0, int dma_len)
530	{
531	pThis->use_hdma = cmd < 0xc0;
532	pThis->fifo = (cmd >> 1) & 1;
533	pThis->dma_auto = (cmd >> 2) & 1;
534	pThis->fmt_signed = (d0 >> 4) & 1;
535	pThis->fmt_stereo = (d0 >> 5) & 1;
536
537	switch (cmd >> 4)
538	{
539	case 11:
540	pThis->fmt_bits = 16;
541	break;
542
543	case 12:
544	pThis->fmt_bits = 8;
545	break;
546	}
547
548	if (-1 != pThis->time_const)
549	{
550	#if 1
551	int tmp = 256 - pThis->time_const;
552	pThis->freq = (1000000 + (tmp / 2)) / tmp;
553	#else
554	/* pThis->freq = 1000000 / ((255 - pThis->time_const) << pThis->fmt_stereo); */
555	pThis->freq = 1000000 / ((255 - pThis->time_const));
556	#endif
557	pThis->time_const = -1;
558	}
559
560	pThis->block_size = dma_len + 1;
561	pThis->block_size <<= ((pThis->fmt_bits == 16) ? 1 : 0);
562	if (!pThis->dma_auto)
563	{
564	/*
565	* It is clear that for DOOM and auto-init this value
566	* shouldn't take stereo into account, while Miles Sound Systems
567	* setsound.exe with single transfer mode wouldn't work without it
568	* wonders of SB16 yet again.
569	*/
570	pThis->block_size <<= pThis->fmt_stereo;
571	}
572
573	LogFlowFunc(("freq %d, stereo %d, sign %d, bits %d, dma %d, auto %d, fifo %d, high %d\n",
574	pThis->freq, pThis->fmt_stereo, pThis->fmt_signed, pThis->fmt_bits,
575	pThis->block_size, pThis->dma_auto, pThis->fifo, pThis->highspeed));
576
577	if (16 == pThis->fmt_bits)
578	pThis->fmt = pThis->fmt_signed ? AUD_FMT_S16 : AUD_FMT_U16;
579	else
580	pThis->fmt = pThis->fmt_signed ? AUD_FMT_S8 : AUD_FMT_U8;
581
582	pThis->left_till_irq = pThis->block_size;
583
584	pThis->bytes_per_second = (pThis->freq << pThis->fmt_stereo) << ((pThis->fmt_bits == 16) ? 1 : 0);
585	pThis->highspeed = 0;
586	pThis->align = (1 << (pThis->fmt_stereo + (pThis->fmt_bits == 16))) - 1;
587	if (pThis->block_size & pThis->align)
588	{
589	LogFlowFunc(("warning: misaligned block size %d, alignment %d\n",
590	pThis->block_size, pThis->align + 1));
591	}
592
593	if (pThis->freq)
594	{
595	PDMAUDIOSTREAMCFG streamCfg;
596	streamCfg.uHz = pThis->freq;
597	streamCfg.cChannels = 1 << pThis->fmt_stereo;
598	streamCfg.enmFormat = pThis->fmt;
599	streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
600
601	int rc = sb16OpenOut(pThis, &streamCfg);
602	AssertRC(rc);
603	}
604
605	sb16Control(pThis, 1);
606	sb16SpeakerControl(pThis, 1);
607	}
608
609	static inline void dsp_out_data (PSB16STATE pThis, uint8_t val)
610	{
611	LogFlowFunc(("outdata %#x\n", val));
612	if ((size_t) pThis->out_data_len < sizeof (pThis->out_data)) {
613	pThis->out_data[pThis->out_data_len++] = val;
614	}
615	}
616
617	static inline uint8_t dsp_get_data (PSB16STATE pThis)
618	{
619	if (pThis->in_index) {
620	return pThis->in2_data[--pThis->in_index];
621	}
622	else {
623	LogFlowFunc(("buffer underflow\n"));
624	return 0;
625	}
626	}
627
628	static void sb16HandleCommand(PSB16STATE pThis, uint8_t cmd)
629	{
630	LogFlowFunc(("command %#x\n", cmd));
631
632	if (cmd > 0xaf && cmd < 0xd0)
633	{
634	if (cmd & 8) /** @todo Handle recording. */
635	LogFlowFunc(("ADC not yet supported (command %#x)\n", cmd));
636
637	switch (cmd >> 4)
638	{
639	case 11:
640	case 12:
641	break;
642	default:
643	LogFlowFunc(("%#x wrong bits\n", cmd));
644	}
645
646	pThis->needed_bytes = 3;
647	}
648	else
649	{
650	pThis->needed_bytes = 0;
651
652	switch (cmd)
653	{
654	case 0x03:
655	dsp_out_data(pThis, 0x10); /* pThis->csp_param); */
656	goto warn;
657
658	case 0x04:
659	pThis->needed_bytes = 1;
660	goto warn;
661
662	case 0x05:
663	pThis->needed_bytes = 2;
664	goto warn;
665
666	case 0x08:
667	/* __asm__ ("int3"); */
668	goto warn;
669
670	case 0x0e:
671	pThis->needed_bytes = 2;
672	goto warn;
673
674	case 0x09:
675	dsp_out_data(pThis, 0xf8);
676	goto warn;
677
678	case 0x0f:
679	pThis->needed_bytes = 1;
680	goto warn;
681
682	case 0x10:
683	pThis->needed_bytes = 1;
684	goto warn;
685
686	case 0x14:
687	pThis->needed_bytes = 2;
688	pThis->block_size = 0;
689	break;
690
691	case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
692	dma_cmd8(pThis, DMA8_AUTO, -1);
693	break;
694
695	case 0x20: /* Direct ADC, Juice/PL */
696	dsp_out_data(pThis, 0xff);
697	goto warn;
698
699	case 0x35:
700	LogFlowFunc(("0x35 - MIDI command not implemented\n"));
701	break;
702
703	case 0x40:
704	pThis->freq = -1;
705	pThis->time_const = -1;
706	pThis->needed_bytes = 1;
707	break;
708
709	case 0x41:
710	pThis->freq = -1;
711	pThis->time_const = -1;
712	pThis->needed_bytes = 2;
713	break;
714
715	case 0x42:
716	pThis->freq = -1;
717	pThis->time_const = -1;
718	pThis->needed_bytes = 2;
719	goto warn;
720
721	case 0x45:
722	dsp_out_data(pThis, 0xaa);
723	goto warn;
724
725	case 0x47: /* Continue Auto-Initialize DMA 16bit */
726	break;
727
728	case 0x48:
729	pThis->needed_bytes = 2;
730	break;
731
732	case 0x74:
733	pThis->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */
734	LogFlowFunc(("0x75 - DMA DAC, 4-bit ADPCM not implemented\n"));
735	break;
736
737	case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
738	pThis->needed_bytes = 2;
739	LogFlowFunc(("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n"));
740	break;
741
742	case 0x76: /* DMA DAC, 2.6-bit ADPCM */
743	pThis->needed_bytes = 2;
744	LogFlowFunc(("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n"));
745	break;
746
747	case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
748	pThis->needed_bytes = 2;
749	LogFlowFunc(("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n"));
750	break;
751
752	case 0x7d:
753	LogFlowFunc(("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n"));
754	LogFlowFunc(("not implemented\n"));
755	break;
756
757	case 0x7f:
758	LogFlowFunc(("0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"));
759	LogFlowFunc(("not implemented\n"));
760	break;
761
762	case 0x80:
763	pThis->needed_bytes = 2;
764	break;
765
766	case 0x90:
767	case 0x91:
768	dma_cmd8(pThis, (((cmd & 1) == 0) ? 1 : 0) \| DMA8_HIGH, -1);
769	break;
770
771	case 0xd0: /* halt DMA operation. 8bit */
772	sb16Control(pThis, 0);
773	break;
774
775	case 0xd1: /* speaker on */
776	sb16SpeakerControl(pThis, 1);
777	break;
778
779	case 0xd3: /* speaker off */
780	sb16SpeakerControl(pThis, 0);
781	break;
782
783	case 0xd4: /* continue DMA operation. 8bit */
784	/* KQ6 (or maybe Sierras audblst.drv in general) resets
785	the frequency between halt/continue */
786	continue_dma8(pThis);
787	break;
788
789	case 0xd5: /* halt DMA operation. 16bit */
790	sb16Control(pThis, 0);
791	break;
792
793	case 0xd6: /* continue DMA operation. 16bit */
794	sb16Control(pThis, 1);
795	break;
796
797	case 0xd9: /* exit auto-init DMA after this block. 16bit */
798	pThis->dma_auto = 0;
799	break;
800
801	case 0xda: /* exit auto-init DMA after this block. 8bit */
802	pThis->dma_auto = 0;
803	break;
804
805	case 0xe0: /* DSP identification */
806	pThis->needed_bytes = 1;
807	break;
808
809	case 0xe1:
810	dsp_out_data(pThis, pThis->ver & 0xff);
811	dsp_out_data(pThis, pThis->ver >> 8);
812	break;
813
814	case 0xe2:
815	pThis->needed_bytes = 1;
816	goto warn;
817
818	case 0xe3:
819	{
820	for (int i = sizeof (e3) - 1; i >= 0; --i)
821	dsp_out_data(pThis, e3[i]);
822
823	break;
824	}
825
826	case 0xe4: /* write test reg */
827	pThis->needed_bytes = 1;
828	break;
829
830	case 0xe7:
831	LogFlowFunc(("Attempt to probe for ESS (0xe7)?\n"));
832	break;
833
834	case 0xe8: /* read test reg */
835	dsp_out_data(pThis, pThis->test_reg);
836	break;
837
838	case 0xf2:
839	case 0xf3:
840	dsp_out_data(pThis, 0xaa);
841	pThis->mixer_regs[0x82] \|= (cmd == 0xf2) ? 1 : 2;
842	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 1);
843	break;
844
845	case 0xf8:
846	/* Undocumented, used by old Creative diagnostic programs. */
847	dsp_out_data (pThis, 0);
848	goto warn;
849
850	case 0xf9:
851	pThis->needed_bytes = 1;
852	goto warn;
853
854	case 0xfa:
855	dsp_out_data (pThis, 0);
856	goto warn;
857
858	case 0xfc: /* FIXME */
859	dsp_out_data (pThis, 0);
860	goto warn;
861
862	default:
863	LogFlowFunc(("Unrecognized command %#x\n", cmd));
864	break;
865	}
866	}
867
868	if (!pThis->needed_bytes)
869	LogFlow(("\n"));
870
871	exit:
872
873	if (!pThis->needed_bytes)
874	pThis->cmd = -1;
875	else
876	pThis->cmd = cmd;
877
878	return;
879
880	warn:
881	LogFlowFunc(("warning: command %#x,%d is not truly understood yet\n",
882	cmd, pThis->needed_bytes));
883	goto exit;
884	}
885
886	static uint16_t dsp_get_lohi (PSB16STATE pThis)
887	{
888	uint8_t hi = dsp_get_data (pThis);
889	uint8_t lo = dsp_get_data (pThis);
890	return (hi << 8) \| lo;
891	}
892
893	static uint16_t dsp_get_hilo (PSB16STATE pThis)
894	{
895	uint8_t lo = dsp_get_data (pThis);
896	uint8_t hi = dsp_get_data (pThis);
897	return (hi << 8) \| lo;
898	}
899
900	static void complete(PSB16STATE pThis)
901	{
902	int d0, d1, d2;
903	LogFlowFunc(("complete command %#x, in_index %d, needed_bytes %d\n",
904	pThis->cmd, pThis->in_index, pThis->needed_bytes));
905
906	if (pThis->cmd > 0xaf && pThis->cmd < 0xd0)
907	{
908	d2 = dsp_get_data (pThis);
909	d1 = dsp_get_data (pThis);
910	d0 = dsp_get_data (pThis);
911
912	if (pThis->cmd & 8)
913	LogFlowFunc(("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", pThis->cmd, d0, d1, d2));
914	else
915	{
916	LogFlowFunc(("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", pThis->cmd, d0, d1, d2));
917	dma_cmd(pThis, pThis->cmd, d0, d1 + (d2 << 8));
918	}
919	}
920	else
921	{
922	switch (pThis->cmd)
923	{
924	case 0x04:
925	pThis->csp_mode = dsp_get_data (pThis);
926	pThis->csp_reg83r = 0;
927	pThis->csp_reg83w = 0;
928	LogFlowFunc(("CSP command 0x04: mode=%#x\n", pThis->csp_mode));
929	break;
930
931	case 0x05:
932	pThis->csp_param = dsp_get_data (pThis);
933	pThis->csp_value = dsp_get_data (pThis);
934	LogFlowFunc(("CSP command 0x05: param=%#x value=%#x\n",
935	pThis->csp_param,
936	pThis->csp_value));
937	break;
938
939	case 0x0e:
940	{
941	d0 = dsp_get_data(pThis);
942	d1 = dsp_get_data(pThis);
943	LogFlowFunc(("write CSP register %d <- %#x\n", d1, d0));
944	if (d1 == 0x83)
945	{
946	LogFlowFunc(("0x83[%d] <- %#x\n", pThis->csp_reg83r, d0));
947	pThis->csp_reg83[pThis->csp_reg83r % 4] = d0;
948	pThis->csp_reg83r += 1;
949	}
950	else
951	pThis->csp_regs[d1] = d0;
952	break;
953	}
954
955	case 0x0f:
956	d0 = dsp_get_data(pThis);
957	LogFlowFunc(("read CSP register %#x -> %#x, mode=%#x\n", d0, pThis->csp_regs[d0], pThis->csp_mode));
958	if (d0 == 0x83)
959	{
960	LogFlowFunc(("0x83[%d] -> %#x\n",
961	pThis->csp_reg83w,
962	pThis->csp_reg83[pThis->csp_reg83w % 4]));
963	dsp_out_data (pThis, pThis->csp_reg83[pThis->csp_reg83w % 4]);
964	pThis->csp_reg83w += 1;
965	}
966	else
967	dsp_out_data(pThis, pThis->csp_regs[d0]);
968	break;
969
970	case 0x10:
971	d0 = dsp_get_data(pThis);
972	LogFlowFunc(("cmd 0x10 d0=%#x\n", d0));
973	break;
974
975	case 0x14:
976	dma_cmd8(pThis, 0, dsp_get_lohi (pThis) + 1);
977	break;
978
979	case 0x40:
980	pThis->time_const = dsp_get_data(pThis);
981	LogFlowFunc(("set time const %d\n", pThis->time_const));
982	break;
983
984	case 0x42: /* FT2 sets output freq with this, go figure */
985	#if 0
986	LogFlowFunc(("cmd 0x42 might not do what it think it should\n"));
987	#endif
988	case 0x41:
989	pThis->freq = dsp_get_hilo(pThis);
990	LogFlowFunc(("set freq %d\n", pThis->freq));
991	break;
992
993	case 0x48:
994	pThis->block_size = dsp_get_lohi(pThis) + 1;
995	LogFlowFunc(("set dma block len %d\n", pThis->block_size));
996	break;
997
998	case 0x74:
999	case 0x75:
1000	case 0x76:
1001	case 0x77:
1002	/* ADPCM stuff, ignore */
1003	break;
1004
1005	case 0x80:
1006	{
1007	int freq, samples, bytes;
1008	uint64_t ticks;
1009
1010	freq = pThis->freq > 0 ? pThis->freq : 11025;
1011	samples = dsp_get_lohi (pThis) + 1;
1012	bytes = samples << pThis->fmt_stereo << ((pThis->fmt_bits == 16) ? 1 : 0);
1013	ticks = (bytes * TMTimerGetFreq(pThis->pTimerIRQ)) / freq;
1014	if (ticks < TMTimerGetFreq(pThis->pTimerIRQ) / 1024)
1015	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 1);
1016	else
1017	TMTimerSet(pThis->pTimerIRQ, TMTimerGet(pThis->pTimerIRQ) + ticks);
1018	LogFlowFunc(("mix silence: %d samples, %d bytes, %RU64 ticks\n", samples, bytes, ticks));
1019	break;
1020	}
1021
1022	case 0xe0:
1023	d0 = dsp_get_data(pThis);
1024	pThis->out_data_len = 0;
1025	LogFlowFunc(("E0 data = %#x\n", d0));
1026	dsp_out_data(pThis, ~d0);
1027	break;
1028
1029	case 0xe2:
1030	d0 = dsp_get_data(pThis);
1031	LogFlow(("SB16:E2 = %#x\n", d0));
1032	break;
1033
1034	case 0xe4:
1035	pThis->test_reg = dsp_get_data(pThis);
1036	break;
1037
1038	case 0xf9:
1039	d0 = dsp_get_data(pThis);
1040	LogFlowFunc(("command 0xf9 with %#x\n", d0));
1041	switch (d0) {
1042	case 0x0e:
1043	dsp_out_data(pThis, 0xff);
1044	break;
1045
1046	case 0x0f:
1047	dsp_out_data(pThis, 0x07);
1048	break;
1049
1050	case 0x37:
1051	dsp_out_data(pThis, 0x38);
1052	break;
1053
1054	default:
1055	dsp_out_data(pThis, 0x00);
1056	break;
1057	}
1058	break;
1059
1060	default:
1061	LogFlowFunc(("complete: unrecognized command %#x\n", pThis->cmd));
1062	return;
1063	}
1064	}
1065
1066	LogFlow(("\n"));
1067	pThis->cmd = -1;
1068	return;
1069	}
1070
1071	static uint8_t sb16MixRegToVol(PSB16STATE pThis, int reg)
1072	{
1073	/* The SB16 mixer has a 0 to -62dB range in 32 levels (2dB each step).
1074	* We use a 0 to -96dB range in 256 levels (0.375dB each step).
1075	* Only the top 5 bits of a mixer register are used.
1076	*/
1077	uint8_t steps = 31 - (pThis->mixer_regs[reg] >> 3);
1078	uint8_t vol = 255 - steps * 16 / 3; /* (2dB8) / (0.375dB8) */
1079	return vol;
1080	}
1081
1082	static void sb16SetMasterVolume(PSB16STATE pThis)
1083	{
1084	/* There's no mute switch, only volume controls. */
1085	uint8_t lvol = sb16MixRegToVol(pThis, 0x30);
1086	uint8_t rvol = sb16MixRegToVol(pThis, 0x31);
1087	PDMAUDIOVOLUME vol = { false, lvol, rvol };
1088	AudioMixerSetMasterVolume(pThis->pMixer, &vol);
1089	}
1090
1091	static void sb16SetPcmOutVolume(PSB16STATE pThis)
1092	{
1093	/* There's no mute switch, only volume controls. */
1094	uint8_t lvol = sb16MixRegToVol(pThis, 0x32);
1095	uint8_t rvol = sb16MixRegToVol(pThis, 0x33);
1096	PDMAUDIOVOLUME vol = { false, lvol, rvol };
1097	AudioMixerSetSinkVolume(pThis->pSinkOutput, &vol);
1098	}
1099
1100	static void sb16ResetLegacy(PSB16STATE pThis)
1101	{
1102	pThis->freq = 11025;
1103	pThis->fmt_signed = 0;
1104	pThis->fmt_bits = 8;
1105	pThis->fmt_stereo = 0;
1106
1107	PDMAUDIOSTREAMCFG streamCfg;
1108	streamCfg.uHz = pThis->freq;
1109	streamCfg.cChannels = 1; /* Mono */
1110	streamCfg.enmFormat = AUD_FMT_U8;
1111	streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
1112
1113	int rc2 = sb16OpenOut(pThis, &streamCfg);
1114	AssertRC(rc2);
1115	}
1116
1117	static void sb16Reset(PSB16STATE pThis)
1118	{
1119	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
1120	if (pThis->dma_auto)
1121	{
1122	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 1);
1123	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
1124	}
1125
1126	pThis->mixer_regs[0x82] = 0;
1127	pThis->dma_auto = 0;
1128	pThis->in_index = 0;
1129	pThis->out_data_len = 0;
1130	pThis->left_till_irq = 0;
1131	pThis->needed_bytes = 0;
1132	pThis->block_size = -1;
1133	pThis->nzero = 0;
1134	pThis->highspeed = 0;
1135	pThis->v2x6 = 0;
1136	pThis->cmd = -1;
1137
1138	dsp_out_data(pThis, 0xaa);
1139	sb16SpeakerControl(pThis, 0);
1140	sb16Control(pThis, 0);
1141	sb16ResetLegacy(pThis);
1142	}
1143
1144	static IO_WRITE_PROTO(dsp_write)
1145	{
1146	PSB16STATE pThis = (PSB16STATE)opaque;
1147	int iport = nport - pThis->port;
1148
1149	LogFlowFunc(("write %#x <- %#x\n", nport, val));
1150	switch (iport)
1151	{
1152	case 0x06:
1153	switch (val)
1154	{
1155	case 0x00:
1156	{
1157	if (pThis->v2x6 == 1)
1158	{
1159	if (0 && pThis->highspeed)
1160	{
1161	pThis->highspeed = 0;
1162	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
1163	sb16Control(pThis, 0);
1164	}
1165	else
1166	sb16Reset(pThis);
1167	}
1168	pThis->v2x6 = 0;
1169	break;
1170	}
1171
1172	case 0x01:
1173	case 0x03: /* FreeBSD kludge */
1174	pThis->v2x6 = 1;
1175	break;
1176
1177	case 0xc6:
1178	pThis->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */
1179	break;
1180
1181	case 0xb8: /* Panic */
1182	sb16Reset(pThis);
1183	break;
1184
1185	case 0x39:
1186	dsp_out_data(pThis, 0x38);
1187	sb16Reset(pThis);
1188	pThis->v2x6 = 0x39;
1189	break;
1190
1191	default:
1192	pThis->v2x6 = val;
1193	break;
1194	}
1195	break;
1196
1197	case 0x0c: /* Write data or command \| write status */
1198	#if 0
1199	if (pThis->highspeed)
1200	break;
1201	#endif
1202	if (0 == pThis->needed_bytes)
1203	{
1204	sb16HandleCommand(pThis, val);
1205	#if 0
1206	if (0 == pThis->needed_bytes) {
1207	log_dsp (pThis);
1208	}
1209	#endif
1210	}
1211	else
1212	{
1213	if (pThis->in_index == sizeof (pThis->in2_data))
1214	{
1215	LogFlowFunc(("in data overrun\n"));
1216	}
1217	else
1218	{
1219	pThis->in2_data[pThis->in_index++] = val;
1220	if (pThis->in_index == pThis->needed_bytes)
1221	{
1222	pThis->needed_bytes = 0;
1223	complete (pThis);
1224	#if 0
1225	log_dsp (pThis);
1226	#endif
1227	}
1228	}
1229	}
1230	break;
1231
1232	default:
1233	LogFlowFunc(("nport=%#x, val=%#x)\n", nport, val));
1234	break;
1235	}
1236
1237	return VINF_SUCCESS;
1238	}
1239
1240	static IO_READ_PROTO(dsp_read)
1241	{
1242	PSB16STATE pThis = (PSB16STATE)opaque;
1243	int iport, retval, ack = 0;
1244
1245	iport = nport - pThis->port;
1246
1247	/** @todo reject non-byte access?
1248	* The spec does not mention a non-byte access so we should check how real hardware behaves. */
1249
1250	switch (iport)
1251	{
1252	case 0x06: /* reset */
1253	retval = 0xff;
1254	break;
1255
1256	case 0x0a: /* read data */
1257	if (pThis->out_data_len)
1258	{
1259	retval = pThis->out_data[--pThis->out_data_len];
1260	pThis->last_read_byte = retval;
1261	}
1262	else
1263	{
1264	if (pThis->cmd != -1)
1265	LogFlowFunc(("empty output buffer for command %#x\n", pThis->cmd));
1266	retval = pThis->last_read_byte;
1267	/* goto error; */
1268	}
1269	break;
1270
1271	case 0x0c: /* 0 can write */
1272	retval = pThis->can_write ? 0 : 0x80;
1273	break;
1274
1275	case 0x0d: /* timer interrupt clear */
1276	/* LogFlowFunc(("timer interrupt clear\n")); */
1277	retval = 0;
1278	break;
1279
1280	case 0x0e: /* data available status \| irq 8 ack */
1281	retval = (!pThis->out_data_len \|\| pThis->highspeed) ? 0 : 0x80;
1282	if (pThis->mixer_regs[0x82] & 1)
1283	{
1284	ack = 1;
1285	pThis->mixer_regs[0x82] &= ~1;
1286	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
1287	}
1288	break;
1289
1290	case 0x0f: /* irq 16 ack */
1291	retval = 0xff;
1292	if (pThis->mixer_regs[0x82] & 2)
1293	{
1294	ack = 1;
1295	pThis->mixer_regs[0x82] &= ~2;
1296	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
1297	}
1298	break;
1299
1300	default:
1301	goto error;
1302	}
1303
1304	if (!ack)
1305	LogFlowFunc(("read %#x -> %#x\n", nport, retval));
1306
1307	*pu32 = retval;
1308	return VINF_SUCCESS;
1309
1310	error:
1311	LogFlowFunc(("warning: dsp_read %#x error\n", nport));
1312	return VERR_IOM_IOPORT_UNUSED;
1313	}
1314
1315	static void sb16MixerReset(PSB16STATE pThis)
1316	{
1317	PSB16DRIVER pDrv;
1318
1319	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1320	pDrv->Out.phStrmOut = NULL;
1321
1322	pThis->pSinkOutput = NULL;
1323
1324	if (pThis->pMixer)
1325	{
1326	AudioMixerDestroy(pThis->pMixer);
1327	pThis->pMixer = NULL;
1328	}
1329
1330	memset(pThis->mixer_regs, 0xff, 0x7f);
1331	memset(pThis->mixer_regs + 0x83, 0xff, sizeof (pThis->mixer_regs) - 0x83);
1332
1333	pThis->mixer_regs[0x02] = 4; /* master volume 3bits */
1334	pThis->mixer_regs[0x06] = 4; /* MIDI volume 3bits */
1335	pThis->mixer_regs[0x08] = 0; /* CD volume 3bits */
1336	pThis->mixer_regs[0x0a] = 0; /* voice volume 2bits */
1337
1338	/* d5=input filt, d3=lowpass filt, d1,d2=input source */
1339	pThis->mixer_regs[0x0c] = 0;
1340
1341	/* d5=output filt, d1=stereo switch */
1342	pThis->mixer_regs[0x0e] = 0;
1343
1344	/* voice volume L d5,d7, R d1,d3 */
1345	pThis->mixer_regs[0x04] = (12 << 4) \| 12;
1346	/* master ... */
1347	pThis->mixer_regs[0x22] = (12 << 4) \| 12;
1348	/* MIDI ... */
1349	pThis->mixer_regs[0x26] = (12 << 4) \| 12;
1350
1351	/* master/voice/MIDI L/R volume */
1352	for (int i = 0x30; i < 0x36; i++)
1353	pThis->mixer_regs[i] = 24 << 3; /* -14 dB */
1354
1355	/* treble/bass */
1356	for (int i = 0x44; i < 0x48; i++)
1357	pThis->mixer_regs[i] = 0x80;
1358
1359	int rc2 = AudioMixerCreate("SB16 Mixer", 0 /* uFlags */, &pThis->pMixer);
1360	if (RT_SUCCESS(rc2))
1361	{
1362	/* Set a default audio format for our mixer. */
1363	PDMAUDIOSTREAMCFG streamCfg;
1364	streamCfg.uHz = 44100;
1365	streamCfg.cChannels = 2;
1366	streamCfg.enmFormat = AUD_FMT_S16;
1367	streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
1368
1369	rc2 = AudioMixerSetDeviceFormat(pThis->pMixer, &streamCfg);
1370	AssertRC(rc2);
1371
1372	/* Add all required audio sinks. */
1373	rc2 = AudioMixerAddSink(pThis->pMixer, "[Playback] PCM Output",
1374	AUDMIXSINKDIR_OUTPUT, &pThis->pSinkOutput);
1375	AssertRC(rc2);
1376	}
1377
1378	/* Update the master (mixer) and PCM out volumes. */
1379	sb16SetMasterVolume(pThis);
1380	sb16SetPcmOutVolume(pThis);
1381	}
1382
1383	static IO_WRITE_PROTO(mixer_write_indexb)
1384	{
1385	PSB16STATE pThis = (PSB16STATE)opaque;
1386	(void) nport;
1387	pThis->mixer_nreg = val;
1388
1389	return VINF_SUCCESS;
1390	}
1391
1392	uint32_t popcount(uint32_t u) /** @todo r=andy WTF? */
1393	{
1394	u = ((u&0x55555555) + ((u>>1)&0x55555555));
1395	u = ((u&0x33333333) + ((u>>2)&0x33333333));
1396	u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
1397	u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
1398	u = ( u&0x0000ffff) + (u>>16);
1399	return u;
1400	}
1401
1402	uint32_t lsbindex(uint32_t u)
1403	{
1404	return popcount((u & -(int32_t)u) - 1);
1405	}
1406
1407	/* Convert SB16 to SB Pro mixer volume (left). */
1408	static inline void sb16ConvVolumeL(PSB16STATE pThis, unsigned reg, uint8_t val)
1409	{
1410	/* High nibble in SBP mixer. */
1411	pThis->mixer_regs[reg] = (pThis->mixer_regs[reg] & 0x0f) \| (val & 0xf0);
1412	}
1413
1414	/* Convert SB16 to SB Pro mixer volume (right). */
1415	static inline void sb16ConvVolumeR(PSB16STATE pThis, unsigned reg, uint8_t val)
1416	{
1417	/* Low nibble in SBP mixer. */
1418	pThis->mixer_regs[reg] = (pThis->mixer_regs[reg] & 0xf0) \| (val >> 4);
1419	}
1420
1421	/* Convert SB Pro to SB16 mixer volume (left + right). */
1422	static inline void sb16ConvVolumeOldToNew(PSB16STATE pThis, unsigned reg, uint8_t val)
1423	{
1424	/* Left channel. */
1425	pThis->mixer_regs[reg + 0] = (val & 0xf0) \| RT_BIT(3);
1426	/* Right channel (the register immediately following). */
1427	pThis->mixer_regs[reg + 1] = (val << 4) \| RT_BIT(3);
1428	}
1429
1430	static IO_WRITE_PROTO(mixer_write_datab)
1431	{
1432	PSB16STATE pThis = (PSB16STATE)opaque;
1433	bool fUpdateMaster = false;
1434	bool fUpdateStream = false;
1435
1436	(void) nport;
1437	LogFlowFunc(("mixer_write [%#x] <- %#x\n", pThis->mixer_nreg, val));
1438
1439	switch (pThis->mixer_nreg)
1440	{
1441	case 0x00:
1442	sb16MixerReset(pThis);
1443	/* And update the actual volume, too. */
1444	fUpdateMaster = true;
1445	fUpdateStream = true;
1446	break;
1447
1448	case 0x04: /* Translate from old style voice volume (L/R). */
1449	sb16ConvVolumeOldToNew(pThis, 0x32, val);
1450	fUpdateStream = true;
1451	break;
1452
1453	case 0x22: /* Translate from old style master volume (L/R). */
1454	sb16ConvVolumeOldToNew(pThis, 0x30, val);
1455	fUpdateMaster = true;
1456	break;
1457
1458	case 0x26: /* Translate from old style MIDI volume (L/R). */
1459	sb16ConvVolumeOldToNew(pThis, 0x34, val);
1460	break;
1461
1462	case 0x28: /* Translate from old style CD volume (L/R). */
1463	sb16ConvVolumeOldToNew(pThis, 0x36, val);
1464	break;
1465
1466	case 0x2E: /* Translate from old style line volume (L/R). */
1467	sb16ConvVolumeOldToNew(pThis, 0x38, val);
1468	break;
1469
1470	case 0x30: /* Translate to old style master volume (L). */
1471	sb16ConvVolumeL(pThis, 0x22, val);
1472	fUpdateMaster = true;
1473	break;
1474
1475	case 0x31: /* Translate to old style master volume (R). */
1476	sb16ConvVolumeR(pThis, 0x22, val);
1477	fUpdateMaster = true;
1478	break;
1479
1480	case 0x32: /* Translate to old style voice volume (L). */
1481	sb16ConvVolumeL(pThis, 0x04, val);
1482	fUpdateStream = true;
1483	break;
1484
1485	case 0x33: /* Translate to old style voice volume (R). */
1486	sb16ConvVolumeR(pThis, 0x04, val);
1487	fUpdateStream = true;
1488	break;
1489
1490	case 0x34: /* Translate to old style MIDI volume (L). */
1491	sb16ConvVolumeL(pThis, 0x26, val);
1492	break;
1493
1494	case 0x35: /* Translate to old style MIDI volume (R). */
1495	sb16ConvVolumeR(pThis, 0x26, val);
1496	break;
1497
1498	case 0x36: /* Translate to old style CD volume (L). */
1499	sb16ConvVolumeL(pThis, 0x28, val);
1500	break;
1501
1502	case 0x37: /* Translate to old style CD volume (R). */
1503	sb16ConvVolumeR(pThis, 0x28, val);
1504	break;
1505
1506	case 0x38: /* Translate to old style line volume (L). */
1507	sb16ConvVolumeL(pThis, 0x2E, val);
1508	break;
1509
1510	case 0x39: /* Translate to old style line volume (R). */
1511	sb16ConvVolumeR(pThis, 0x2E, val);
1512	break;
1513
1514	case 0x80:
1515	{
1516	int irq = irq_of_magic(val);
1517	LogFlowFunc(("setting irq to %d (val=%#x)\n", irq, val));
1518	if (irq > 0)
1519	pThis->irq = irq;
1520	break;
1521	}
1522
1523	case 0x81:
1524	{
1525	int dma, hdma;
1526
1527	dma = lsbindex (val & 0xf);
1528	hdma = lsbindex (val & 0xf0);
1529	if (dma != pThis->dma \|\| hdma != pThis->hdma)
1530	LogFlow(("SB16: attempt to change DMA 8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
1531	dma, pThis->dma, hdma, pThis->hdma, val));
1532	#if 0
1533	pThis->dma = dma;
1534	pThis->hdma = hdma;
1535	#endif
1536	break;
1537	}
1538
1539	case 0x82:
1540	LogFlowFunc(("attempt to write into IRQ status register (val=%#x)\n", val));
1541	return VINF_SUCCESS;
1542
1543	default:
1544	if (pThis->mixer_nreg >= 0x80)
1545	LogFlowFunc(("attempt to write mixer[%#x] <- %#x\n", pThis->mixer_nreg, val));
1546	break;
1547	}
1548
1549	pThis->mixer_regs[pThis->mixer_nreg] = val;
1550
1551	/* Update the master (mixer) volume. */
1552	if (fUpdateMaster)
1553	sb16SetMasterVolume(pThis);
1554
1555	/* Update the stream (PCM) volume. */
1556	if (fUpdateStream)
1557	sb16SetPcmOutVolume(pThis);
1558
1559	return VINF_SUCCESS;
1560	}
1561
1562	static IO_WRITE_PROTO(mixer_write)
1563	{
1564	PSB16STATE pThis = (PSB16STATE)opaque;
1565	int iport = nport - pThis->port;
1566	switch (cb)
1567	{
1568	case 1:
1569	switch (iport)
1570	{
1571	case 4:
1572	mixer_write_indexb (pDevIns, opaque, nport, val, 1);
1573	break;
1574	case 5:
1575	mixer_write_datab (pDevIns, opaque, nport, val, 1);
1576	break;
1577	}
1578	break;
1579	case 2:
1580	mixer_write_indexb (pDevIns, opaque, nport, val & 0xff, 1);
1581	mixer_write_datab (pDevIns, opaque, nport, (val >> 8) & 0xff, 1);
1582	break;
1583	default:
1584	AssertMsgFailed(("Port=%#x cb=%d u32=%#x\n", nport, cb, val));
1585	break;
1586	}
1587	return VINF_SUCCESS;
1588	}
1589
1590	static IO_READ_PROTO(mixer_read)
1591	{
1592	PSB16STATE pThis = (PSB16STATE)opaque;
1593
1594	(void) nport;
1595	#ifndef DEBUG_SB16_MOST
1596	if (pThis->mixer_nreg != 0x82) {
1597	LogFlowFunc(("mixer_read[%#x] -> %#x\n",
1598	pThis->mixer_nreg, pThis->mixer_regs[pThis->mixer_nreg]));
1599	}
1600	#else
1601	LogFlowFunc(("mixer_read[%#x] -> %#x\n",
1602	pThis->mixer_nreg, pThis->mixer_regs[pThis->mixer_nreg]));
1603	#endif
1604	*pu32 = pThis->mixer_regs[pThis->mixer_nreg];
1605	return VINF_SUCCESS;
1606	}
1607
1608	static int sb16WriteAudio(PSB16STATE pThis, int nchan, uint32_t dma_pos,
1609	uint32_t dma_len, int len)
1610	{
1611	uint8_t tmpbuf[_4K]; /** @todo Have a buffer on the heap. */
1612	uint32_t cbToWrite = len;
1613	uint32_t cbWrittenTotal = 0;
1614
1615	while (cbToWrite)
1616	{
1617	uint32_t cbToRead;
1618	uint32_t cbRead;
1619
1620	cbToRead = RT_MIN(dma_len - dma_pos, cbToWrite);
1621	if (cbToRead > sizeof(tmpbuf))
1622	cbToRead = sizeof(tmpbuf);
1623
1624	int rc = PDMDevHlpDMAReadMemory(pThis->pDevInsR3, nchan, tmpbuf, dma_pos, cbToRead, &cbRead);
1625	AssertMsgRC(rc, ("DMAReadMemory -> %Rrc\n", rc));
1626
1627	uint32_t cbWritten;
1628
1629	/* Just multiplex the output to the connected backends.
1630	* No need to utilize the virtual mixer here (yet). */
1631	PSB16DRIVER pDrv;
1632	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1633	{
1634	int rc2 = pDrv->pConnector->pfnWrite(pDrv->pConnector, pDrv->Out.pStrmOut,
1635	tmpbuf, cbToRead, &cbWritten);
1636	LogFlowFunc(("\tLUN#%RU8: rc=%Rrc, cbWritten=%RU32\n", pDrv->uLUN, rc2, cbWritten));
1637	}
1638
1639	Assert(cbToWrite >= cbToRead);
1640	cbToWrite -= cbToRead;
1641	dma_pos = (dma_pos + cbToRead) % dma_len;
1642	cbWrittenTotal += cbToRead;
1643
1644	if (!cbRead)
1645	break;
1646	}
1647
1648	return cbWrittenTotal;
1649	}
1650
1651	static DECLCALLBACK(uint32_t) sb16DMARead(PPDMDEVINS pDevIns, void *opaque, unsigned nchan, uint32_t dma_pos, uint32_t dma_len)
1652	{
1653	PSB16STATE pThis = (PSB16STATE)opaque;
1654	int till, copy, written, free;
1655
1656	if (pThis->block_size <= 0)
1657	{
1658	LogFlowFunc(("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
1659	pThis->block_size, nchan, dma_pos, dma_len));
1660	return dma_pos;
1661	}
1662
1663	if (pThis->left_till_irq < 0)
1664	pThis->left_till_irq = pThis->block_size;
1665
1666	PSB16DRIVER pDrv;
1667
1668	uint32_t cbOutMin = UINT32_MAX;
1669	uint32_t cbOut;
1670	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1671	{
1672	int rc2 = pDrv->pConnector->pfnQueryStatus(pDrv->pConnector,
1673	NULL /* pcbIn /, &cbOut, NULL / pcSamplesLive */);
1674	if (RT_SUCCESS(rc2))
1675	cbOutMin = RT_MIN(cbOutMin, cbOut);
1676	}
1677
1678	LogFlowFunc(("cbOutMin=%RU32\n", cbOutMin));
1679	if (cbOutMin == UINT32_MAX)
1680	{
1681	free = dma_len;
1682	}
1683	else
1684	{
1685	free = cbOutMin & ~pThis->align; /** @todo int vs. uint32. */
1686	if ((free <= 0) \|\| !dma_len)
1687	return dma_pos;
1688	}
1689
1690	copy = free;
1691	till = pThis->left_till_irq;
1692
1693	#ifdef DEBUG_SB16_MOST
1694	LogFlowFunc(("pos:%06d %d till:%d len:%d\n", dma_pos, free, till, dma_len));
1695	#endif
1696
1697	if (copy >= till)
1698	{
1699	if (0 == pThis->dma_auto)
1700	{
1701	copy = till;
1702	}
1703	else
1704	{
1705	if (copy >= till + pThis->block_size)
1706	copy = till; /* Make sure we won't skip IRQs. */
1707	}
1708	}
1709
1710	written = sb16WriteAudio(pThis, nchan, dma_pos, dma_len, copy);
1711	dma_pos = (dma_pos + written) % dma_len;
1712	pThis->left_till_irq -= written;
1713
1714	if (pThis->left_till_irq <= 0)
1715	{
1716	pThis->mixer_regs[0x82] \|= (nchan & 4) ? 2 : 1;
1717	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 1);
1718	if (0 == pThis->dma_auto)
1719	{
1720	sb16Control(pThis, 0);
1721	sb16SpeakerControl(pThis, 0);
1722	}
1723	}
1724
1725	#ifdef DEBUG_SB16_MOST
1726	LogFlowFunc(("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
1727	dma_pos, free, dma_len, pThis->left_till_irq, copy, written,
1728	pThis->block_size));
1729	#endif
1730
1731	while (pThis->left_till_irq <= 0)
1732	pThis->left_till_irq += pThis->block_size;
1733
1734	return dma_pos;
1735	}
1736
1737	static DECLCALLBACK(void) sb16TimerIO(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1738	{
1739	PSB16STATE pThis = (PSB16STATE)pvUser;
1740	Assert(pThis == PDMINS_2_DATA(pDevIns, PSB16STATE));
1741	AssertPtr(pThis);
1742
1743	uint32_t cbInMax = 0;
1744	uint32_t cbOutMin = UINT32_MAX;
1745
1746	PSB16DRIVER pDrv;
1747
1748	uint64_t cTicksNow = TMTimerGet(pTimer);
1749	uint64_t cTicksElapsed = cTicksNow - pThis->uTimerTSIO;
1750	uint64_t cTicksPerSec = TMTimerGetFreq(pTimer);
1751
1752	pThis->uTimerTSIO = cTicksNow;
1753
1754	/*
1755	* Calculate the mixer's (fixed) sampling rate.
1756	*/
1757	AssertPtr(pThis->pMixer);
1758
1759	PDMAUDIOSTREAMCFG mixerStrmCfg;
1760	int rc = AudioMixerGetDeviceFormat(pThis->pMixer, &mixerStrmCfg);
1761	AssertRC(rc);
1762
1763	PDMPCMPROPS mixerStrmProps;
1764	rc = DrvAudioStreamCfgToProps(&mixerStrmCfg, &mixerStrmProps);
1765	AssertRC(rc);
1766
1767	uint32_t cMixerSamplesMin = (int)((2 * cTicksElapsed * mixerStrmCfg.uHz + cTicksPerSec) / cTicksPerSec / 2);
1768	uint32_t cbMixerSamplesMin = cMixerSamplesMin << mixerStrmProps.cShift;
1769
1770	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1771	{
1772	uint32_t cbIn = 0;
1773	uint32_t cbOut = 0;
1774
1775	rc = pDrv->pConnector->pfnQueryStatus(pDrv->pConnector,
1776	&cbIn, &cbOut, NULL /* cSamplesLive */);
1777	if (RT_SUCCESS(rc))
1778	rc = pDrv->pConnector->pfnPlayOut(pDrv->pConnector, NULL /* cSamplesPlayed */);
1779
1780	#ifdef DEBUG_TIMER
1781	LogFlowFunc(("LUN#%RU8: rc=%Rrc, cbIn=%RU32, cbOut=%RU32\n", pDrv->uLUN, rc, cbIn, cbOut));
1782	#endif
1783	/* If we there was an error handling (available) output or there simply is no output available,
1784	* then calculate the minimum data rate which must be processed by the device emulation in order
1785	* to function correctly.
1786	*
1787	* This is not the optimal solution, but as we have to deal with this on a timer-based approach
1788	* (until we have the audio callbacks) we need to have device' DMA engines running. */
1789	if (!pDrv->pConnector->pfnIsValidOut(pDrv->pConnector, pDrv->Out.pStrmOut))
1790	{
1791	/* Use the mixer's (fixed) sampling rate. */
1792	cbOut = RT_MAX(cbOut, cbMixerSamplesMin);
1793	continue;
1794	}
1795
1796	const bool fIsActiveOut = pDrv->pConnector->pfnIsActiveOut(pDrv->pConnector, pDrv->Out.pStrmOut);
1797	if ( RT_FAILURE(rc)
1798	\|\| !fIsActiveOut)
1799	{
1800	uint32_t cSamplesMin = (int)((2 * cTicksElapsed * pDrv->Out.pStrmOut->Props.uHz + cTicksPerSec) / cTicksPerSec / 2);
1801	uint32_t cbSamplesMin = AUDIOMIXBUF_S2B(&pDrv->Out.pStrmOut->MixBuf, cSamplesMin);
1802
1803	Log2Func(("\trc=%Rrc, cSamplesMin=%RU32, cbSamplesMin=%RU32\n", rc, cSamplesMin, cbSamplesMin));
1804
1805	cbOut = RT_MAX(cbOut, cbSamplesMin);
1806	}
1807
1808	cbOutMin = RT_MIN(cbOutMin, cbOut);
1809	cbInMax = RT_MAX(cbInMax, cbIn);
1810	}
1811
1812	Log2Func(("cbInMax=%RU32, cbOutMin=%RU32\n", cbInMax, cbOutMin));
1813
1814	if (cbOutMin == UINT32_MAX)
1815	cbOutMin = 0;
1816
1817	/*
1818	* Playback.
1819	*/
1820	if (cbOutMin)
1821	{
1822	Assert(cbOutMin != UINT32_MAX);
1823
1824	/* New space available, see if we can transfer more. */
1825	PDMDevHlpDMASchedule(pThis->pDevInsR3);
1826	}
1827
1828	/*
1829	* Recording.
1830	*/
1831	/** @todo Implement recording. */
1832
1833	/* Kick the timer again. */
1834	uint64_t cTicks = pThis->cTimerTicksIO;
1835	/** @todo adjust cTicks down by now much cbOutMin represents. */
1836	TMTimerSet(pThis->pTimerIO, cTicksNow + cTicks);
1837	}
1838
1839	static void sb16Save(PSSMHANDLE pSSM, PSB16STATE pThis)
1840	{
1841	SSMR3PutS32(pSSM, pThis->irq);
1842	SSMR3PutS32(pSSM, pThis->dma);
1843	SSMR3PutS32(pSSM, pThis->hdma);
1844	SSMR3PutS32(pSSM, pThis->port);
1845	SSMR3PutS32(pSSM, pThis->ver);
1846	SSMR3PutS32(pSSM, pThis->in_index);
1847	SSMR3PutS32(pSSM, pThis->out_data_len);
1848	SSMR3PutS32(pSSM, pThis->fmt_stereo);
1849	SSMR3PutS32(pSSM, pThis->fmt_signed);
1850	SSMR3PutS32(pSSM, pThis->fmt_bits);
1851
1852	SSMR3PutU32(pSSM, pThis->fmt);
1853
1854	SSMR3PutS32(pSSM, pThis->dma_auto);
1855	SSMR3PutS32(pSSM, pThis->block_size);
1856	SSMR3PutS32(pSSM, pThis->fifo);
1857	SSMR3PutS32(pSSM, pThis->freq);
1858	SSMR3PutS32(pSSM, pThis->time_const);
1859	SSMR3PutS32(pSSM, pThis->speaker);
1860	SSMR3PutS32(pSSM, pThis->needed_bytes);
1861	SSMR3PutS32(pSSM, pThis->cmd);
1862	SSMR3PutS32(pSSM, pThis->use_hdma);
1863	SSMR3PutS32(pSSM, pThis->highspeed);
1864	SSMR3PutS32(pSSM, pThis->can_write);
1865	SSMR3PutS32(pSSM, pThis->v2x6);
1866
1867	SSMR3PutU8 (pSSM, pThis->csp_param);
1868	SSMR3PutU8 (pSSM, pThis->csp_value);
1869	SSMR3PutU8 (pSSM, pThis->csp_mode);
1870	SSMR3PutU8 (pSSM, pThis->csp_param); /* Bug compatible! */
1871	SSMR3PutMem(pSSM, pThis->csp_regs, 256);
1872	SSMR3PutU8 (pSSM, pThis->csp_index);
1873	SSMR3PutMem(pSSM, pThis->csp_reg83, 4);
1874	SSMR3PutS32(pSSM, pThis->csp_reg83r);
1875	SSMR3PutS32(pSSM, pThis->csp_reg83w);
1876
1877	SSMR3PutMem(pSSM, pThis->in2_data, sizeof (pThis->in2_data));
1878	SSMR3PutMem(pSSM, pThis->out_data, sizeof (pThis->out_data));
1879	SSMR3PutU8 (pSSM, pThis->test_reg);
1880	SSMR3PutU8 (pSSM, pThis->last_read_byte);
1881
1882	SSMR3PutS32(pSSM, pThis->nzero);
1883	SSMR3PutS32(pSSM, pThis->left_till_irq);
1884	SSMR3PutS32(pSSM, pThis->dma_running);
1885	SSMR3PutS32(pSSM, pThis->bytes_per_second);
1886	SSMR3PutS32(pSSM, pThis->align);
1887
1888	SSMR3PutS32(pSSM, pThis->mixer_nreg);
1889	SSMR3PutMem(pSSM, pThis->mixer_regs, 256);
1890
1891	}
1892
1893	static int sb16Load(PSSMHANDLE pSSM, PSB16STATE pThis, int version_id)
1894	{
1895	SSMR3GetS32(pSSM, &pThis->irq);
1896	SSMR3GetS32(pSSM, &pThis->dma);
1897	SSMR3GetS32(pSSM, &pThis->hdma);
1898	SSMR3GetS32(pSSM, &pThis->port);
1899	SSMR3GetS32(pSSM, &pThis->ver);
1900	SSMR3GetS32(pSSM, &pThis->in_index);
1901	SSMR3GetS32(pSSM, &pThis->out_data_len);
1902	SSMR3GetS32(pSSM, &pThis->fmt_stereo);
1903	SSMR3GetS32(pSSM, &pThis->fmt_signed);
1904	SSMR3GetS32(pSSM, &pThis->fmt_bits);
1905
1906	SSMR3GetU32(pSSM, (uint32_t *)&pThis->fmt);
1907
1908	SSMR3GetS32(pSSM, &pThis->dma_auto);
1909	SSMR3GetS32(pSSM, &pThis->block_size);
1910	SSMR3GetS32(pSSM, &pThis->fifo);
1911	SSMR3GetS32(pSSM, &pThis->freq);
1912	SSMR3GetS32(pSSM, &pThis->time_const);
1913	SSMR3GetS32(pSSM, &pThis->speaker);
1914	SSMR3GetS32(pSSM, &pThis->needed_bytes);
1915	SSMR3GetS32(pSSM, &pThis->cmd);
1916	SSMR3GetS32(pSSM, &pThis->use_hdma);
1917	SSMR3GetS32(pSSM, &pThis->highspeed);
1918	SSMR3GetS32(pSSM, &pThis->can_write);
1919	SSMR3GetS32(pSSM, &pThis->v2x6);
1920
1921	SSMR3GetU8 (pSSM, &pThis->csp_param);
1922	SSMR3GetU8 (pSSM, &pThis->csp_value);
1923	SSMR3GetU8 (pSSM, &pThis->csp_mode);
1924	SSMR3GetU8 (pSSM, &pThis->csp_param); /* Bug compatible! */
1925	SSMR3GetMem(pSSM, pThis->csp_regs, 256);
1926	SSMR3GetU8 (pSSM, &pThis->csp_index);
1927	SSMR3GetMem(pSSM, pThis->csp_reg83, 4);
1928	SSMR3GetS32(pSSM, &pThis->csp_reg83r);
1929	SSMR3GetS32(pSSM, &pThis->csp_reg83w);
1930
1931	SSMR3GetMem(pSSM, pThis->in2_data, sizeof (pThis->in2_data));
1932	SSMR3GetMem(pSSM, pThis->out_data, sizeof (pThis->out_data));
1933	SSMR3GetU8 (pSSM, &pThis->test_reg);
1934	SSMR3GetU8 (pSSM, &pThis->last_read_byte);
1935
1936	SSMR3GetS32(pSSM, &pThis->nzero);
1937	SSMR3GetS32(pSSM, &pThis->left_till_irq);
1938	SSMR3GetS32(pSSM, &pThis->dma_running);
1939	SSMR3GetS32(pSSM, &pThis->bytes_per_second);
1940	SSMR3GetS32(pSSM, &pThis->align);
1941
1942	SSMR3GetS32(pSSM, &pThis->mixer_nreg);
1943	SSMR3GetMem(pSSM, pThis->mixer_regs, 256);
1944
1945	#if 0
1946	PSB16DRIVER pDrv;
1947	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
1948	{
1949	if (pDrv->Out.pStrmOut)
1950	{
1951	pDrv->pConnector->pfnCloseOut(pThis->pDrv, pDrv->Out.pStrmOut);
1952	pDrv->Out.pStrmOut = NULL;
1953	}
1954	}
1955	#endif
1956
1957	if (pThis->dma_running)
1958	{
1959	if (pThis->freq)
1960	{
1961	PDMAUDIOSTREAMCFG streamCfg;
1962	streamCfg.uHz = pThis->freq;
1963	streamCfg.cChannels = 1 << pThis->fmt_stereo;
1964	streamCfg.enmFormat = pThis->fmt;
1965	streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
1966
1967	int rc = sb16OpenOut(pThis, &streamCfg);
1968	AssertRC(rc);
1969	}
1970
1971	sb16Control(pThis, 1);
1972	sb16SpeakerControl(pThis, pThis->speaker);
1973	}
1974
1975	/* Update the master (mixer) and PCM out volumes. */
1976	sb16SetMasterVolume(pThis);
1977	sb16SetPcmOutVolume(pThis);
1978
1979	return VINF_SUCCESS;
1980	}
1981
1982	static DECLCALLBACK(int) sb16LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
1983	{
1984	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
1985
1986	SSMR3PutS32(pSSM, pThis->irqCfg);
1987	SSMR3PutS32(pSSM, pThis->dmaCfg);
1988	SSMR3PutS32(pSSM, pThis->hdmaCfg);
1989	SSMR3PutS32(pSSM, pThis->portCfg);
1990	SSMR3PutS32(pSSM, pThis->verCfg);
1991	return VINF_SSM_DONT_CALL_AGAIN;
1992	}
1993
1994	static DECLCALLBACK(int) sb16SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1995	{
1996	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
1997
1998	sb16LiveExec(pDevIns, pSSM, 0);
1999	sb16Save(pSSM, pThis);
2000	return VINF_SUCCESS;
2001	}
2002
2003	static DECLCALLBACK(int) sb16LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2004	{
2005	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
2006
2007	AssertMsgReturn( uVersion == SB16_SAVE_STATE_VERSION
2008	\|\| uVersion == SB16_SAVE_STATE_VERSION_VBOX_30,
2009	("%u\n", uVersion),
2010	VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
2011	if (uVersion > SB16_SAVE_STATE_VERSION_VBOX_30)
2012	{
2013	int32_t irq;
2014	SSMR3GetS32 (pSSM, &irq);
2015	int32_t dma;
2016	SSMR3GetS32 (pSSM, &dma);
2017	int32_t hdma;
2018	SSMR3GetS32 (pSSM, &hdma);
2019	int32_t port;
2020	SSMR3GetS32 (pSSM, &port);
2021	int32_t ver;
2022	int rc = SSMR3GetS32 (pSSM, &ver);
2023	AssertRCReturn (rc, rc);
2024
2025	if ( irq != pThis->irqCfg
2026	\|\| dma != pThis->dmaCfg
2027	\|\| hdma != pThis->hdmaCfg
2028	\|\| port != pThis->portCfg
2029	\|\| ver != pThis->verCfg)
2030	{
2031	return SSMR3SetCfgError(pSSM, RT_SRC_POS,
2032	N_("config changed: irq=%x/%x dma=%x/%x hdma=%x/%x port=%x/%x ver=%x/%x (saved/config)"),
2033	irq, pThis->irqCfg,
2034	dma, pThis->dmaCfg,
2035	hdma, pThis->hdmaCfg,
2036	port, pThis->portCfg,
2037	ver, pThis->verCfg);
2038	}
2039	}
2040
2041	if (uPass != SSM_PASS_FINAL)
2042	return VINF_SUCCESS;
2043
2044	sb16Load(pSSM, pThis, uVersion);
2045	return VINF_SUCCESS;
2046	}
2047
2048	static int sb16OpenOut(PSB16STATE pThis, PPDMAUDIOSTREAMCFG pCfg)
2049	{
2050	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2051	AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2052
2053	int rc = VINF_SUCCESS;
2054
2055	PSB16DRIVER pDrv;
2056	uint8_t uLUN = 0;
2057
2058	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
2059	{
2060	char *pszDesc;
2061	if (RTStrAPrintf(&pszDesc, "[LUN#%RU8] sb16.po", uLUN) <= 0)
2062	{
2063	rc = VERR_NO_MEMORY;
2064	break;
2065	}
2066
2067	int rc2 = pDrv->pConnector->pfnCreateOut(pDrv->pConnector, pszDesc, pCfg, &pDrv->Out.pStrmOut);
2068	LogFlowFunc(("LUN#%RU8: Created output with rc=%Rrc\n", uLUN, rc));
2069	if (rc2 == VINF_SUCCESS) /* Note: Could return VWRN_ALREADY_EXISTS. */
2070	{
2071	AudioMixerRemoveStream(pThis->pSinkOutput, pDrv->Out.phStrmOut);
2072	rc = AudioMixerAddStreamOut(pThis->pSinkOutput,
2073	pDrv->pConnector, pDrv->Out.pStrmOut,
2074	0 /* uFlags */,
2075	&pDrv->Out.phStrmOut);
2076	}
2077
2078	RTStrFree(pszDesc);
2079
2080	if (RT_FAILURE(rc2))
2081	{
2082	if (RT_SUCCESS(rc))
2083	rc = rc2;
2084	break;
2085	}
2086
2087	uLUN++;
2088	}
2089
2090	/* Ensure volume gets propagated. */
2091	AudioMixerInvalidate(pThis->pMixer);
2092
2093	return rc;
2094	}
2095
2096	/**
2097	* @interface_method_impl{PDMDEVREG,pfnReset}
2098	*/
2099	static DECLCALLBACK(void) sb16DevReset(PPDMDEVINS pDevIns)
2100	{
2101	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
2102
2103	/* Bring back the device to initial state, and especially make
2104	* sure there's no interrupt or DMA activity.
2105	*/
2106	PDMDevHlpISASetIrq(pThis->pDevInsR3, pThis->irq, 0);
2107
2108	pThis->mixer_regs[0x82] = 0;
2109	pThis->csp_regs[5] = 1;
2110	pThis->csp_regs[9] = 0xf8;
2111
2112	pThis->dma_auto = 0;
2113	pThis->in_index = 0;
2114	pThis->out_data_len = 0;
2115	pThis->left_till_irq = 0;
2116	pThis->needed_bytes = 0;
2117	pThis->block_size = -1;
2118	pThis->nzero = 0;
2119	pThis->highspeed = 0;
2120	pThis->v2x6 = 0;
2121	pThis->cmd = -1;
2122
2123	sb16MixerReset(pThis);
2124	sb16SpeakerControl(pThis, 0);
2125	sb16Control(pThis, 0);
2126	sb16ResetLegacy(pThis);
2127	}
2128
2129	/**
2130	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
2131	*/
2132	static DECLCALLBACK(void ) sb16QueryInterface(struct PDMIBASE pInterface, const char *pszIID)
2133	{
2134	PSB16STATE pThis = RT_FROM_MEMBER(pInterface, SB16STATE, IBase);
2135	Assert(&pThis->IBase == pInterface);
2136
2137	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2138	return NULL;
2139	}
2140
2141	/**
2142	* @interface_method_impl{PDMDEVREG,pfnDestruct}
2143	*/
2144	static DECLCALLBACK(int) sb16Destruct(PPDMDEVINS pDevIns)
2145	{
2146	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
2147
2148	PSB16DRIVER pDrv;
2149
2150	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
2151	pDrv->Out.phStrmOut = NULL;
2152
2153	pThis->pSinkOutput = NULL;
2154
2155	if (pThis->pMixer)
2156	{
2157	AudioMixerDestroy(pThis->pMixer);
2158	pThis->pMixer = NULL;
2159	}
2160
2161	return VINF_SUCCESS;
2162	}
2163
2164	static DECLCALLBACK(int) sb16Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2165	{
2166	PSB16STATE pThis = PDMINS_2_DATA(pDevIns, PSB16STATE);
2167
2168	/*
2169	* Validations.
2170	*/
2171	Assert(iInstance == 0);
2172	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2173	if (!CFGMR3AreValuesValid(pCfg,
2174	"IRQ\0"
2175	"DMA\0"
2176	"DMA16\0"
2177	"Port\0"
2178	"Version\0"
2179	"TimerHz\0"))
2180	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
2181	N_("Invalid configuration for SB16 device"));
2182
2183	/*
2184	* Read config data.
2185	*/
2186	int rc = CFGMR3QuerySIntDef(pCfg, "IRQ", &pThis->irq, 5);
2187	if (RT_FAILURE(rc))
2188	return PDMDEV_SET_ERROR(pDevIns, rc,
2189	N_("SB16 configuration error: Failed to get the \"IRQ\" value"));
2190	pThis->irqCfg = pThis->irq;
2191
2192	rc = CFGMR3QuerySIntDef(pCfg, "DMA", &pThis->dma, 1);
2193	if (RT_FAILURE(rc))
2194	return PDMDEV_SET_ERROR(pDevIns, rc,
2195	N_("SB16 configuration error: Failed to get the \"DMA\" value"));
2196	pThis->dmaCfg = pThis->dma;
2197
2198	rc = CFGMR3QuerySIntDef(pCfg, "DMA16", &pThis->hdma, 5);
2199	if (RT_FAILURE(rc))
2200	return PDMDEV_SET_ERROR(pDevIns, rc,
2201	N_("SB16 configuration error: Failed to get the \"DMA16\" value"));
2202	pThis->hdmaCfg = pThis->hdma;
2203
2204	RTIOPORT Port;
2205	rc = CFGMR3QueryPortDef(pCfg, "Port", &Port, 0x220);
2206	if (RT_FAILURE(rc))
2207	return PDMDEV_SET_ERROR(pDevIns, rc,
2208	N_("SB16 configuration error: Failed to get the \"Port\" value"));
2209	pThis->port = Port;
2210	pThis->portCfg = Port;
2211
2212	uint16_t u16Version;
2213	rc = CFGMR3QueryU16Def(pCfg, "Version", &u16Version, 0x0405);
2214	if (RT_FAILURE(rc))
2215	return PDMDEV_SET_ERROR(pDevIns, rc,
2216	N_("SB16 configuration error: Failed to get the \"Version\" value"));
2217
2218	#ifndef VBOX_WITH_AUDIO_CALLBACKS
2219	uint16_t uTimerHz;
2220	rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 200 /* Hz */);
2221	if (RT_FAILURE(rc))
2222	return PDMDEV_SET_ERROR(pDevIns, rc,
2223	N_("SB16 configuration error: failed to read Hertz (Hz) rate as unsigned integer"));
2224	#endif
2225
2226	pThis->ver = u16Version;
2227	pThis->verCfg = u16Version;
2228
2229	/*
2230	* Init instance data.
2231	*/
2232	pThis->pDevInsR3 = pDevIns;
2233	pThis->IBase.pfnQueryInterface = sb16QueryInterface;
2234	pThis->cmd = -1;
2235
2236	pThis->mixer_regs[0x80] = magic_of_irq (pThis->irq);
2237	pThis->mixer_regs[0x81] = (1 << pThis->dma) \| (1 << pThis->hdma);
2238	pThis->mixer_regs[0x82] = 2 << 5;
2239
2240	pThis->csp_regs[5] = 1;
2241	pThis->csp_regs[9] = 0xf8;
2242
2243	RTListInit(&pThis->lstDrv);
2244
2245	sb16MixerReset(pThis);
2246
2247	/*
2248	* Create timer(s), register & attach stuff.
2249	*/
2250	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIRQ, pThis,
2251	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "SB16 IRQ timer", &pThis->pTimerIRQ);
2252	if (RT_FAILURE(rc))
2253	AssertMsgFailedReturn(("Error creating IRQ timer, rc=%Rrc\n", rc), rc);
2254
2255	rc = PDMDevHlpIOPortRegister(pDevIns, pThis->port + 0x04, 2, pThis,
2256	mixer_write, mixer_read, NULL, NULL, "SB16");
2257	if (RT_FAILURE(rc))
2258	return rc;
2259	rc = PDMDevHlpIOPortRegister(pDevIns, pThis->port + 0x06, 10, pThis,
2260	dsp_write, dsp_read, NULL, NULL, "SB16");
2261	if (RT_FAILURE(rc))
2262	return rc;
2263
2264	rc = PDMDevHlpDMARegister(pDevIns, pThis->hdma, sb16DMARead, pThis);
2265	if (RT_FAILURE(rc))
2266	return rc;
2267	rc = PDMDevHlpDMARegister(pDevIns, pThis->dma, sb16DMARead, pThis);
2268	if (RT_FAILURE(rc))
2269	return rc;
2270
2271	pThis->can_write = 1;
2272
2273	rc = PDMDevHlpSSMRegister3(pDevIns, SB16_SAVE_STATE_VERSION, sizeof(SB16STATE), sb16LiveExec, sb16SaveExec, sb16LoadExec);
2274	if (RT_FAILURE(rc))
2275	return rc;
2276
2277	/*
2278	* Attach driver.
2279	*/
2280	uint8_t uLUN;
2281	for (uLUN = 0; uLUN < UINT8_MAX; ++uLUN)
2282	{
2283	LogFunc(("Trying to attach driver for LUN #%RU8 ...\n", uLUN));
2284	rc = sb16AttachInternal(pDevIns, NULL /* pDrv /, uLUN, 0 / fFlags */);
2285	if (RT_FAILURE(rc))
2286	{
2287	if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2288	rc = VINF_SUCCESS;
2289	else if (rc == VERR_AUDIO_BACKEND_INIT_FAILED)
2290	{
2291	sb16Reattach(pThis, NULL /* pDrv */, uLUN, "NullAudio");
2292	PDMDevHlpVMSetRuntimeError(pDevIns, 0 /fFlags/, "HostAudioNotResponding",
2293	N_("No audio devices could be opened. Selecting the NULL audio backend "
2294	"with the consequence that no sound is audible"));
2295	/* attaching to the NULL audio backend will never fail */
2296	rc = VINF_SUCCESS;
2297	}
2298	break;
2299	}
2300	}
2301
2302	LogFunc(("cLUNs=%RU8, rc=%Rrc\n", uLUN, rc));
2303
2304	sb16ResetLegacy(pThis);
2305
2306	PSB16DRIVER pDrv;
2307	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
2308	{
2309	/*
2310	* Only primary drivers are critical for the VM to run. Everything else
2311	* might not worth showing an own error message box in the GUI.
2312	*/
2313	if (!(pDrv->Flags & PDMAUDIODRVFLAG_PRIMARY))
2314	continue;
2315
2316	PPDMIAUDIOCONNECTOR pCon = pDrv->pConnector;
2317	AssertPtr(pCon);
2318
2319	/* Note: No input streams available for SB16 yet. */
2320	bool fValidOut = pCon->pfnIsValidOut(pCon, pDrv->Out.pStrmOut);
2321	if (!fValidOut)
2322	{
2323	LogRel(("SB16: Falling back to NULL backend (no sound audible)\n"));
2324
2325	sb16ResetLegacy(pThis);
2326	sb16Reattach(pThis, pDrv, pDrv->uLUN, "NullAudio");
2327
2328	PDMDevHlpVMSetRuntimeError(pDevIns, 0 /fFlags/, "HostAudioNotResponding",
2329	N_("No audio devices could be opened. Selecting the NULL audio backend "
2330	"with the consequence that no sound is audible"));
2331	}
2332	}
2333
2334	#ifndef VBOX_WITH_AUDIO_CALLBACKS
2335	if (RT_SUCCESS(rc))
2336	{
2337	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16TimerIO, pThis,
2338	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "SB16 IO timer", &pThis->pTimerIO);
2339	if (RT_FAILURE(rc))
2340	AssertMsgFailedReturn(("Error creating I/O timer, rc=%Rrc\n", rc), rc);
2341	else
2342	{
2343	pThis->cTimerTicksIO = TMTimerGetFreq(pThis->pTimerIO) / uTimerHz;
2344	pThis->uTimerTSIO = TMTimerGet(pThis->pTimerIO);
2345	LogFunc(("Timer ticks=%RU64 (%RU16 Hz)\n", pThis->cTimerTicksIO, uTimerHz));
2346
2347	/* Fire off timer. */
2348	TMTimerSet(pThis->pTimerIO, TMTimerGet(pThis->pTimerIO) + pThis->cTimerTicksIO);
2349	}
2350	}
2351	#else
2352	if (RT_SUCCESS(rc))
2353	{
2354	/** @todo Merge this callback registration with the validation block above once
2355	* this becomes the standard. */
2356	PSB16DRIVER pDrv;
2357	RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
2358	{
2359	/* Only register primary driver.
2360	* The device emulation does the output multiplexing then. */
2361	if (pDrv->Flags != PDMAUDIODRVFLAG_PRIMARY)
2362	continue;
2363
2364	PDMAUDIOCALLBACK AudioCallbacks[2];
2365
2366	SB16CALLBACKCTX Ctx = { pThis, pDrv };
2367
2368	AudioCallbacks[0].enmType = PDMAUDIOCALLBACKTYPE_INPUT;
2369	AudioCallbacks[0].pfnCallback = sb16CallbackInput;
2370	AudioCallbacks[0].pvCtx = &Ctx;
2371	AudioCallbacks[0].cbCtx = sizeof(SB16CALLBACKCTX);
2372
2373	AudioCallbacks[1].enmType = PDMAUDIOCALLBACKTYPE_OUTPUT;
2374	AudioCallbacks[1].pfnCallback = sb16CallbackOutput;
2375	AudioCallbacks[1].pvCtx = &Ctx;
2376	AudioCallbacks[1].cbCtx = sizeof(SB16CALLBACKCTX);
2377
2378	rc = pDrv->pConnector->pfnRegisterCallbacks(pDrv->pConnector, AudioCallbacks, RT_ELEMENTS(AudioCallbacks));
2379	if (RT_FAILURE(rc))
2380	break;
2381	}
2382	}
2383	#endif
2384
2385	return VINF_SUCCESS;
2386	}
2387
2388	const PDMDEVREG g_DeviceSB16 =
2389	{
2390	/* u32Version */
2391	PDM_DEVREG_VERSION,
2392	/* szName */
2393	"sb16",
2394	/* szRCMod */
2395	"",
2396	/* szR0Mod */
2397	"",
2398	/* pszDescription */
2399	"Sound Blaster 16 Controller",
2400	/* fFlags */
2401	PDM_DEVREG_FLAGS_DEFAULT_BITS,
2402	/* fClass */
2403	PDM_DEVREG_CLASS_AUDIO,
2404	/* cMaxInstances */
2405	1,
2406	/* cbInstance */
2407	sizeof(SB16STATE),
2408	/* pfnConstruct */
2409	sb16Construct,
2410	/* pfnDestruct */
2411	sb16Destruct,
2412	/* pfnRelocate */
2413	NULL,
2414	/* pfnMemSetup */
2415	NULL,
2416	/* pfnPowerOn */
2417	NULL,
2418	/* pfnReset */
2419	sb16DevReset,
2420	/* pfnSuspend */
2421	NULL,
2422	/* pfnResume */
2423	NULL,
2424	/* pfnAttach */
2425	sb16Attach,
2426	/* pfnDetach */
2427	sb16Detach,
2428	/* pfnQueryInterface */
2429	NULL,
2430	/* pfnInitComplete */
2431	NULL,
2432	/* pfnPowerOff */
2433	NULL,
2434	/* pfnSoftReset */
2435	NULL,
2436	/* u32VersionEnd */
2437	PDM_DEVREG_VERSION
2438	};

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

source: vbox/trunk/src/VBox/Devices/Audio_old/DevSB16.cpp@ 61497

Download in other formats: