2 * QEMU Soundblaster 16 emulation
4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #define LENOFA(a) ((int) (sizeof(a)/sizeof(a[0])))
28 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
31 /* #define DEBUG_SB16_MOST */
34 #define ldebug(...) dolog (__VA_ARGS__)
39 #define IO_READ_PROTO(name) \
40 uint32_t name (void *opaque, uint32_t nport)
41 #define IO_WRITE_PROTO(name) \
42 void name (void *opaque, uint32_t nport, uint32_t val)
44 static const char e3
[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
53 } conf
= {5, 4, 5, 1, 5, 0x220};
55 typedef struct SB16State
{
87 uint8_t csp_regs
[256];
96 uint8_t last_read_byte
;
102 int bytes_per_second
;
110 uint8_t mixer_regs
[256];
113 static void SB_audio_callback (void *opaque
, int free
);
115 static int magic_of_irq (int irq
)
127 dolog ("bad irq %d\n", irq
);
132 static int irq_of_magic (int magic
)
144 dolog ("bad irq magic %d\n", magic
);
150 static void log_dsp (SB16State
*dsp
)
152 ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
153 dsp
->fmt_stereo
? "Stereo" : "Mono",
154 dsp
->fmt_signed
? "Signed" : "Unsigned",
156 dsp
->dma_auto
? "Auto" : "Single",
164 static void speaker (SB16State
*s
, int on
)
167 /* AUD_enable (s->voice, on); */
170 static void control (SB16State
*s
, int hold
)
172 int dma
= s
->use_hdma
? s
->hdma
: s
->dma
;
173 s
->dma_running
= hold
;
175 ldebug ("hold %d high %d dma %d\n", hold
, s
->use_hdma
, dma
);
179 AUD_set_active_out (s
->voice
, 1);
182 DMA_release_DREQ (dma
);
183 AUD_set_active_out (s
->voice
, 0);
187 static void aux_timer (void *opaque
)
189 SB16State
*s
= opaque
;
191 qemu_irq_raise (s
->pic
[s
->irq
]);
197 static void continue_dma8 (SB16State
*s
)
205 as
.nchannels
= 1 << s
->fmt_stereo
;
209 s
->voice
= AUD_open_out (
222 static void dma_cmd8 (SB16State
*s
, int mask
, int dma_len
)
228 s
->fmt_stereo
= (s
->mixer_regs
[0x0e] & 2) != 0;
229 if (-1 == s
->time_const
) {
234 int tmp
= (256 - s
->time_const
);
235 s
->freq
= (1000000 + (tmp
/ 2)) / tmp
;
239 s
->block_size
= dma_len
<< s
->fmt_stereo
;
242 /* This is apparently the only way to make both Act1/PL
243 and SecondReality/FC work
245 Act1 sets block size via command 0x48 and it's an odd number
246 SR does the same with even number
247 Both use stereo, and Creatives own documentation states that
248 0x48 sets block size in bytes less one.. go figure */
249 s
->block_size
&= ~s
->fmt_stereo
;
252 s
->freq
>>= s
->fmt_stereo
;
253 s
->left_till_irq
= s
->block_size
;
254 s
->bytes_per_second
= (s
->freq
<< s
->fmt_stereo
);
255 /* s->highspeed = (mask & DMA8_HIGH) != 0; */
256 s
->dma_auto
= (mask
& DMA8_AUTO
) != 0;
257 s
->align
= (1 << s
->fmt_stereo
) - 1;
259 if (s
->block_size
& s
->align
) {
260 dolog ("warning: misaligned block size %d, alignment %d\n",
261 s
->block_size
, s
->align
+ 1);
264 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
265 "dma %d, auto %d, fifo %d, high %d\n",
266 s
->freq
, s
->fmt_stereo
, s
->fmt_signed
, s
->fmt_bits
,
267 s
->block_size
, s
->dma_auto
, s
->fifo
, s
->highspeed
);
273 static void dma_cmd (SB16State
*s
, uint8_t cmd
, uint8_t d0
, int dma_len
)
275 s
->use_hdma
= cmd
< 0xc0;
276 s
->fifo
= (cmd
>> 1) & 1;
277 s
->dma_auto
= (cmd
>> 2) & 1;
278 s
->fmt_signed
= (d0
>> 4) & 1;
279 s
->fmt_stereo
= (d0
>> 5) & 1;
291 if (-1 != s
->time_const
) {
293 int tmp
= 256 - s
->time_const
;
294 s
->freq
= (1000000 + (tmp
/ 2)) / tmp
;
296 /* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */
297 s
->freq
= 1000000 / ((255 - s
->time_const
));
302 s
->block_size
= dma_len
+ 1;
303 s
->block_size
<<= (s
->fmt_bits
== 16);
305 /* It is clear that for DOOM and auto-init this value
306 shouldn't take stereo into account, while Miles Sound Systems
307 setsound.exe with single transfer mode wouldn't work without it
308 wonders of SB16 yet again */
309 s
->block_size
<<= s
->fmt_stereo
;
312 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
313 "dma %d, auto %d, fifo %d, high %d\n",
314 s
->freq
, s
->fmt_stereo
, s
->fmt_signed
, s
->fmt_bits
,
315 s
->block_size
, s
->dma_auto
, s
->fifo
, s
->highspeed
);
317 if (16 == s
->fmt_bits
) {
319 s
->fmt
= AUD_FMT_S16
;
322 s
->fmt
= AUD_FMT_U16
;
334 s
->left_till_irq
= s
->block_size
;
336 s
->bytes_per_second
= (s
->freq
<< s
->fmt_stereo
) << (s
->fmt_bits
== 16);
338 s
->align
= (1 << (s
->fmt_stereo
+ (s
->fmt_bits
== 16))) - 1;
339 if (s
->block_size
& s
->align
) {
340 dolog ("warning: misaligned block size %d, alignment %d\n",
341 s
->block_size
, s
->align
+ 1);
350 as
.nchannels
= 1 << s
->fmt_stereo
;
354 s
->voice
= AUD_open_out (
368 static inline void dsp_out_data (SB16State
*s
, uint8_t val
)
370 ldebug ("outdata %#x\n", val
);
371 if ((size_t) s
->out_data_len
< sizeof (s
->out_data
)) {
372 s
->out_data
[s
->out_data_len
++] = val
;
376 static inline uint8_t dsp_get_data (SB16State
*s
)
379 return s
->in2_data
[--s
->in_index
];
382 dolog ("buffer underflow\n");
387 static void command (SB16State
*s
, uint8_t cmd
)
389 ldebug ("command %#x\n", cmd
);
391 if (cmd
> 0xaf && cmd
< 0xd0) {
393 dolog ("ADC not yet supported (command %#x)\n", cmd
);
401 dolog ("%#x wrong bits\n", cmd
);
410 dsp_out_data (s
, 0x10); /* s->csp_param); */
422 /* __asm__ ("int3"); */
430 dsp_out_data (s
, 0xf8);
446 case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
447 dma_cmd8 (s
, DMA8_AUTO
, -1);
450 case 0x20: /* Direct ADC, Juice/PL */
451 dsp_out_data (s
, 0xff);
455 dolog ("0x35 - MIDI command not implemented\n");
477 dsp_out_data (s
, 0xaa);
480 case 0x47: /* Continue Auto-Initialize DMA 16bit */
488 s
->needed_bytes
= 2; /* DMA DAC, 4-bit ADPCM */
489 dolog ("0x75 - DMA DAC, 4-bit ADPCM not implemented\n");
492 case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
494 dolog ("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n");
497 case 0x76: /* DMA DAC, 2.6-bit ADPCM */
499 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n");
502 case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
504 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n");
508 dolog ("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n");
509 dolog ("not implemented\n");
514 "0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"
516 dolog ("not implemented\n");
525 dma_cmd8 (s
, ((cmd
& 1) == 0) | DMA8_HIGH
, -1);
528 case 0xd0: /* halt DMA operation. 8bit */
532 case 0xd1: /* speaker on */
536 case 0xd3: /* speaker off */
540 case 0xd4: /* continue DMA operation. 8bit */
541 /* KQ6 (or maybe Sierras audblst.drv in general) resets
542 the frequency between halt/continue */
546 case 0xd5: /* halt DMA operation. 16bit */
550 case 0xd6: /* continue DMA operation. 16bit */
554 case 0xd9: /* exit auto-init DMA after this block. 16bit */
558 case 0xda: /* exit auto-init DMA after this block. 8bit */
562 case 0xe0: /* DSP identification */
567 dsp_out_data (s
, s
->ver
& 0xff);
568 dsp_out_data (s
, s
->ver
>> 8);
578 for (i
= sizeof (e3
) - 1; i
>= 0; --i
)
579 dsp_out_data (s
, e3
[i
]);
583 case 0xe4: /* write test reg */
588 dolog ("Attempt to probe for ESS (0xe7)?\n");
591 case 0xe8: /* read test reg */
592 dsp_out_data (s
, s
->test_reg
);
597 dsp_out_data (s
, 0xaa);
598 s
->mixer_regs
[0x82] |= (cmd
== 0xf2) ? 1 : 2;
599 qemu_irq_raise (s
->pic
[s
->irq
]);
610 case 0xfc: /* FIXME */
615 dolog ("Unrecognized command %#x\n", cmd
);
620 if (!s
->needed_bytes
) {
625 if (!s
->needed_bytes
) {
634 dolog ("warning: command %#x,%d is not truly understood yet\n",
635 cmd
, s
->needed_bytes
);
640 static uint16_t dsp_get_lohi (SB16State
*s
)
642 uint8_t hi
= dsp_get_data (s
);
643 uint8_t lo
= dsp_get_data (s
);
644 return (hi
<< 8) | lo
;
647 static uint16_t dsp_get_hilo (SB16State
*s
)
649 uint8_t lo
= dsp_get_data (s
);
650 uint8_t hi
= dsp_get_data (s
);
651 return (hi
<< 8) | lo
;
654 static void complete (SB16State
*s
)
657 ldebug ("complete command %#x, in_index %d, needed_bytes %d\n",
658 s
->cmd
, s
->in_index
, s
->needed_bytes
);
660 if (s
->cmd
> 0xaf && s
->cmd
< 0xd0) {
661 d2
= dsp_get_data (s
);
662 d1
= dsp_get_data (s
);
663 d0
= dsp_get_data (s
);
666 dolog ("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
670 ldebug ("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
672 dma_cmd (s
, s
->cmd
, d0
, d1
+ (d2
<< 8));
678 s
->csp_mode
= dsp_get_data (s
);
681 ldebug ("CSP command 0x04: mode=%#x\n", s
->csp_mode
);
685 s
->csp_param
= dsp_get_data (s
);
686 s
->csp_value
= dsp_get_data (s
);
687 ldebug ("CSP command 0x05: param=%#x value=%#x\n",
693 d0
= dsp_get_data (s
);
694 d1
= dsp_get_data (s
);
695 ldebug ("write CSP register %d <- %#x\n", d1
, d0
);
697 ldebug ("0x83[%d] <- %#x\n", s
->csp_reg83r
, d0
);
698 s
->csp_reg83
[s
->csp_reg83r
% 4] = d0
;
702 s
->csp_regs
[d1
] = d0
;
707 d0
= dsp_get_data (s
);
708 ldebug ("read CSP register %#x -> %#x, mode=%#x\n",
709 d0
, s
->csp_regs
[d0
], s
->csp_mode
);
711 ldebug ("0x83[%d] -> %#x\n",
713 s
->csp_reg83
[s
->csp_reg83w
% 4]);
714 dsp_out_data (s
, s
->csp_reg83
[s
->csp_reg83w
% 4]);
718 dsp_out_data (s
, s
->csp_regs
[d0
]);
723 d0
= dsp_get_data (s
);
724 dolog ("cmd 0x10 d0=%#x\n", d0
);
728 dma_cmd8 (s
, 0, dsp_get_lohi (s
) + 1);
732 s
->time_const
= dsp_get_data (s
);
733 ldebug ("set time const %d\n", s
->time_const
);
736 case 0x42: /* FT2 sets output freq with this, go figure */
738 dolog ("cmd 0x42 might not do what it think it should\n");
741 s
->freq
= dsp_get_hilo (s
);
742 ldebug ("set freq %d\n", s
->freq
);
746 s
->block_size
= dsp_get_lohi (s
) + 1;
747 ldebug ("set dma block len %d\n", s
->block_size
);
754 /* ADPCM stuff, ignore */
759 int freq
, samples
, bytes
;
762 freq
= s
->freq
> 0 ? s
->freq
: 11025;
763 samples
= dsp_get_lohi (s
) + 1;
764 bytes
= samples
<< s
->fmt_stereo
<< (s
->fmt_bits
== 16);
765 ticks
= (bytes
* ticks_per_sec
) / freq
;
766 if (ticks
< ticks_per_sec
/ 1024) {
767 qemu_irq_raise (s
->pic
[s
->irq
]);
773 qemu_get_clock (vm_clock
) + ticks
777 ldebug ("mix silence %d %d %" PRId64
"\n", samples
, bytes
, ticks
);
782 d0
= dsp_get_data (s
);
784 ldebug ("E0 data = %#x\n", d0
);
785 dsp_out_data (s
, ~d0
);
789 d0
= dsp_get_data (s
);
790 ldebug ("E2 = %#x\n", d0
);
794 s
->test_reg
= dsp_get_data (s
);
798 d0
= dsp_get_data (s
);
799 ldebug ("command 0xf9 with %#x\n", d0
);
802 dsp_out_data (s
, 0xff);
806 dsp_out_data (s
, 0x07);
810 dsp_out_data (s
, 0x38);
814 dsp_out_data (s
, 0x00);
820 dolog ("complete: unrecognized command %#x\n", s
->cmd
);
830 static void legacy_reset (SB16State
*s
)
844 s
->voice
= AUD_open_out (
853 /* Not sure about that... */
854 /* AUD_set_active_out (s->voice, 1); */
857 static void reset (SB16State
*s
)
859 qemu_irq_lower (s
->pic
[s
->irq
]);
861 qemu_irq_raise (s
->pic
[s
->irq
]);
862 qemu_irq_lower (s
->pic
[s
->irq
]);
865 s
->mixer_regs
[0x82] = 0;
869 s
->left_till_irq
= 0;
877 dsp_out_data(s
, 0xaa);
883 static IO_WRITE_PROTO (dsp_write
)
885 SB16State
*s
= opaque
;
888 iport
= nport
- s
->port
;
890 ldebug ("write %#x <- %#x\n", nport
, val
);
896 if (0 && s
->highspeed
) {
898 qemu_irq_lower (s
->pic
[s
->irq
]);
909 case 0x03: /* FreeBSD kludge */
914 s
->v2x6
= 0; /* Prince of Persia, csp.sys, diagnose.exe */
917 case 0xb8: /* Panic */
922 dsp_out_data (s
, 0x38);
933 case 0x0c: /* write data or command | write status */
934 /* if (s->highspeed) */
937 if (0 == s
->needed_bytes
) {
940 if (0 == s
->needed_bytes
) {
946 if (s
->in_index
== sizeof (s
->in2_data
)) {
947 dolog ("in data overrun\n");
950 s
->in2_data
[s
->in_index
++] = val
;
951 if (s
->in_index
== s
->needed_bytes
) {
963 ldebug ("(nport=%#x, val=%#x)\n", nport
, val
);
968 static IO_READ_PROTO (dsp_read
)
970 SB16State
*s
= opaque
;
971 int iport
, retval
, ack
= 0;
973 iport
= nport
- s
->port
;
976 case 0x06: /* reset */
980 case 0x0a: /* read data */
981 if (s
->out_data_len
) {
982 retval
= s
->out_data
[--s
->out_data_len
];
983 s
->last_read_byte
= retval
;
987 dolog ("empty output buffer for command %#x\n",
990 retval
= s
->last_read_byte
;
995 case 0x0c: /* 0 can write */
996 retval
= s
->can_write
? 0 : 0x80;
999 case 0x0d: /* timer interrupt clear */
1000 /* dolog ("timer interrupt clear\n"); */
1004 case 0x0e: /* data available status | irq 8 ack */
1005 retval
= (!s
->out_data_len
|| s
->highspeed
) ? 0 : 0x80;
1006 if (s
->mixer_regs
[0x82] & 1) {
1008 s
->mixer_regs
[0x82] &= 1;
1009 qemu_irq_lower (s
->pic
[s
->irq
]);
1013 case 0x0f: /* irq 16 ack */
1015 if (s
->mixer_regs
[0x82] & 2) {
1017 s
->mixer_regs
[0x82] &= 2;
1018 qemu_irq_lower (s
->pic
[s
->irq
]);
1027 ldebug ("read %#x -> %#x\n", nport
, retval
);
1033 dolog ("warning: dsp_read %#x error\n", nport
);
1037 static void reset_mixer (SB16State
*s
)
1041 memset (s
->mixer_regs
, 0xff, 0x7f);
1042 memset (s
->mixer_regs
+ 0x83, 0xff, sizeof (s
->mixer_regs
) - 0x83);
1044 s
->mixer_regs
[0x02] = 4; /* master volume 3bits */
1045 s
->mixer_regs
[0x06] = 4; /* MIDI volume 3bits */
1046 s
->mixer_regs
[0x08] = 0; /* CD volume 3bits */
1047 s
->mixer_regs
[0x0a] = 0; /* voice volume 2bits */
1049 /* d5=input filt, d3=lowpass filt, d1,d2=input source */
1050 s
->mixer_regs
[0x0c] = 0;
1052 /* d5=output filt, d1=stereo switch */
1053 s
->mixer_regs
[0x0e] = 0;
1055 /* voice volume L d5,d7, R d1,d3 */
1056 s
->mixer_regs
[0x04] = (4 << 5) | (4 << 1);
1058 s
->mixer_regs
[0x22] = (4 << 5) | (4 << 1);
1060 s
->mixer_regs
[0x26] = (4 << 5) | (4 << 1);
1062 for (i
= 0x30; i
< 0x48; i
++) {
1063 s
->mixer_regs
[i
] = 0x20;
1067 static IO_WRITE_PROTO(mixer_write_indexb
)
1069 SB16State
*s
= opaque
;
1071 s
->mixer_nreg
= val
;
1074 static IO_WRITE_PROTO(mixer_write_datab
)
1076 SB16State
*s
= opaque
;
1079 ldebug ("mixer_write [%#x] <- %#x\n", s
->mixer_nreg
, val
);
1081 switch (s
->mixer_nreg
) {
1088 int irq
= irq_of_magic (val
);
1089 ldebug ("setting irq to %d (val=%#x)\n", irq
, val
);
1100 dma
= lsbindex (val
& 0xf);
1101 hdma
= lsbindex (val
& 0xf0);
1102 if (dma
!= s
->dma
|| hdma
!= s
->hdma
) {
1104 "attempt to change DMA "
1105 "8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
1106 dma
, s
->dma
, hdma
, s
->hdma
, val
);
1116 dolog ("attempt to write into IRQ status register (val=%#x)\n",
1121 if (s
->mixer_nreg
>= 0x80) {
1122 ldebug ("attempt to write mixer[%#x] <- %#x\n", s
->mixer_nreg
, val
);
1127 s
->mixer_regs
[s
->mixer_nreg
] = val
;
1130 static IO_WRITE_PROTO(mixer_write_indexw
)
1132 mixer_write_indexb (opaque
, nport
, val
& 0xff);
1133 mixer_write_datab (opaque
, nport
, (val
>> 8) & 0xff);
1136 static IO_READ_PROTO(mixer_read
)
1138 SB16State
*s
= opaque
;
1141 #ifndef DEBUG_SB16_MOST
1142 if (s
->mixer_nreg
!= 0x82) {
1143 ldebug ("mixer_read[%#x] -> %#x\n",
1144 s
->mixer_nreg
, s
->mixer_regs
[s
->mixer_nreg
]);
1147 ldebug ("mixer_read[%#x] -> %#x\n",
1148 s
->mixer_nreg
, s
->mixer_regs
[s
->mixer_nreg
]);
1150 return s
->mixer_regs
[s
->mixer_nreg
];
1153 static int write_audio (SB16State
*s
, int nchan
, int dma_pos
,
1154 int dma_len
, int len
)
1157 uint8_t tmpbuf
[4096];
1163 int left
= dma_len
- dma_pos
;
1167 to_copy
= audio_MIN (temp
, left
);
1168 if (to_copy
> sizeof (tmpbuf
)) {
1169 to_copy
= sizeof (tmpbuf
);
1172 copied
= DMA_read_memory (nchan
, tmpbuf
, dma_pos
, to_copy
);
1173 copied
= AUD_write (s
->voice
, tmpbuf
, copied
);
1176 dma_pos
= (dma_pos
+ copied
) % dma_len
;
1187 static int SB_read_DMA (void *opaque
, int nchan
, int dma_pos
, int dma_len
)
1189 SB16State
*s
= opaque
;
1190 int till
, copy
, written
, free
;
1192 if (s
->left_till_irq
< 0) {
1193 s
->left_till_irq
= s
->block_size
;
1197 free
= s
->audio_free
& ~s
->align
;
1198 if ((free
<= 0) || !dma_len
) {
1207 till
= s
->left_till_irq
;
1209 #ifdef DEBUG_SB16_MOST
1210 dolog ("pos:%06d %d till:%d len:%d\n",
1211 dma_pos
, free
, till
, dma_len
);
1215 if (0 == s
->dma_auto
) {
1220 written
= write_audio (s
, nchan
, dma_pos
, dma_len
, copy
);
1221 dma_pos
= (dma_pos
+ written
) % dma_len
;
1222 s
->left_till_irq
-= written
;
1224 if (s
->left_till_irq
<= 0) {
1225 s
->mixer_regs
[0x82] |= (nchan
& 4) ? 2 : 1;
1226 qemu_irq_raise (s
->pic
[s
->irq
]);
1227 if (0 == s
->dma_auto
) {
1233 #ifdef DEBUG_SB16_MOST
1234 ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
1235 dma_pos
, free
, dma_len
, s
->left_till_irq
, copy
, written
,
1239 while (s
->left_till_irq
<= 0) {
1240 s
->left_till_irq
= s
->block_size
+ s
->left_till_irq
;
1246 static void SB_audio_callback (void *opaque
, int free
)
1248 SB16State
*s
= opaque
;
1249 s
->audio_free
= free
;
1252 static void SB_save (QEMUFile
*f
, void *opaque
)
1254 SB16State
*s
= opaque
;
1256 qemu_put_be32s (f
, &s
->irq
);
1257 qemu_put_be32s (f
, &s
->dma
);
1258 qemu_put_be32s (f
, &s
->hdma
);
1259 qemu_put_be32s (f
, &s
->port
);
1260 qemu_put_be32s (f
, &s
->ver
);
1261 qemu_put_be32s (f
, &s
->in_index
);
1262 qemu_put_be32s (f
, &s
->out_data_len
);
1263 qemu_put_be32s (f
, &s
->fmt_stereo
);
1264 qemu_put_be32s (f
, &s
->fmt_signed
);
1265 qemu_put_be32s (f
, &s
->fmt_bits
);
1266 qemu_put_be32s (f
, &s
->fmt
);
1267 qemu_put_be32s (f
, &s
->dma_auto
);
1268 qemu_put_be32s (f
, &s
->block_size
);
1269 qemu_put_be32s (f
, &s
->fifo
);
1270 qemu_put_be32s (f
, &s
->freq
);
1271 qemu_put_be32s (f
, &s
->time_const
);
1272 qemu_put_be32s (f
, &s
->speaker
);
1273 qemu_put_be32s (f
, &s
->needed_bytes
);
1274 qemu_put_be32s (f
, &s
->cmd
);
1275 qemu_put_be32s (f
, &s
->use_hdma
);
1276 qemu_put_be32s (f
, &s
->highspeed
);
1277 qemu_put_be32s (f
, &s
->can_write
);
1278 qemu_put_be32s (f
, &s
->v2x6
);
1280 qemu_put_8s (f
, &s
->csp_param
);
1281 qemu_put_8s (f
, &s
->csp_value
);
1282 qemu_put_8s (f
, &s
->csp_mode
);
1283 qemu_put_8s (f
, &s
->csp_param
);
1284 qemu_put_buffer (f
, s
->csp_regs
, 256);
1285 qemu_put_8s (f
, &s
->csp_index
);
1286 qemu_put_buffer (f
, s
->csp_reg83
, 4);
1287 qemu_put_be32s (f
, &s
->csp_reg83r
);
1288 qemu_put_be32s (f
, &s
->csp_reg83w
);
1290 qemu_put_buffer (f
, s
->in2_data
, sizeof (s
->in2_data
));
1291 qemu_put_buffer (f
, s
->out_data
, sizeof (s
->out_data
));
1292 qemu_put_8s (f
, &s
->test_reg
);
1293 qemu_put_8s (f
, &s
->last_read_byte
);
1295 qemu_put_be32s (f
, &s
->nzero
);
1296 qemu_put_be32s (f
, &s
->left_till_irq
);
1297 qemu_put_be32s (f
, &s
->dma_running
);
1298 qemu_put_be32s (f
, &s
->bytes_per_second
);
1299 qemu_put_be32s (f
, &s
->align
);
1301 qemu_put_be32s (f
, &s
->mixer_nreg
);
1302 qemu_put_buffer (f
, s
->mixer_regs
, 256);
1305 static int SB_load (QEMUFile
*f
, void *opaque
, int version_id
)
1307 SB16State
*s
= opaque
;
1309 if (version_id
!= 1) {
1313 qemu_get_be32s (f
, &s
->irq
);
1314 qemu_get_be32s (f
, &s
->dma
);
1315 qemu_get_be32s (f
, &s
->hdma
);
1316 qemu_get_be32s (f
, &s
->port
);
1317 qemu_get_be32s (f
, &s
->ver
);
1318 qemu_get_be32s (f
, &s
->in_index
);
1319 qemu_get_be32s (f
, &s
->out_data_len
);
1320 qemu_get_be32s (f
, &s
->fmt_stereo
);
1321 qemu_get_be32s (f
, &s
->fmt_signed
);
1322 qemu_get_be32s (f
, &s
->fmt_bits
);
1323 qemu_get_be32s (f
, &s
->fmt
);
1324 qemu_get_be32s (f
, &s
->dma_auto
);
1325 qemu_get_be32s (f
, &s
->block_size
);
1326 qemu_get_be32s (f
, &s
->fifo
);
1327 qemu_get_be32s (f
, &s
->freq
);
1328 qemu_get_be32s (f
, &s
->time_const
);
1329 qemu_get_be32s (f
, &s
->speaker
);
1330 qemu_get_be32s (f
, &s
->needed_bytes
);
1331 qemu_get_be32s (f
, &s
->cmd
);
1332 qemu_get_be32s (f
, &s
->use_hdma
);
1333 qemu_get_be32s (f
, &s
->highspeed
);
1334 qemu_get_be32s (f
, &s
->can_write
);
1335 qemu_get_be32s (f
, &s
->v2x6
);
1337 qemu_get_8s (f
, &s
->csp_param
);
1338 qemu_get_8s (f
, &s
->csp_value
);
1339 qemu_get_8s (f
, &s
->csp_mode
);
1340 qemu_get_8s (f
, &s
->csp_param
);
1341 qemu_get_buffer (f
, s
->csp_regs
, 256);
1342 qemu_get_8s (f
, &s
->csp_index
);
1343 qemu_get_buffer (f
, s
->csp_reg83
, 4);
1344 qemu_get_be32s (f
, &s
->csp_reg83r
);
1345 qemu_get_be32s (f
, &s
->csp_reg83w
);
1347 qemu_get_buffer (f
, s
->in2_data
, sizeof (s
->in2_data
));
1348 qemu_get_buffer (f
, s
->out_data
, sizeof (s
->out_data
));
1349 qemu_get_8s (f
, &s
->test_reg
);
1350 qemu_get_8s (f
, &s
->last_read_byte
);
1352 qemu_get_be32s (f
, &s
->nzero
);
1353 qemu_get_be32s (f
, &s
->left_till_irq
);
1354 qemu_get_be32s (f
, &s
->dma_running
);
1355 qemu_get_be32s (f
, &s
->bytes_per_second
);
1356 qemu_get_be32s (f
, &s
->align
);
1358 qemu_get_be32s (f
, &s
->mixer_nreg
);
1359 qemu_get_buffer (f
, s
->mixer_regs
, 256);
1362 AUD_close_out (&s
->card
, s
->voice
);
1366 if (s
->dma_running
) {
1373 as
.nchannels
= 1 << s
->fmt_stereo
;
1377 s
->voice
= AUD_open_out (
1388 speaker (s
, s
->speaker
);
1393 int SB16_init (AudioState
*audio
, qemu_irq
*pic
)
1397 static const uint8_t dsp_write_ports
[] = {0x6, 0xc};
1398 static const uint8_t dsp_read_ports
[] = {0x6, 0xa, 0xc, 0xd, 0xe, 0xf};
1401 dolog ("No audio state\n");
1405 s
= qemu_mallocz (sizeof (*s
));
1407 dolog ("Could not allocate memory for SB16 (%zu bytes)\n",
1416 s
->hdma
= conf
.hdma
;
1417 s
->port
= conf
.port
;
1418 s
->ver
= conf
.ver_lo
| (conf
.ver_hi
<< 8);
1420 s
->mixer_regs
[0x80] = magic_of_irq (s
->irq
);
1421 s
->mixer_regs
[0x81] = (1 << s
->dma
) | (1 << s
->hdma
);
1422 s
->mixer_regs
[0x82] = 2 << 5;
1425 s
->csp_regs
[9] = 0xf8;
1428 s
->aux_ts
= qemu_new_timer (vm_clock
, aux_timer
, s
);
1430 dolog ("warning: Could not create auxiliary timer\n");
1433 for (i
= 0; i
< LENOFA (dsp_write_ports
); i
++) {
1434 register_ioport_write (s
->port
+ dsp_write_ports
[i
], 1, 1, dsp_write
, s
);
1437 for (i
= 0; i
< LENOFA (dsp_read_ports
); i
++) {
1438 register_ioport_read (s
->port
+ dsp_read_ports
[i
], 1, 1, dsp_read
, s
);
1441 register_ioport_write (s
->port
+ 0x4, 1, 1, mixer_write_indexb
, s
);
1442 register_ioport_write (s
->port
+ 0x4, 1, 2, mixer_write_indexw
, s
);
1443 register_ioport_read (s
->port
+ 0x5, 1, 1, mixer_read
, s
);
1444 register_ioport_write (s
->port
+ 0x5, 1, 1, mixer_write_datab
, s
);
1446 DMA_register_channel (s
->hdma
, SB_read_DMA
, s
);
1447 DMA_register_channel (s
->dma
, SB_read_DMA
, s
);
1450 register_savevm ("sb16", 0, 1, SB_save
, SB_load
, s
);
1451 AUD_register_card (audio
, "sb16", &s
->card
);