DevSB16.cpp@ 44582

Last change on this file since 44582 was 39308, checked in by vboxsync, 13 years ago
SB16: Improved mixer volume handling.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 51.1 KB

Line
1	/* $Id: DevSB16.cpp 39308 2011-11-15 13:48:17Z vboxsync $ */
2	/** @file
3	* DevSB16 - VBox SB16 Audio Controller.
4	*
5	* (r3917 sb16.c)
6	*
7	* @todo hiccups on NT4 and Win98.
8	*/
9
10	/*
11	* QEMU Soundblaster 16 emulation
12	*
13	* Copyright (c) 2003-2005 Vassili Karpov (malc)
14	*
15	* Permission is hereby granted, free of charge, to any person obtaining a copy
16	* of this software and associated documentation files (the "Software"), to deal
17	* in the Software without restriction, including without limitation the rights
18	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
19	* copies of the Software, and to permit persons to whom the Software is
20	* furnished to do so, subject to the following conditions:
21	*
22	* The above copyright notice and this permission notice shall be included in
23	* all copies or substantial portions of the Software.
24	*
25	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
26	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
28	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
29	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
30	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
31	* THE SOFTWARE.
32	*/
33
34	#define LOG_GROUP LOG_GROUP_DEV_AUDIO
35	#include <VBox/vmm/pdmdev.h>
36	#include <iprt/assert.h>
37	#include <iprt/string.h>
38	#include <iprt/uuid.h>
39	#include "vl_vbox.h"
40
41	extern "C" {
42	#include "audio.h"
43	}
44
45	#ifndef VBOX
46
47	#define LENOFA(a) ((int) (sizeof(a)/sizeof(a[0])))
48
49	#define dolog(...) AUD_log ("sb16", __VA_ARGS__)
50
51	/* #define DEBUG */
52	/* #define DEBUG_SB16_MOST */
53
54	#ifdef DEBUG
55	#define ldebug(...) dolog (__VA_ARGS__)
56	#else
57	#define ldebug(...)
58	#endif
59
60	#else /* VBOX */
61
62	/** Current saved state version. */
63	#define SB16_SAVE_STATE_VERSION 2
64	/** The version used in VirtualBox version 3.0 and earlier. This didn't include
65	* the config dump. */
66	#define SB16_SAVE_STATE_VERSION_VBOX_30 1
67
68	DECLINLINE(void) dolog (const char *fmt, ...)
69	{
70	va_list ap;
71	va_start (ap, fmt);
72	AUD_vlog ("sb16", fmt, ap);
73	va_end (ap);
74	}
75
76	# ifdef DEBUG
77	static void ldebug (const char *fmt, ...)
78	{
79	va_list ap;
80
81	va_start (ap, fmt);
82	AUD_vlog ("sb16", fmt, ap);
83	va_end (ap);
84	}
85	# else
86	DECLINLINE(void) ldebug (const char *fmt, ...)
87	{
88	(void)fmt;
89	}
90	# endif
91
92	#endif /* VBOX */
93
94	#ifndef VBOX
95	#define IO_READ_PROTO(name) \
96	uint32_t name (void *opaque, uint32_t nport)
97	#define IO_WRITE_PROTO(name) \
98	void name (void *opaque, uint32_t nport, uint32_t val)
99	#else /* VBOX */
100	#define IO_READ_PROTO(name) \
101	DECLCALLBACK(int) name (PPDMDEVINS pDevIns, void *opaque, \
102	RTIOPORT nport, uint32_t *pu32, unsigned cb)
103
104	#define IO_WRITE_PROTO(name) \
105	DECLCALLBACK(int) name (PPDMDEVINS pDevIns, void *opaque, \
106	RTIOPORT nport, uint32_t val, unsigned cb)
107	#endif /* VBOX */
108
109	static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
110
111	#ifndef VBOX
112	static struct {
113	int ver_lo;
114	int ver_hi;
115	int irq;
116	int dma;
117	int hdma;
118	int port;
119	} conf = {5, 4, 5, 1, 5, 0x220};
120	#endif /* !VBOX */
121
122	typedef struct SB16State {
123	#ifdef VBOX
124	PPDMDEVINSR3 pDevIns;
125	#endif
126	QEMUSoundCard card;
127	#ifndef VBOX
128	qemu_irq *pic;
129	#endif
130	#ifdef VBOX /* lazy bird */
131	int irqCfg;
132	int dmaCfg;
133	int hdmaCfg;
134	int portCfg;
135	int verCfg;
136	#endif
137	int irq;
138	int dma;
139	int hdma;
140	int port;
141	int ver;
142
143	int in_index;
144	int out_data_len;
145	int fmt_stereo;
146	int fmt_signed;
147	int fmt_bits;
148	audfmt_e fmt;
149	int dma_auto;
150	int block_size;
151	int fifo;
152	int freq;
153	int time_const;
154	int speaker;
155	int needed_bytes;
156	int cmd;
157	int use_hdma;
158	int highspeed;
159	int can_write;
160
161	int v2x6;
162
163	uint8_t csp_param;
164	uint8_t csp_value;
165	uint8_t csp_mode;
166	uint8_t csp_regs[256];
167	uint8_t csp_index;
168	uint8_t csp_reg83[4];
169	int csp_reg83r;
170	int csp_reg83w;
171
172	uint8_t in2_data[10];
173	uint8_t out_data[50];
174	uint8_t test_reg;
175	uint8_t last_read_byte;
176	int nzero;
177
178	int left_till_irq;
179
180	int dma_running;
181	int bytes_per_second;
182	int align;
183	int audio_free;
184	SWVoiceOut *voice;
185
186	#ifndef VBOX
187	QEMUTimer *aux_ts;
188	#else
189	PTMTIMER pTimer;
190	PPDMIBASE pDrvBase;
191	/** LUN\#0: Base interface. */
192	PDMIBASE IBase;
193	#endif
194	/* mixer state */
195	int mixer_nreg;
196	uint8_t mixer_regs[256];
197	} SB16State;
198
199	static void SB_audio_callback (void *opaque, int free);
200
201	static int magic_of_irq (int irq)
202	{
203	switch (irq) {
204	case 5:
205	return 2;
206	case 7:
207	return 4;
208	case 9:
209	return 1;
210	case 10:
211	return 8;
212	default:
213	dolog ("bad irq %d\n", irq);
214	return 2;
215	}
216	}
217
218	static int irq_of_magic (int magic)
219	{
220	switch (magic) {
221	case 1:
222	return 9;
223	case 2:
224	return 5;
225	case 4:
226	return 7;
227	case 8:
228	return 10;
229	default:
230	dolog ("bad irq magic %d\n", magic);
231	return -1;
232	}
233	}
234
235	#if 0
236	static void log_dsp (SB16State *dsp)
237	{
238	ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
239	dsp->fmt_stereo ? "Stereo" : "Mono",
240	dsp->fmt_signed ? "Signed" : "Unsigned",
241	dsp->fmt_bits,
242	dsp->dma_auto ? "Auto" : "Single",
243	dsp->block_size,
244	dsp->freq,
245	dsp->time_const,
246	dsp->speaker);
247	}
248	#endif
249
250	static void speaker (SB16State *s, int on)
251	{
252	s->speaker = on;
253	/* AUD_enable (s->voice, on); */
254	}
255
256	static void control (SB16State *s, int hold)
257	{
258	int dma = s->use_hdma ? s->hdma : s->dma;
259	s->dma_running = hold;
260
261	ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);
262
263	#ifndef VBOX
264	if (hold) {
265	DMA_hold_DREQ (dma);
266	AUD_set_active_out (s->voice, 1);
267	}
268	else {
269	DMA_release_DREQ (dma);
270	AUD_set_active_out (s->voice, 0);
271	}
272	#else /* VBOX */
273	if (hold)
274	{
275	PDMDevHlpDMASetDREQ (s->pDevIns, dma, 1);
276	PDMDevHlpDMASchedule (s->pDevIns);
277	AUD_set_active_out (s->voice, 1);
278	}
279	else
280	{
281	PDMDevHlpDMASetDREQ (s->pDevIns, dma, 0);
282	AUD_set_active_out (s->voice, 0);
283	}
284	#endif /* VBOX */
285	}
286
287	#ifndef VBOX
288	static void aux_timer (void *opaque)
289	{
290	SB16State *s = opaque;
291	s->can_write = 1;
292	qemu_irq_raise (s->pic[s->irq]);
293	}
294	#else /* VBOX */
295	static DECLCALLBACK(void) sb16Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvThis)
296	{
297	SB16State s = (SB16State )pvThis;
298	s->can_write = 1;
299	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 1);
300	}
301	#endif /* VBOX */
302
303	#define DMA8_AUTO 1
304	#define DMA8_HIGH 2
305
306	static void continue_dma8 (SB16State *s)
307	{
308	if (s->freq > 0) {
309	audsettings_t as;
310
311	s->audio_free = 0;
312
313	as.freq = s->freq;
314	as.nchannels = 1 << s->fmt_stereo;
315	as.fmt = s->fmt;
316	as.endianness = 0;
317
318	s->voice = AUD_open_out (
319	&s->card,
320	s->voice,
321	"sb16",
322	s,
323	SB_audio_callback,
324	&as
325	);
326	}
327
328	control (s, 1);
329	}
330
331	static void dma_cmd8 (SB16State *s, int mask, int dma_len)
332	{
333	s->fmt = AUD_FMT_U8;
334	s->use_hdma = 0;
335	s->fmt_bits = 8;
336	s->fmt_signed = 0;
337	s->fmt_stereo = (s->mixer_regs[0x0e] & 2) != 0;
338	if (-1 == s->time_const) {
339	if (s->freq <= 0)
340	s->freq = 11025;
341	}
342	else {
343	int tmp = (256 - s->time_const);
344	s->freq = (1000000 + (tmp / 2)) / tmp;
345	}
346
347	if (dma_len != -1) {
348	s->block_size = dma_len << s->fmt_stereo;
349	}
350	else {
351	/* This is apparently the only way to make both Act1/PL
352	and SecondReality/FC work
353
354	Act1 sets block size via command 0x48 and it's an odd number
355	SR does the same with even number
356	Both use stereo, and Creatives own documentation states that
357	0x48 sets block size in bytes less one.. go figure */
358	s->block_size &= ~s->fmt_stereo;
359	}
360
361	s->freq >>= s->fmt_stereo;
362	s->left_till_irq = s->block_size;
363	s->bytes_per_second = (s->freq << s->fmt_stereo);
364	/* s->highspeed = (mask & DMA8_HIGH) != 0; */
365	s->dma_auto = (mask & DMA8_AUTO) != 0;
366	s->align = (1 << s->fmt_stereo) - 1;
367
368	if (s->block_size & s->align) {
369	dolog ("warning: misaligned block size %d, alignment %d\n",
370	s->block_size, s->align + 1);
371	}
372
373	ldebug ("freq %d, stereo %d, sign %d, bits %d, "
374	"dma %d, auto %d, fifo %d, high %d\n",
375	s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
376	s->block_size, s->dma_auto, s->fifo, s->highspeed);
377
378	continue_dma8 (s);
379	speaker (s, 1);
380	}
381
382	static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len)
383	{
384	s->use_hdma = cmd < 0xc0;
385	s->fifo = (cmd >> 1) & 1;
386	s->dma_auto = (cmd >> 2) & 1;
387	s->fmt_signed = (d0 >> 4) & 1;
388	s->fmt_stereo = (d0 >> 5) & 1;
389
390	switch (cmd >> 4) {
391	case 11:
392	s->fmt_bits = 16;
393	break;
394
395	case 12:
396	s->fmt_bits = 8;
397	break;
398	}
399
400	if (-1 != s->time_const) {
401	#if 1
402	int tmp = 256 - s->time_const;
403	s->freq = (1000000 + (tmp / 2)) / tmp;
404	#else
405	/* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */
406	s->freq = 1000000 / ((255 - s->time_const));
407	#endif
408	s->time_const = -1;
409	}
410
411	s->block_size = dma_len + 1;
412	s->block_size <<= ((s->fmt_bits == 16) ? 1 : 0);
413	if (!s->dma_auto) {
414	/* It is clear that for DOOM and auto-init this value
415	shouldn't take stereo into account, while Miles Sound Systems
416	setsound.exe with single transfer mode wouldn't work without it
417	wonders of SB16 yet again */
418	s->block_size <<= s->fmt_stereo;
419	}
420
421	ldebug ("freq %d, stereo %d, sign %d, bits %d, "
422	"dma %d, auto %d, fifo %d, high %d\n",
423	s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
424	s->block_size, s->dma_auto, s->fifo, s->highspeed);
425
426	if (16 == s->fmt_bits) {
427	if (s->fmt_signed) {
428	s->fmt = AUD_FMT_S16;
429	}
430	else {
431	s->fmt = AUD_FMT_U16;
432	}
433	}
434	else {
435	if (s->fmt_signed) {
436	s->fmt = AUD_FMT_S8;
437	}
438	else {
439	s->fmt = AUD_FMT_U8;
440	}
441	}
442
443	s->left_till_irq = s->block_size;
444
445	s->bytes_per_second = (s->freq << s->fmt_stereo) << ((s->fmt_bits == 16) ? 1 : 0);
446	s->highspeed = 0;
447	s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;
448	if (s->block_size & s->align) {
449	dolog ("warning: misaligned block size %d, alignment %d\n",
450	s->block_size, s->align + 1);
451	}
452
453	if (s->freq) {
454	audsettings_t as;
455
456	s->audio_free = 0;
457
458	as.freq = s->freq;
459	as.nchannels = 1 << s->fmt_stereo;
460	as.fmt = s->fmt;
461	as.endianness = 0;
462
463	s->voice = AUD_open_out (
464	&s->card,
465	s->voice,
466	"sb16",
467	s,
468	SB_audio_callback,
469	&as
470	);
471	}
472
473	control (s, 1);
474	speaker (s, 1);
475	}
476
477	static inline void dsp_out_data (SB16State *s, uint8_t val)
478	{
479	ldebug ("outdata %#x\n", val);
480	if ((size_t) s->out_data_len < sizeof (s->out_data)) {
481	s->out_data[s->out_data_len++] = val;
482	}
483	}
484
485	static inline uint8_t dsp_get_data (SB16State *s)
486	{
487	if (s->in_index) {
488	return s->in2_data[--s->in_index];
489	}
490	else {
491	dolog ("buffer underflow\n");
492	return 0;
493	}
494	}
495
496	static void command (SB16State *s, uint8_t cmd)
497	{
498	ldebug ("command %#x\n", cmd);
499
500	if (cmd > 0xaf && cmd < 0xd0) {
501	if (cmd & 8) {
502	dolog ("ADC not yet supported (command %#x)\n", cmd);
503	}
504
505	switch (cmd >> 4) {
506	case 11:
507	case 12:
508	break;
509	default:
510	dolog ("%#x wrong bits\n", cmd);
511	}
512	s->needed_bytes = 3;
513	}
514	else {
515	s->needed_bytes = 0;
516
517	switch (cmd) {
518	case 0x03:
519	dsp_out_data (s, 0x10); /* s->csp_param); */
520	goto warn;
521
522	case 0x04:
523	s->needed_bytes = 1;
524	goto warn;
525
526	case 0x05:
527	s->needed_bytes = 2;
528	goto warn;
529
530	case 0x08:
531	/* __asm__ ("int3"); */
532	goto warn;
533
534	case 0x0e:
535	s->needed_bytes = 2;
536	goto warn;
537
538	case 0x09:
539	dsp_out_data (s, 0xf8);
540	goto warn;
541
542	case 0x0f:
543	s->needed_bytes = 1;
544	goto warn;
545
546	case 0x10:
547	s->needed_bytes = 1;
548	goto warn;
549
550	case 0x14:
551	s->needed_bytes = 2;
552	s->block_size = 0;
553	break;
554
555	case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
556	dma_cmd8 (s, DMA8_AUTO, -1);
557	break;
558
559	case 0x20: /* Direct ADC, Juice/PL */
560	dsp_out_data (s, 0xff);
561	goto warn;
562
563	case 0x35:
564	dolog ("0x35 - MIDI command not implemented\n");
565	break;
566
567	case 0x40:
568	s->freq = -1;
569	s->time_const = -1;
570	s->needed_bytes = 1;
571	break;
572
573	case 0x41:
574	s->freq = -1;
575	s->time_const = -1;
576	s->needed_bytes = 2;
577	break;
578
579	case 0x42:
580	s->freq = -1;
581	s->time_const = -1;
582	s->needed_bytes = 2;
583	goto warn;
584
585	case 0x45:
586	dsp_out_data (s, 0xaa);
587	goto warn;
588
589	case 0x47: /* Continue Auto-Initialize DMA 16bit */
590	break;
591
592	case 0x48:
593	s->needed_bytes = 2;
594	break;
595
596	case 0x74:
597	s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */
598	dolog ("0x75 - DMA DAC, 4-bit ADPCM not implemented\n");
599	break;
600
601	case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
602	s->needed_bytes = 2;
603	dolog ("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n");
604	break;
605
606	case 0x76: /* DMA DAC, 2.6-bit ADPCM */
607	s->needed_bytes = 2;
608	dolog ("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n");
609	break;
610
611	case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
612	s->needed_bytes = 2;
613	dolog ("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n");
614	break;
615
616	case 0x7d:
617	dolog ("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n");
618	dolog ("not implemented\n");
619	break;
620
621	case 0x7f:
622	dolog (
623	"0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"
624	);
625	dolog ("not implemented\n");
626	break;
627
628	case 0x80:
629	s->needed_bytes = 2;
630	break;
631
632	case 0x90:
633	case 0x91:
634	dma_cmd8 (s, (((cmd & 1) == 0) ? 1 : 0) \| DMA8_HIGH, -1);
635	break;
636
637	case 0xd0: /* halt DMA operation. 8bit */
638	control (s, 0);
639	break;
640
641	case 0xd1: /* speaker on */
642	speaker (s, 1);
643	break;
644
645	case 0xd3: /* speaker off */
646	speaker (s, 0);
647	break;
648
649	case 0xd4: /* continue DMA operation. 8bit */
650	/* KQ6 (or maybe Sierras audblst.drv in general) resets
651	the frequency between halt/continue */
652	continue_dma8 (s);
653	break;
654
655	case 0xd5: /* halt DMA operation. 16bit */
656	control (s, 0);
657	break;
658
659	case 0xd6: /* continue DMA operation. 16bit */
660	control (s, 1);
661	break;
662
663	case 0xd9: /* exit auto-init DMA after this block. 16bit */
664	s->dma_auto = 0;
665	break;
666
667	case 0xda: /* exit auto-init DMA after this block. 8bit */
668	s->dma_auto = 0;
669	break;
670
671	case 0xe0: /* DSP identification */
672	s->needed_bytes = 1;
673	break;
674
675	case 0xe1:
676	dsp_out_data (s, s->ver & 0xff);
677	dsp_out_data (s, s->ver >> 8);
678	break;
679
680	case 0xe2:
681	s->needed_bytes = 1;
682	goto warn;
683
684	case 0xe3:
685	{
686	int i;
687	for (i = sizeof (e3) - 1; i >= 0; --i)
688	dsp_out_data (s, e3[i]);
689	}
690	break;
691
692	case 0xe4: /* write test reg */
693	s->needed_bytes = 1;
694	break;
695
696	case 0xe7:
697	dolog ("Attempt to probe for ESS (0xe7)?\n");
698	break;
699
700	case 0xe8: /* read test reg */
701	dsp_out_data (s, s->test_reg);
702	break;
703
704	case 0xf2:
705	case 0xf3:
706	dsp_out_data (s, 0xaa);
707	s->mixer_regs[0x82] \|= (cmd == 0xf2) ? 1 : 2;
708	#ifndef VBOX
709	qemu_irq_raise (s->pic[s->irq]);
710	#else
711	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 1);
712	#endif
713	break;
714
715	case 0xf9:
716	s->needed_bytes = 1;
717	goto warn;
718
719	case 0xfa:
720	dsp_out_data (s, 0);
721	goto warn;
722
723	case 0xfc: /* FIXME */
724	dsp_out_data (s, 0);
725	goto warn;
726
727	default:
728	dolog ("Unrecognized command %#x\n", cmd);
729	break;
730	}
731	}
732
733	if (!s->needed_bytes) {
734	ldebug ("\n");
735	}
736
737	exit:
738	if (!s->needed_bytes) {
739	s->cmd = -1;
740	}
741	else {
742	s->cmd = cmd;
743	}
744	return;
745
746	warn:
747	dolog ("warning: command %#x,%d is not truly understood yet\n",
748	cmd, s->needed_bytes);
749	goto exit;
750
751	}
752
753	static uint16_t dsp_get_lohi (SB16State *s)
754	{
755	uint8_t hi = dsp_get_data (s);
756	uint8_t lo = dsp_get_data (s);
757	return (hi << 8) \| lo;
758	}
759
760	static uint16_t dsp_get_hilo (SB16State *s)
761	{
762	uint8_t lo = dsp_get_data (s);
763	uint8_t hi = dsp_get_data (s);
764	return (hi << 8) \| lo;
765	}
766
767	static void complete (SB16State *s)
768	{
769	int d0, d1, d2;
770	ldebug ("complete command %#x, in_index %d, needed_bytes %d\n",
771	s->cmd, s->in_index, s->needed_bytes);
772
773	if (s->cmd > 0xaf && s->cmd < 0xd0) {
774	d2 = dsp_get_data (s);
775	d1 = dsp_get_data (s);
776	d0 = dsp_get_data (s);
777
778	if (s->cmd & 8) {
779	dolog ("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
780	s->cmd, d0, d1, d2);
781	}
782	else {
783	ldebug ("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
784	s->cmd, d0, d1, d2);
785	dma_cmd (s, s->cmd, d0, d1 + (d2 << 8));
786	}
787	}
788	else {
789	switch (s->cmd) {
790	case 0x04:
791	s->csp_mode = dsp_get_data (s);
792	s->csp_reg83r = 0;
793	s->csp_reg83w = 0;
794	ldebug ("CSP command 0x04: mode=%#x\n", s->csp_mode);
795	break;
796
797	case 0x05:
798	s->csp_param = dsp_get_data (s);
799	s->csp_value = dsp_get_data (s);
800	ldebug ("CSP command 0x05: param=%#x value=%#x\n",
801	s->csp_param,
802	s->csp_value);
803	break;
804
805	case 0x0e:
806	d0 = dsp_get_data (s);
807	d1 = dsp_get_data (s);
808	ldebug ("write CSP register %d <- %#x\n", d1, d0);
809	if (d1 == 0x83) {
810	ldebug ("0x83[%d] <- %#x\n", s->csp_reg83r, d0);
811	s->csp_reg83[s->csp_reg83r % 4] = d0;
812	s->csp_reg83r += 1;
813	}
814	else {
815	s->csp_regs[d1] = d0;
816	}
817	break;
818
819	case 0x0f:
820	d0 = dsp_get_data (s);
821	ldebug ("read CSP register %#x -> %#x, mode=%#x\n",
822	d0, s->csp_regs[d0], s->csp_mode);
823	if (d0 == 0x83) {
824	ldebug ("0x83[%d] -> %#x\n",
825	s->csp_reg83w,
826	s->csp_reg83[s->csp_reg83w % 4]);
827	dsp_out_data (s, s->csp_reg83[s->csp_reg83w % 4]);
828	s->csp_reg83w += 1;
829	}
830	else {
831	dsp_out_data (s, s->csp_regs[d0]);
832	}
833	break;
834
835	case 0x10:
836	d0 = dsp_get_data (s);
837	dolog ("cmd 0x10 d0=%#x\n", d0);
838	break;
839
840	case 0x14:
841	dma_cmd8 (s, 0, dsp_get_lohi (s) + 1);
842	break;
843
844	case 0x40:
845	s->time_const = dsp_get_data (s);
846	ldebug ("set time const %d\n", s->time_const);
847	break;
848
849	case 0x42: /* FT2 sets output freq with this, go figure */
850	#if 0
851	dolog ("cmd 0x42 might not do what it think it should\n");
852	#endif
853	case 0x41:
854	s->freq = dsp_get_hilo (s);
855	ldebug ("set freq %d\n", s->freq);
856	break;
857
858	case 0x48:
859	s->block_size = dsp_get_lohi (s) + 1;
860	ldebug ("set dma block len %d\n", s->block_size);
861	break;
862
863	case 0x74:
864	case 0x75:
865	case 0x76:
866	case 0x77:
867	/* ADPCM stuff, ignore */
868	break;
869
870	case 0x80:
871	{
872	int freq, samples, bytes;
873	uint64_t ticks;
874
875	freq = s->freq > 0 ? s->freq : 11025;
876	samples = dsp_get_lohi (s) + 1;
877	bytes = samples << s->fmt_stereo << ((s->fmt_bits == 16) ? 1 : 0);
878	#ifndef VBOX
879	ticks = (bytes * ticks_per_sec) / freq;
880	if (ticks < ticks_per_sec / 1024) {
881	qemu_irq_raise (s->pic[s->irq]);
882	}
883	else {
884	if (s->aux_ts) {
885	qemu_mod_timer (
886	s->aux_ts,
887	qemu_get_clock (vm_clock) + ticks
888	);
889	}
890	}
891	ldebug ("mix silence %d %d %" PRId64 "\n", samples, bytes, ticks);
892	#else /* VBOX */
893	ticks = (bytes * TMTimerGetFreq(s->pTimer)) / freq;
894	if (ticks < TMTimerGetFreq(s->pTimer) / 1024)
895	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 1);
896	else
897	TMTimerSet(s->pTimer, TMTimerGet(s->pTimer) + ticks);
898	ldebug ("mix silence %d %d % %RU64\n", samples, bytes, ticks);
899	#endif /* VBOX */
900	}
901	break;
902
903	case 0xe0:
904	d0 = dsp_get_data (s);
905	s->out_data_len = 0;
906	ldebug ("E0 data = %#x\n", d0);
907	dsp_out_data (s, ~d0);
908	break;
909
910	case 0xe2:
911	d0 = dsp_get_data (s);
912	ldebug ("E2 = %#x\n", d0);
913	break;
914
915	case 0xe4:
916	s->test_reg = dsp_get_data (s);
917	break;
918
919	case 0xf9:
920	d0 = dsp_get_data (s);
921	ldebug ("command 0xf9 with %#x\n", d0);
922	switch (d0) {
923	case 0x0e:
924	dsp_out_data (s, 0xff);
925	break;
926
927	case 0x0f:
928	dsp_out_data (s, 0x07);
929	break;
930
931	case 0x37:
932	dsp_out_data (s, 0x38);
933	break;
934
935	default:
936	dsp_out_data (s, 0x00);
937	break;
938	}
939	break;
940
941	default:
942	dolog ("complete: unrecognized command %#x\n", s->cmd);
943	return;
944	}
945	}
946
947	ldebug ("\n");
948	s->cmd = -1;
949	return;
950	}
951
952	static void legacy_reset (SB16State *s)
953	{
954	audsettings_t as;
955
956	s->freq = 11025;
957	s->fmt_signed = 0;
958	s->fmt_bits = 8;
959	s->fmt_stereo = 0;
960
961	as.freq = s->freq;
962	as.nchannels = 1;
963	as.fmt = AUD_FMT_U8;
964	as.endianness = 0;
965
966	s->voice = AUD_open_out (
967	&s->card,
968	s->voice,
969	"sb16",
970	s,
971	SB_audio_callback,
972	&as
973	);
974
975	/* Not sure about that... */
976	/* AUD_set_active_out (s->voice, 1); */
977	}
978
979	static void reset (SB16State *s)
980	{
981	#ifndef VBOX
982	qemu_irq_lower (s->pic[s->irq]);
983	if (s->dma_auto) {
984	qemu_irq_raise (s->pic[s->irq]);
985	qemu_irq_lower (s->pic[s->irq]);
986	}
987	#else /* VBOX */
988	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 0);
989	if (s->dma_auto) {
990	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 1);
991	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 0);
992	}
993	#endif /* VBOX */
994
995	s->mixer_regs[0x82] = 0;
996	s->dma_auto = 0;
997	s->in_index = 0;
998	s->out_data_len = 0;
999	s->left_till_irq = 0;
1000	s->needed_bytes = 0;
1001	s->block_size = -1;
1002	s->nzero = 0;
1003	s->highspeed = 0;
1004	s->v2x6 = 0;
1005	s->cmd = -1;
1006
1007	dsp_out_data(s, 0xaa);
1008	speaker (s, 0);
1009	control (s, 0);
1010	legacy_reset (s);
1011	}
1012
1013	static IO_WRITE_PROTO (dsp_write)
1014	{
1015	SB16State s = (SB16State)opaque;
1016	int iport = nport - s->port;
1017
1018	ldebug ("write %#x <- %#x\n", nport, val);
1019	switch (iport) {
1020	case 0x06:
1021	switch (val) {
1022	case 0x00:
1023	if (s->v2x6 == 1) {
1024	if (0 && s->highspeed) {
1025	s->highspeed = 0;
1026	#ifndef VBOX
1027	qemu_irq_lower (s->pic[s->irq]);
1028	#else
1029	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 0);
1030	#endif
1031	control (s, 0);
1032	}
1033	else {
1034	reset (s);
1035	}
1036	}
1037	s->v2x6 = 0;
1038	break;
1039
1040	case 0x01:
1041	case 0x03: /* FreeBSD kludge */
1042	s->v2x6 = 1;
1043	break;
1044
1045	case 0xc6:
1046	s->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */
1047	break;
1048
1049	case 0xb8: /* Panic */
1050	reset (s);
1051	break;
1052
1053	case 0x39:
1054	dsp_out_data (s, 0x38);
1055	reset (s);
1056	s->v2x6 = 0x39;
1057	break;
1058
1059	default:
1060	s->v2x6 = val;
1061	break;
1062	}
1063	break;
1064
1065	case 0x0c: /* write data or command \| write status */
1066	/* if (s->highspeed) */
1067	/* break; */
1068
1069	if (0 == s->needed_bytes) {
1070	command (s, val);
1071	#if 0
1072	if (0 == s->needed_bytes) {
1073	log_dsp (s);
1074	}
1075	#endif
1076	}
1077	else {
1078	if (s->in_index == sizeof (s->in2_data)) {
1079	dolog ("in data overrun\n");
1080	}
1081	else {
1082	s->in2_data[s->in_index++] = val;
1083	if (s->in_index == s->needed_bytes) {
1084	s->needed_bytes = 0;
1085	complete (s);
1086	#if 0
1087	log_dsp (s);
1088	#endif
1089	}
1090	}
1091	}
1092	break;
1093
1094	default:
1095	ldebug ("(nport=%#x, val=%#x)\n", nport, val);
1096	break;
1097	}
1098
1099	#ifdef VBOX
1100	return VINF_SUCCESS;
1101	#endif
1102	}
1103
1104	static IO_READ_PROTO (dsp_read)
1105	{
1106	SB16State s = (SB16State)opaque;
1107	int iport, retval, ack = 0;
1108
1109	iport = nport - s->port;
1110	#ifdef VBOX
1111	/** @todo reject non-byte access?
1112	* The spec does not mention a non-byte access so we should check how real hardware behaves. */
1113	#endif
1114
1115	switch (iport) {
1116	case 0x06: /* reset */
1117	retval = 0xff;
1118	break;
1119
1120	case 0x0a: /* read data */
1121	if (s->out_data_len) {
1122	retval = s->out_data[--s->out_data_len];
1123	s->last_read_byte = retval;
1124	}
1125	else {
1126	if (s->cmd != -1) {
1127	dolog ("empty output buffer for command %#x\n",
1128	s->cmd);
1129	}
1130	retval = s->last_read_byte;
1131	/* goto error; */
1132	}
1133	break;
1134
1135	case 0x0c: /* 0 can write */
1136	retval = s->can_write ? 0 : 0x80;
1137	break;
1138
1139	case 0x0d: /* timer interrupt clear */
1140	/* dolog ("timer interrupt clear\n"); */
1141	retval = 0;
1142	break;
1143
1144	case 0x0e: /* data available status \| irq 8 ack */
1145	retval = (!s->out_data_len \|\| s->highspeed) ? 0 : 0x80;
1146	if (s->mixer_regs[0x82] & 1) {
1147	ack = 1;
1148	s->mixer_regs[0x82] &= 1;
1149	#ifndef VBOX
1150	qemu_irq_lower (s->pic[s->irq]);
1151	#else
1152	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 0);
1153	#endif
1154	}
1155	break;
1156
1157	case 0x0f: /* irq 16 ack */
1158	retval = 0xff;
1159	if (s->mixer_regs[0x82] & 2) {
1160	ack = 1;
1161	s->mixer_regs[0x82] &= 2;
1162	#ifndef VBOX
1163	qemu_irq_lower (s->pic[s->irq]);
1164	#else
1165	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 0);
1166	#endif
1167	}
1168	break;
1169
1170	default:
1171	goto error;
1172	}
1173
1174	if (!ack) {
1175	ldebug ("read %#x -> %#x\n", nport, retval);
1176	}
1177
1178	#ifndef VBOX
1179	return retval;
1180	#else
1181	*pu32 = retval;
1182	return VINF_SUCCESS;
1183	#endif
1184
1185	error:
1186	dolog ("warning: dsp_read %#x error\n", nport);
1187	#ifndef VBOX
1188	return 0xff;
1189	#else
1190	return VERR_IOM_IOPORT_UNUSED;
1191	#endif
1192	}
1193
1194	static void reset_mixer (SB16State *s)
1195	{
1196	int i;
1197
1198	memset (s->mixer_regs, 0xff, 0x7f);
1199	memset (s->mixer_regs + 0x83, 0xff, sizeof (s->mixer_regs) - 0x83);
1200
1201	s->mixer_regs[0x02] = 4; /* master volume 3bits */
1202	s->mixer_regs[0x06] = 4; /* MIDI volume 3bits */
1203	s->mixer_regs[0x08] = 0; /* CD volume 3bits */
1204	s->mixer_regs[0x0a] = 0; /* voice volume 2bits */
1205
1206	/* d5=input filt, d3=lowpass filt, d1,d2=input source */
1207	s->mixer_regs[0x0c] = 0;
1208
1209	/* d5=output filt, d1=stereo switch */
1210	s->mixer_regs[0x0e] = 0;
1211
1212	/* voice volume L d5,d7, R d1,d3 */
1213	s->mixer_regs[0x04] = (4 << 5) \| (4 << 1);
1214	/* master ... */
1215	s->mixer_regs[0x22] = (4 << 5) \| (4 << 1);
1216	/* MIDI ... */
1217	s->mixer_regs[0x26] = (4 << 5) \| (4 << 1);
1218
1219	for (i = 0x30; i < 0x48; i++) {
1220	s->mixer_regs[i] = 0x20;
1221	}
1222	}
1223
1224	static IO_WRITE_PROTO(mixer_write_indexb)
1225	{
1226	SB16State s = (SB16State)opaque;
1227	(void) nport;
1228	s->mixer_nreg = val;
1229
1230	#ifdef VBOX
1231	return VINF_SUCCESS;
1232	#endif
1233	}
1234
1235	static IO_WRITE_PROTO(mixer_write_datab)
1236	{
1237	SB16State s = (SB16State)opaque;
1238	bool update_master = false;
1239	bool update_voice = false;
1240
1241	(void) nport;
1242	ldebug ("mixer_write [%#x] <- %#x\n", s->mixer_nreg, val);
1243
1244	switch (s->mixer_nreg) {
1245	case 0x00:
1246	reset_mixer(s);
1247	/* And update the actual volume, too. */
1248	update_master = true;
1249	update_voice = true;
1250	break;
1251
1252	case 0x04:
1253	/* Translate from old style voice volume (L/R). */
1254	s->mixer_regs[0x32] = val & 0xff;
1255	s->mixer_regs[0x33] = val << 4;
1256	update_voice = true;
1257	break;
1258
1259	case 0x22:
1260	/* Translate from old style master volume (L/R). */
1261	s->mixer_regs[0x30] = val & 0xff;
1262	s->mixer_regs[0x31] = val << 4;
1263	update_master = true;
1264	break;
1265
1266	case 0x30:
1267	/* Translate to old style master volume (L). */
1268	s->mixer_regs[0x22] = (s->mixer_regs[0x22] & 0x0f) \| val;
1269	update_master = true;
1270	break;
1271
1272	case 0x31:
1273	/* Translate to old style master volume (R). */
1274	s->mixer_regs[0x22] = (s->mixer_regs[0x22] & 0xf0) \| (val >> 4);
1275	update_master = true;
1276	break;
1277
1278	case 0x32:
1279	/* Translate to old style voice volume (L). */
1280	s->mixer_regs[0x04] = (s->mixer_regs[0x04] & 0x0f) \| val;
1281	update_voice = true;
1282	break;
1283
1284	case 0x33:
1285	/* Translate to old style voice volume (R). */
1286	s->mixer_regs[0x04] = (s->mixer_regs[0x04] & 0xf0) \| (val >> 4);
1287	update_voice = true;
1288	break;
1289
1290	case 0x80:
1291	{
1292	int irq = irq_of_magic (val);
1293	ldebug ("setting irq to %d (val=%#x)\n", irq, val);
1294	if (irq > 0) {
1295	s->irq = irq;
1296	}
1297	}
1298	break;
1299
1300	case 0x81:
1301	{
1302	int dma, hdma;
1303
1304	dma = lsbindex (val & 0xf);
1305	hdma = lsbindex (val & 0xf0);
1306	if (dma != s->dma \|\| hdma != s->hdma) {
1307	dolog (
1308	"attempt to change DMA "
1309	"8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
1310	dma, s->dma, hdma, s->hdma, val);
1311	}
1312	#if 0
1313	s->dma = dma;
1314	s->hdma = hdma;
1315	#endif
1316	}
1317	break;
1318
1319	case 0x82:
1320	dolog ("attempt to write into IRQ status register (val=%#x)\n",
1321	val);
1322	#ifdef VBOX
1323	return VINF_SUCCESS;
1324	#endif
1325
1326	default:
1327	if (s->mixer_nreg >= 0x80) {
1328	ldebug ("attempt to write mixer[%#x] <- %#x\n", s->mixer_nreg, val);
1329	}
1330	break;
1331	}
1332
1333	s->mixer_regs[s->mixer_nreg] = val;
1334
1335	#ifdef VBOX
1336	/* Update the master (mixer) volume. */
1337	if (update_master)
1338	{
1339	int mute = 0;
1340	uint8_t lvol = s->mixer_regs[0x30];
1341	uint8_t rvol = s->mixer_regs[0x31];
1342	AUD_set_volume(AUD_MIXER_VOLUME, &mute, &lvol, &rvol);
1343	}
1344	/* Update the voice (PCM) volume. */
1345	if (update_voice)
1346	{
1347	int mute = 0;
1348	uint8_t lvol = s->mixer_regs[0x32];
1349	uint8_t rvol = s->mixer_regs[0x33];
1350	AUD_set_volume(AUD_MIXER_PCM, &mute, &lvol, &rvol);
1351	}
1352	#endif /* VBOX */
1353
1354	#ifdef VBOX
1355	return VINF_SUCCESS;
1356	#endif
1357	}
1358
1359	static IO_WRITE_PROTO(mixer_write)
1360	{
1361	#ifndef VBOX
1362	mixer_write_indexb (opaque, nport, val & 0xff);
1363	mixer_write_datab (opaque, nport, (val >> 8) & 0xff);
1364	#else /* VBOX */
1365	SB16State s = (SB16State)opaque;
1366	int iport = nport - s->port;
1367	switch (cb)
1368	{
1369	case 1:
1370	switch (iport)
1371	{
1372	case 4:
1373	mixer_write_indexb (pDevIns, opaque, nport, val, 1);
1374	break;
1375	case 5:
1376	mixer_write_datab (pDevIns, opaque, nport, val, 1);
1377	break;
1378	}
1379	break;
1380	case 2:
1381	mixer_write_indexb (pDevIns, opaque, nport, val & 0xff, 1);
1382	mixer_write_datab (pDevIns, opaque, nport, (val >> 8) & 0xff, 1);
1383	break;
1384	default:
1385	AssertMsgFailed(("Port=%#x cb=%d u32=%#x\n", nport, cb, val));
1386	break;
1387	}
1388	return VINF_SUCCESS;
1389	#endif /* VBOX */
1390	}
1391
1392	static IO_READ_PROTO(mixer_read)
1393	{
1394	SB16State s = (SB16State)opaque;
1395
1396	(void) nport;
1397	#ifndef DEBUG_SB16_MOST
1398	if (s->mixer_nreg != 0x82) {
1399	ldebug ("mixer_read[%#x] -> %#x\n",
1400	s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1401	}
1402	#else
1403	ldebug ("mixer_read[%#x] -> %#x\n",
1404	s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1405	#endif
1406	#ifndef VBOX
1407	return s->mixer_regs[s->mixer_nreg];
1408	#else
1409	*pu32 = s->mixer_regs[s->mixer_nreg];
1410	return VINF_SUCCESS;
1411	#endif
1412	}
1413
1414	static int write_audio (SB16State *s, int nchan, int dma_pos,
1415	int dma_len, int len)
1416	{
1417	int temp, net;
1418	uint8_t tmpbuf[4096];
1419
1420	temp = len;
1421	net = 0;
1422
1423	while (temp) {
1424	int left = dma_len - dma_pos;
1425	#ifndef VBOX
1426	int copied;
1427	size_t to_copy;
1428	#else
1429	uint32_t copied;
1430	uint32_t to_copy;
1431	#endif
1432
1433	to_copy = audio_MIN (temp, left);
1434	if (to_copy > sizeof (tmpbuf)) {
1435	to_copy = sizeof (tmpbuf);
1436	}
1437
1438	#ifndef VBOX
1439	copied = DMA_read_memory (nchan, tmpbuf, dma_pos, to_copy);
1440	#else
1441	int rc = PDMDevHlpDMAReadMemory(s->pDevIns, nchan, tmpbuf, dma_pos,
1442	to_copy, &copied);
1443	AssertMsgRC (rc, ("DMAReadMemory -> %Rrc\n", rc));
1444	#endif
1445
1446	copied = AUD_write (s->voice, tmpbuf, copied);
1447
1448	temp -= copied;
1449	dma_pos = (dma_pos + copied) % dma_len;
1450	net += copied;
1451
1452	if (!copied) {
1453	break;
1454	}
1455	}
1456
1457	return net;
1458	}
1459
1460	#ifndef VBOX
1461	static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
1462	#else
1463	static DECLCALLBACK(uint32_t) SB_read_DMA (PPDMDEVINS pDevIns, void *opaque, unsigned nchan, uint32_t dma_pos, uint32_t dma_len)
1464	#endif
1465	{
1466	SB16State s = (SB16State)opaque;
1467	int till, copy, written, free;
1468
1469	if (s->block_size <= 0) {
1470	dolog ("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
1471	s->block_size, nchan, dma_pos, dma_len);
1472	return dma_pos;
1473	}
1474
1475	if (s->left_till_irq < 0) {
1476	s->left_till_irq = s->block_size;
1477	}
1478
1479	if (s->voice) {
1480	free = s->audio_free & ~s->align;
1481	if ((free <= 0) \|\| !dma_len) {
1482	return dma_pos;
1483	}
1484	}
1485	else {
1486	free = dma_len;
1487	}
1488
1489	copy = free;
1490	till = s->left_till_irq;
1491
1492	#ifdef DEBUG_SB16_MOST
1493	dolog ("pos:%06d %d till:%d len:%d\n",
1494	dma_pos, free, till, dma_len);
1495	#endif
1496
1497	if (copy >= till) {
1498	if (0 == s->dma_auto) {
1499	copy = till;
1500	} else {
1501	if( copy >= till + s->block_size ) {
1502	copy = till; /* Make sure we won't skip IRQs. */
1503	}
1504	}
1505	}
1506
1507	written = write_audio (s, nchan, dma_pos, dma_len, copy);
1508	dma_pos = (dma_pos + written) % dma_len;
1509	s->left_till_irq -= written;
1510
1511	if (s->left_till_irq <= 0) {
1512	s->mixer_regs[0x82] \|= (nchan & 4) ? 2 : 1;
1513	#ifndef VBOX
1514	qemu_irq_raise (s->pic[s->irq]);
1515	#else
1516	PDMDevHlpISASetIrq(s->pDevIns, s->irq, 1);
1517	#endif
1518	if (0 == s->dma_auto) {
1519	control (s, 0);
1520	speaker (s, 0);
1521	}
1522	}
1523
1524	#ifdef DEBUG_SB16_MOST
1525	ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
1526	dma_pos, free, dma_len, s->left_till_irq, copy, written,
1527	s->block_size);
1528	#endif
1529
1530	while (s->left_till_irq <= 0) {
1531	s->left_till_irq = s->block_size + s->left_till_irq;
1532	}
1533
1534	return dma_pos;
1535	}
1536
1537	static void SB_audio_callback (void *opaque, int free)
1538	{
1539	SB16State s = (SB16State)opaque;
1540	s->audio_free = free;
1541	#ifdef VBOX
1542	/* New space available, see if we can transfer more. There is no cyclic DMA timer in VBox. */
1543	PDMDevHlpDMASchedule (s->pDevIns);
1544	#endif
1545	}
1546
1547	static void SB_save (QEMUFile f, void opaque)
1548	{
1549	#ifndef VBOX
1550	SB16State *s = opaque;
1551	#else
1552	SB16State s = (SB16State )opaque;
1553	#endif
1554
1555	qemu_put_be32 (f, s->irq);
1556	qemu_put_be32 (f, s->dma);
1557	qemu_put_be32 (f, s->hdma);
1558	qemu_put_be32 (f, s->port);
1559	qemu_put_be32 (f, s->ver);
1560	qemu_put_be32 (f, s->in_index);
1561	qemu_put_be32 (f, s->out_data_len);
1562	qemu_put_be32 (f, s->fmt_stereo);
1563	qemu_put_be32 (f, s->fmt_signed);
1564	qemu_put_be32 (f, s->fmt_bits);
1565	qemu_put_be32s (f, &s->fmt);
1566	qemu_put_be32 (f, s->dma_auto);
1567	qemu_put_be32 (f, s->block_size);
1568	qemu_put_be32 (f, s->fifo);
1569	qemu_put_be32 (f, s->freq);
1570	qemu_put_be32 (f, s->time_const);
1571	qemu_put_be32 (f, s->speaker);
1572	qemu_put_be32 (f, s->needed_bytes);
1573	qemu_put_be32 (f, s->cmd);
1574	qemu_put_be32 (f, s->use_hdma);
1575	qemu_put_be32 (f, s->highspeed);
1576	qemu_put_be32 (f, s->can_write);
1577	qemu_put_be32 (f, s->v2x6);
1578
1579	qemu_put_8s (f, &s->csp_param);
1580	qemu_put_8s (f, &s->csp_value);
1581	qemu_put_8s (f, &s->csp_mode);
1582	qemu_put_8s (f, &s->csp_param);
1583	qemu_put_buffer (f, s->csp_regs, 256);
1584	qemu_put_8s (f, &s->csp_index);
1585	qemu_put_buffer (f, s->csp_reg83, 4);
1586	qemu_put_be32 (f, s->csp_reg83r);
1587	qemu_put_be32 (f, s->csp_reg83w);
1588
1589	qemu_put_buffer (f, s->in2_data, sizeof (s->in2_data));
1590	qemu_put_buffer (f, s->out_data, sizeof (s->out_data));
1591	qemu_put_8s (f, &s->test_reg);
1592	qemu_put_8s (f, &s->last_read_byte);
1593
1594	qemu_put_be32 (f, s->nzero);
1595	qemu_put_be32 (f, s->left_till_irq);
1596	qemu_put_be32 (f, s->dma_running);
1597	qemu_put_be32 (f, s->bytes_per_second);
1598	qemu_put_be32 (f, s->align);
1599
1600	qemu_put_be32 (f, s->mixer_nreg);
1601	qemu_put_buffer (f, s->mixer_regs, 256);
1602	}
1603
1604	static int SB_load (QEMUFile f, void opaque, int version_id)
1605	{
1606	#ifndef VBOX
1607	SB16State *s = opaque;
1608
1609	if (version_id != 1) {
1610	return -EINVAL;
1611	}
1612	#else
1613	SB16State s = (SB16State )opaque;
1614	#endif
1615
1616	s->irq=qemu_get_be32 (f);
1617	s->dma=qemu_get_be32 (f);
1618	s->hdma=qemu_get_be32 (f);
1619	s->port=qemu_get_be32 (f);
1620	s->ver=qemu_get_be32 (f);
1621	s->in_index=qemu_get_be32 (f);
1622	s->out_data_len=qemu_get_be32 (f);
1623	s->fmt_stereo=qemu_get_be32 (f);
1624	s->fmt_signed=qemu_get_be32 (f);
1625	s->fmt_bits=qemu_get_be32 (f);
1626	qemu_get_be32s (f, (uint32_t*)&s->fmt);
1627	s->dma_auto=qemu_get_be32 (f);
1628	s->block_size=qemu_get_be32 (f);
1629	s->fifo=qemu_get_be32 (f);
1630	s->freq=qemu_get_be32 (f);
1631	s->time_const=qemu_get_be32 (f);
1632	s->speaker=qemu_get_be32 (f);
1633	s->needed_bytes=qemu_get_be32 (f);
1634	s->cmd=qemu_get_be32 (f);
1635	s->use_hdma=qemu_get_be32 (f);
1636	s->highspeed=qemu_get_be32 (f);
1637	s->can_write=qemu_get_be32 (f);
1638	s->v2x6=qemu_get_be32 (f);
1639
1640	qemu_get_8s (f, &s->csp_param);
1641	qemu_get_8s (f, &s->csp_value);
1642	qemu_get_8s (f, &s->csp_mode);
1643	qemu_get_8s (f, &s->csp_param);
1644	qemu_get_buffer (f, s->csp_regs, 256);
1645	qemu_get_8s (f, &s->csp_index);
1646	qemu_get_buffer (f, s->csp_reg83, 4);
1647	s->csp_reg83r=qemu_get_be32 (f);
1648	s->csp_reg83w=qemu_get_be32 (f);
1649
1650	qemu_get_buffer (f, s->in2_data, sizeof (s->in2_data));
1651	qemu_get_buffer (f, s->out_data, sizeof (s->out_data));
1652	qemu_get_8s (f, &s->test_reg);
1653	qemu_get_8s (f, &s->last_read_byte);
1654
1655	s->nzero=qemu_get_be32 (f);
1656	s->left_till_irq=qemu_get_be32 (f);
1657	s->dma_running=qemu_get_be32 (f);
1658	s->bytes_per_second=qemu_get_be32 (f);
1659	s->align=qemu_get_be32 (f);
1660
1661	s->mixer_nreg=qemu_get_be32 (f);
1662	qemu_get_buffer (f, s->mixer_regs, 256);
1663
1664	if (s->voice) {
1665	AUD_close_out (&s->card, s->voice);
1666	s->voice = NULL;
1667	}
1668
1669	if (s->dma_running) {
1670	if (s->freq) {
1671	audsettings_t as;
1672
1673	s->audio_free = 0;
1674
1675	as.freq = s->freq;
1676	as.nchannels = 1 << s->fmt_stereo;
1677	as.fmt = s->fmt;
1678	as.endianness = 0;
1679
1680	s->voice = AUD_open_out (
1681	&s->card,
1682	s->voice,
1683	"sb16",
1684	s,
1685	SB_audio_callback,
1686	&as
1687	);
1688	}
1689
1690	control (s, 1);
1691	speaker (s, s->speaker);
1692	}
1693
1694	#ifdef VBOX
1695	return VINF_SUCCESS;
1696	#endif
1697	}
1698
1699	#ifndef VBOX
1700	int SB16_init (AudioState audio, qemu_irq pic)
1701	{
1702	SB16State *s;
1703	int i;
1704	static const uint8_t dsp_write_ports[] = {0x6, 0xc};
1705	static const uint8_t dsp_read_ports[] = {0x6, 0xa, 0xc, 0xd, 0xe, 0xf};
1706
1707	if (!audio) {
1708	dolog ("No audio state\n");
1709	return -1;
1710	}
1711
1712	s = qemu_mallocz (sizeof (*s));
1713	if (!s) {
1714	dolog ("Could not allocate memory for SB16 (%zu bytes)\n",
1715	sizeof (*s));
1716	return -1;
1717	}
1718
1719	s->cmd = -1;
1720	s->pic = pic;
1721	s->irq = conf.irq;
1722	s->dma = conf.dma;
1723	s->hdma = conf.hdma;
1724	s->port = conf.port;
1725	s->ver = conf.ver_lo \| (conf.ver_hi << 8);
1726
1727	s->mixer_regs[0x80] = magic_of_irq (s->irq);
1728	s->mixer_regs[0x81] = (1 << s->dma) \| (1 << s->hdma);
1729	s->mixer_regs[0x82] = 2 << 5;
1730
1731	s->csp_regs[5] = 1;
1732	s->csp_regs[9] = 0xf8;
1733
1734	reset_mixer (s);
1735	s->aux_ts = qemu_new_timer (vm_clock, aux_timer, s);
1736	if (!s->aux_ts) {
1737	dolog ("warning: Could not create auxiliary timer\n");
1738	}
1739
1740	for (i = 0; i < LENOFA (dsp_write_ports); i++) {
1741	register_ioport_write (s->port + dsp_write_ports[i], 1, 1, dsp_write, s);
1742	}
1743
1744	for (i = 0; i < LENOFA (dsp_read_ports); i++) {
1745	register_ioport_read (s->port + dsp_read_ports[i], 1, 1, dsp_read, s);
1746	}
1747
1748	register_ioport_write (s->port + 0x4, 1, 1, mixer_write_indexb, s);
1749	register_ioport_write (s->port + 0x4, 1, 2, mixer_write_indexw, s);
1750	register_ioport_read (s->port + 0x5, 1, 1, mixer_read, s);
1751	register_ioport_write (s->port + 0x5, 1, 1, mixer_write_datab, s);
1752
1753	DMA_register_channel (s->hdma, SB_read_DMA, s);
1754	DMA_register_channel (s->dma, SB_read_DMA, s);
1755	s->can_write = 1;
1756
1757	register_savevm ("sb16", 0, 1, SB_save, SB_load, s);
1758	AUD_register_card (audio, "sb16", &s->card);
1759	return 0;
1760	}
1761
1762	#else /* VBOX */
1763
1764
1765	static DECLCALLBACK(int) sb16LiveExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
1766	{
1767	SB16State pThis = PDMINS_2_DATA (pDevIns, SB16State );
1768
1769	SSMR3PutS32(pSSM, pThis->irqCfg);
1770	SSMR3PutS32(pSSM, pThis->dmaCfg);
1771	SSMR3PutS32(pSSM, pThis->hdmaCfg);
1772	SSMR3PutS32(pSSM, pThis->portCfg);
1773	SSMR3PutS32(pSSM, pThis->verCfg);
1774	return VINF_SSM_DONT_CALL_AGAIN;
1775	}
1776
1777	static DECLCALLBACK(int) sb16SaveExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1778	{
1779	SB16State pThis = PDMINS_2_DATA (pDevIns, SB16State );
1780
1781	sb16LiveExec (pDevIns, pSSM, 0);
1782	SB_save (pSSM, pThis);
1783	return VINF_SUCCESS;
1784	}
1785
1786	static DECLCALLBACK(int) sb16LoadExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM,
1787	uint32_t uVersion, uint32_t uPass)
1788	{
1789	SB16State pThis = PDMINS_2_DATA (pDevIns, SB16State );
1790
1791	AssertMsgReturn( uVersion == SB16_SAVE_STATE_VERSION
1792	\|\| uVersion == SB16_SAVE_STATE_VERSION_VBOX_30,
1793	("%u\n", uVersion),
1794	VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
1795	if (uVersion > SB16_SAVE_STATE_VERSION_VBOX_30)
1796	{
1797	int32_t irq;
1798	SSMR3GetS32 (pSSM, &irq);
1799	int32_t dma;
1800	SSMR3GetS32 (pSSM, &dma);
1801	int32_t hdma;
1802	SSMR3GetS32 (pSSM, &hdma);
1803	int32_t port;
1804	SSMR3GetS32 (pSSM, &port);
1805	int32_t ver;
1806	int rc = SSMR3GetS32 (pSSM, &ver);
1807	AssertRCReturn (rc, rc);
1808
1809	if ( irq != pThis->irqCfg
1810	\|\| dma != pThis->dmaCfg
1811	\|\| hdma != pThis->hdmaCfg
1812	\|\| port != pThis->portCfg
1813	\|\| ver != pThis->verCfg )
1814	return SSMR3SetCfgError(pSSM, RT_SRC_POS,
1815	N_("config changed: irq=%x/%x dma=%x/%x hdma=%x/%x port=%x/%x ver=%x/%x (saved/config)"),
1816	irq, pThis->irqCfg,
1817	dma, pThis->dmaCfg,
1818	hdma, pThis->hdmaCfg,
1819	port, pThis->portCfg,
1820	ver, pThis->verCfg);
1821	}
1822	if (uPass != SSM_PASS_FINAL)
1823	return VINF_SUCCESS;
1824
1825	SB_load(pSSM, pThis, uVersion);
1826	return VINF_SUCCESS;
1827	}
1828
1829	/**
1830	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1831	*/
1832	static DECLCALLBACK(void ) sb16QueryInterface (struct PDMIBASE pInterface,
1833	const char *pszIID)
1834	{
1835	SB16State *pThis = RT_FROM_MEMBER(pInterface, SB16State, IBase);
1836	Assert(&pThis->IBase == pInterface);
1837
1838	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
1839	return NULL;
1840	}
1841
1842	static DECLCALLBACK(int) sb16Construct (PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
1843	{
1844	SB16State s = PDMINS_2_DATA(pDevIns, SB16State );
1845	int rc;
1846
1847	/*
1848	* Validations.
1849	*/
1850	Assert(iInstance == 0);
1851	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
1852	if (!CFGMR3AreValuesValid(pCfgHandle,
1853	"IRQ\0"
1854	"DMA\0"
1855	"DMA16\0"
1856	"Port\0"
1857	"Version\0"))
1858	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
1859	N_("Invalid configuration for sb16 device"));
1860
1861	/*
1862	* Read config data.
1863	*/
1864	rc = CFGMR3QuerySIntDef(pCfgHandle, "IRQ", &s->irq, 5);
1865	if (RT_FAILURE(rc))
1866	return PDMDEV_SET_ERROR(pDevIns, rc,
1867	N_("Configuration error: Failed to get the \"IRQ\" value"));
1868	s->irqCfg = s->irq;
1869
1870	rc = CFGMR3QuerySIntDef(pCfgHandle, "DMA", &s->dma, 1);
1871	if (RT_FAILURE(rc))
1872	return PDMDEV_SET_ERROR(pDevIns, rc,
1873	N_("Configuration error: Failed to get the \"DMA\" value"));
1874	s->dmaCfg = s->dma;
1875
1876	rc = CFGMR3QuerySIntDef(pCfgHandle, "DMA16", &s->hdma, 5);
1877	if (RT_FAILURE(rc))
1878	return PDMDEV_SET_ERROR(pDevIns, rc,
1879	N_("Configuration error: Failed to get the \"DMA16\" value"));
1880	s->hdmaCfg = s->hdma;
1881
1882	RTIOPORT Port;
1883	rc = CFGMR3QueryPortDef(pCfgHandle, "Port", &Port, 0x220);
1884	if (RT_FAILURE(rc))
1885	return PDMDEV_SET_ERROR(pDevIns, rc,
1886	N_("Configuration error: Failed to get the \"Port\" value"));
1887	s->port = Port;
1888	s->portCfg = Port;
1889
1890	uint16_t u16Version;
1891	rc = CFGMR3QueryU16Def(pCfgHandle, "Version", &u16Version, 0x0405);
1892	if (RT_FAILURE(rc))
1893	return PDMDEV_SET_ERROR(pDevIns, rc,
1894	N_("Configuration error: Failed to get the \"Version\" value"));
1895	s->ver = u16Version;
1896	s->verCfg = u16Version;
1897
1898	/*
1899	* Init instance data.
1900	*/
1901	s->pDevIns = pDevIns;
1902	s->IBase.pfnQueryInterface = sb16QueryInterface;
1903	s->cmd = -1;
1904
1905	s->mixer_regs[0x80] = magic_of_irq (s->irq);
1906	s->mixer_regs[0x81] = (1 << s->dma) \| (1 << s->hdma);
1907	s->mixer_regs[0x82] = 2 << 5;
1908
1909	s->csp_regs[5] = 1;
1910	s->csp_regs[9] = 0xf8;
1911
1912	reset_mixer(s);
1913
1914	/*
1915	* Create timer, register & attach stuff.
1916	*/
1917	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, sb16Timer, s,
1918	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "SB16 timer", &s->pTimer);
1919	if (RT_FAILURE(rc))
1920	AssertMsgFailedReturn(("pfnTMTimerCreate -> %Rrc\n", rc), rc);
1921
1922	rc = PDMDevHlpIOPortRegister(pDevIns, s->port + 0x04, 2, s,
1923	mixer_write, mixer_read, NULL, NULL, "SB16");
1924	if (RT_FAILURE(rc))
1925	return rc;
1926	rc = PDMDevHlpIOPortRegister(pDevIns, s->port + 0x06, 10, s,
1927	dsp_write, dsp_read, NULL, NULL, "SB16");
1928	if (RT_FAILURE(rc))
1929	return rc;
1930
1931	rc = PDMDevHlpDMARegister(pDevIns, s->hdma, SB_read_DMA, s);
1932	if (RT_FAILURE(rc))
1933	return rc;
1934	rc = PDMDevHlpDMARegister(pDevIns, s->dma, SB_read_DMA, s);
1935	if (RT_FAILURE(rc))
1936	return rc;
1937
1938	s->can_write = 1;
1939
1940	rc = PDMDevHlpSSMRegister3(pDevIns, SB16_SAVE_STATE_VERSION, sizeof(*s), sb16LiveExec, sb16SaveExec, sb16LoadExec);
1941	if (RT_FAILURE(rc))
1942	return rc;
1943
1944	rc = PDMDevHlpDriverAttach(pDevIns, 0, &s->IBase, &s->pDrvBase, "Audio Driver Port");
1945	if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1946	Log(("sb16: No attached driver!\n"));
1947	else if (RT_FAILURE(rc))
1948	AssertMsgFailedReturn(("Failed to attach SB16 LUN #0! rc=%Rrc\n", rc), rc);
1949
1950	AUD_register_card("sb16", &s->card);
1951	legacy_reset(s);
1952
1953	if (!AUD_is_host_voice_out_ok(s->voice))
1954	{
1955	LogRel (("SB16: WARNING: Unable to open PCM OUT!\n"));
1956	AUD_close_out(&s->card, s->voice);
1957	s->voice = NULL;
1958	AUD_init_null();
1959	PDMDevHlpVMSetRuntimeError(pDevIns, 0 /fFlags/, "HostAudioNotResponding",
1960	N_("No audio devices could be opened. Selecting the NULL audio backend "
1961	"with the consequence that no sound is audible"));
1962	}
1963	return VINF_SUCCESS;
1964	}
1965
1966	const PDMDEVREG g_DeviceSB16 =
1967	{
1968	/* u32Version */
1969	PDM_DEVREG_VERSION,
1970	/* szName */
1971	"sb16",
1972	/* szRCMod */
1973	"",
1974	/* szR0Mod */
1975	"",
1976	/* pszDescription */
1977	"Sound Blaster 16 Controller",
1978	/* fFlags */
1979	PDM_DEVREG_FLAGS_DEFAULT_BITS,
1980	/* fClass */
1981	PDM_DEVREG_CLASS_AUDIO,
1982	/* cMaxInstances */
1983	1,
1984	/* cbInstance */
1985	sizeof(SB16State),
1986	/* pfnConstruct */
1987	sb16Construct,
1988	/* pfnDestruct */
1989	NULL,
1990	/* pfnRelocate */
1991	NULL,
1992	/* pfnIOCtl */
1993	NULL,
1994	/* pfnPowerOn */
1995	NULL,
1996	/* pfnReset */
1997	NULL,
1998	/* pfnSuspend */
1999	NULL,
2000	/* pfnResume */
2001	NULL,
2002	/* pfnAttach */
2003	NULL,
2004	/* pfnDetach */
2005	NULL,
2006	/* pfnQueryInterface */
2007	NULL,
2008	/* pfnInitComplete */
2009	NULL,
2010	/* pfnPowerOff */
2011	NULL,
2012	/* pfnSoftReset */
2013	NULL,
2014	/* u32VersionEnd */
2015	PDM_DEVREG_VERSION
2016	};
2017
2018	#endif /* VBOX */
2019

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

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

Download in other formats: