DevSB16.cpp revision 5f80794f0fac6c6ae43bf4d2baaef60babb2a7c7
/* $Id$ */
/** @file
* DevSB16 - VBox SB16 Audio Controller.
*
* (r3917 sb16.c)
*
* @todo hiccups on NT4 and Win98.
*/
/*
* QEMU Soundblaster 16 emulation
*
* Copyright (c) 2003-2005 Vassili Karpov (malc)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#define LOG_GROUP LOG_GROUP_DEV_AUDIO
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#endif
#include "vl_vbox.h"
#ifndef VBOX_WITH_PDM_AUDIO_DRIVER
extern "C" {
#include "audio.h"
}
#endif
#ifndef VBOX
#define LENOFA(a) ((int) (sizeof(a)/sizeof(a[0])))
#else /* VBOX */
/** Current saved state version. */
#define SB16_SAVE_STATE_VERSION 2
/** The version used in VirtualBox version 3.0 and earlier. This didn't include
* the config dump. */
#define SB16_SAVE_STATE_VERSION_VBOX_30 1
#endif /* VBOX */
#ifndef VBOX
#define IO_READ_PROTO(name) \
#define IO_WRITE_PROTO(name) \
#else /* VBOX */
#define IO_READ_PROTO(name) \
#define IO_WRITE_PROTO(name) \
#endif /* VBOX */
static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
#ifndef VBOX
static struct {
int ver_lo;
int ver_hi;
int irq;
int dma;
int hdma;
int port;
#endif /* !VBOX */
typedef struct SB16State {
#ifdef VBOX
/** Pointer to the device instance. */
# ifdef VBOX_WITH_PDM_AUDIO_DRIVER
/** Pointer to the connector of the attached audio driver. */
# endif
#endif
#ifndef VBOX
#endif
#ifndef VBOX_WITH_PDM_AUDIO_DRIVER
#endif
#ifdef VBOX /* lazy bird */
int irqCfg;
int dmaCfg;
int hdmaCfg;
int portCfg;
int verCfg;
#endif
int irq;
int dma;
int hdma;
int port;
int ver;
int in_index;
int out_data_len;
int fmt_stereo;
int fmt_signed;
int fmt_bits;
int dma_auto;
int block_size;
int fifo;
int freq;
int time_const;
int speaker;
int needed_bytes;
int cmd;
int use_hdma;
int highspeed;
int can_write;
int v2x6;
int csp_reg83r;
int csp_reg83w;
int nzero;
int left_till_irq;
int dma_running;
int bytes_per_second;
int align;
int audio_free;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
#ifndef VBOX
#else
/** LUN\#0: Base interface. */
#endif
/* mixer state */
int mixer_nreg;
} SB16State;
static int magic_of_irq (int irq)
{
switch (irq) {
case 5:
return 2;
case 7:
return 4;
case 9:
return 1;
case 10:
return 8;
default:
return 2;
}
}
static int irq_of_magic (int magic)
{
switch (magic) {
case 1:
return 9;
case 2:
return 5;
case 4:
return 7;
case 8:
return 10;
default:
return -1;
}
}
#if 0
{
ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
}
#endif
{
/* AUD_enable (s->voice, on); */
}
{
s->dma_running = hold;
#ifndef VBOX
if (hold) {
DMA_hold_DREQ (dma);
}
else {
AUD_set_active_out (s->voice, 0);
}
#else /* VBOX */
if (hold)
{
PDMDevHlpDMASchedule (s->pDevIns);
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
}
else
{
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
AUD_set_active_out (s->voice, 0);
#endif
}
#endif /* VBOX */
}
#ifndef VBOX
{
s->can_write = 1;
}
#else /* VBOX */
{
s->can_write = 1;
}
#endif /* VBOX */
#define DMA8_AUTO 1
#define DMA8_HIGH 2
static void continue_dma8 (SB16State *s)
{
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
int rc;
#endif
if (s->freq > 0) {
s->audio_free = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
rc = s->pDrv->pfnOpenOut(s->pDrv, &s->voice, "sb16", s, SB_audio_callback, s->freq, 1 << s->fmt_stereo,
s->fmt, 0);
#else
as.endianness = 0;
s->voice = AUD_open_out (
&s->card,
s->voice,
"sb16",
s,
&as
);
#endif
}
control (s, 1);
}
{
s->fmt = AUD_FMT_U8;
s->use_hdma = 0;
s->fmt_bits = 8;
s->fmt_signed = 0;
if (-1 == s->time_const) {
if (s->freq <= 0)
s->freq = 11025;
}
else {
}
if (dma_len != -1) {
}
else {
and SecondReality/FC work
Act1 sets block size via command 0x48 and it's an odd number
SR does the same with even number
Both use stereo, and Creatives own documentation states that
0x48 sets block size in bytes less one.. go figure */
s->block_size &= ~s->fmt_stereo;
}
s->freq >>= s->fmt_stereo;
s->left_till_irq = s->block_size;
/* s->highspeed = (mask & DMA8_HIGH) != 0; */
if (s->block_size & s->align) {
LogFlow(("SB16: warning: misaligned block size %d, alignment %d\n",
}
LogFlow(("SB16: freq %d, stereo %d, sign %d, bits %d, "
"dma %d, auto %d, fifo %d, high %d\n",
continue_dma8 (s);
speaker (s, 1);
}
{
switch (cmd >> 4) {
case 11:
s->fmt_bits = 16;
break;
case 12:
s->fmt_bits = 8;
break;
}
if (-1 != s->time_const) {
#if 1
#else
/* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */
#endif
s->time_const = -1;
}
if (!s->dma_auto) {
/* It is clear that for DOOM and auto-init this value
shouldn't take stereo into account, while Miles Sound Systems
setsound.exe with single transfer mode wouldn't work without it
wonders of SB16 yet again */
s->block_size <<= s->fmt_stereo;
}
LogFlow(("SB16: freq %d, stereo %d, sign %d, bits %d, "
"dma %d, auto %d, fifo %d, high %d\n",
if (16 == s->fmt_bits) {
if (s->fmt_signed) {
s->fmt = AUD_FMT_S16;
}
else {
s->fmt = AUD_FMT_U16;
}
}
else {
if (s->fmt_signed) {
s->fmt = AUD_FMT_S8;
}
else {
s->fmt = AUD_FMT_U8;
}
}
s->left_till_irq = s->block_size;
s->highspeed = 0;
if (s->block_size & s->align) {
LogFlow(("SB16: warning: misaligned block size %d, alignment %d\n",
}
if (s->freq) {
s->audio_free = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
int rc;
rc = s->pDrv->pfnOpenOut(s->pDrv, &s->voice, "sb16", s,SB_audio_callback, s->freq, 1 << s->fmt_stereo, s->fmt, 0);
#else
as.endianness = 0;
s->voice = AUD_open_out (
&s->card,
s->voice,
"sb16",
s,
&as
);
#endif
}
control (s, 1);
speaker (s, 1);
}
{
}
}
{
if (s->in_index) {
}
else {
LogFlow(("SB16: buffer underflow\n"));
return 0;
}
}
{
if (cmd & 8) {
}
switch (cmd >> 4) {
case 11:
case 12:
break;
default:
}
s->needed_bytes = 3;
}
else {
s->needed_bytes = 0;
switch (cmd) {
case 0x03:
goto warn;
case 0x04:
s->needed_bytes = 1;
goto warn;
case 0x05:
s->needed_bytes = 2;
goto warn;
case 0x08:
/* __asm__ ("int3"); */
goto warn;
case 0x0e:
s->needed_bytes = 2;
goto warn;
case 0x09:
dsp_out_data (s, 0xf8);
goto warn;
case 0x0f:
s->needed_bytes = 1;
goto warn;
case 0x10:
s->needed_bytes = 1;
goto warn;
case 0x14:
s->needed_bytes = 2;
s->block_size = 0;
break;
case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
break;
dsp_out_data (s, 0xff);
goto warn;
case 0x35:
LogFlow(("SB16: 0x35 - MIDI command not implemented\n"));
break;
case 0x40:
s->freq = -1;
s->time_const = -1;
s->needed_bytes = 1;
break;
case 0x41:
s->freq = -1;
s->time_const = -1;
s->needed_bytes = 2;
break;
case 0x42:
s->freq = -1;
s->time_const = -1;
s->needed_bytes = 2;
goto warn;
case 0x45:
dsp_out_data (s, 0xaa);
goto warn;
case 0x47: /* Continue Auto-Initialize DMA 16bit */
break;
case 0x48:
s->needed_bytes = 2;
break;
case 0x74:
LogFlow(("SB16: 0x75 - DMA DAC, 4-bit ADPCM not implemented\n"));
break;
case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
s->needed_bytes = 2;
LogFlow(("SB16: 0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n"));
break;
case 0x76: /* DMA DAC, 2.6-bit ADPCM */
s->needed_bytes = 2;
LogFlow(("SB16: 0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n"));
break;
case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
s->needed_bytes = 2;
LogFlow(("SB16: 0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n"));
break;
case 0x7d:
LogFlow(("SB16: 0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n"));
LogFlow(("SB16: not implemented\n"));
break;
case 0x7f:
LogFlow(("SB16: 0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"));
LogFlow(("SB16: not implemented\n"));
break;
case 0x80:
s->needed_bytes = 2;
break;
case 0x90:
case 0x91:
break;
case 0xd0: /* halt DMA operation. 8bit */
control (s, 0);
break;
case 0xd1: /* speaker on */
speaker (s, 1);
break;
case 0xd3: /* speaker off */
speaker (s, 0);
break;
case 0xd4: /* continue DMA operation. 8bit */
/* KQ6 (or maybe Sierras audblst.drv in general) resets
continue_dma8 (s);
break;
case 0xd5: /* halt DMA operation. 16bit */
control (s, 0);
break;
case 0xd6: /* continue DMA operation. 16bit */
control (s, 1);
break;
case 0xd9: /* exit auto-init DMA after this block. 16bit */
s->dma_auto = 0;
break;
case 0xda: /* exit auto-init DMA after this block. 8bit */
s->dma_auto = 0;
break;
case 0xe0: /* DSP identification */
s->needed_bytes = 1;
break;
case 0xe1:
break;
case 0xe2:
s->needed_bytes = 1;
goto warn;
case 0xe3:
{
int i;
for (i = sizeof (e3) - 1; i >= 0; --i)
dsp_out_data (s, e3[i]);
}
break;
case 0xe4: /* write test reg */
s->needed_bytes = 1;
break;
case 0xe7:
LogFlow(("SB16: Attempt to probe for ESS (0xe7)?\n"));
break;
case 0xe8: /* read test reg */
dsp_out_data (s, s->test_reg);
break;
case 0xf2:
case 0xf3:
dsp_out_data (s, 0xaa);
#ifndef VBOX
#else
#endif
break;
case 0xf9:
s->needed_bytes = 1;
goto warn;
case 0xfa:
dsp_out_data (s, 0);
goto warn;
case 0xfc: /* FIXME */
dsp_out_data (s, 0);
goto warn;
default:
break;
}
}
if (!s->needed_bytes) {
LogFlow(("\n"));
}
exit:
if (!s->needed_bytes) {
s->cmd = -1;
}
else {
}
return;
warn:
LogFlow(("SB16: warning: command %#x,%d is not truly understood yet\n",
cmd, s->needed_bytes));
goto exit;
}
{
}
{
}
{
LogFlow(("SB16: complete command %#x, in_index %d, needed_bytes %d\n",
d2 = dsp_get_data (s);
d1 = dsp_get_data (s);
d0 = dsp_get_data (s);
if (s->cmd & 8) {
LogFlow(("SB16: ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
}
else {
LogFlow(("SB16: cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
}
}
else {
switch (s->cmd) {
case 0x04:
s->csp_mode = dsp_get_data (s);
s->csp_reg83r = 0;
s->csp_reg83w = 0;
break;
case 0x05:
s->csp_param = dsp_get_data (s);
s->csp_value = dsp_get_data (s);
LogFlow(("SB16: CSP command 0x05: param=%#x value=%#x\n",
s->csp_param,
s->csp_value));
break;
case 0x0e:
d0 = dsp_get_data (s);
d1 = dsp_get_data (s);
if (d1 == 0x83) {
s->csp_reg83r += 1;
}
else {
}
break;
case 0x0f:
d0 = dsp_get_data (s);
LogFlow(("SB16: read CSP register %#x -> %#x, mode=%#x\n",
if (d0 == 0x83) {
LogFlow(("SB16: 0x83[%d] -> %#x\n",
s->csp_reg83w,
s->csp_reg83w += 1;
}
else {
}
break;
case 0x10:
d0 = dsp_get_data (s);
break;
case 0x14:
break;
case 0x40:
s->time_const = dsp_get_data (s);
break;
case 0x42: /* FT2 sets output freq with this, go figure */
#if 0
dolog ("cmd 0x42 might not do what it think it should\n");
#endif
case 0x41:
s->freq = dsp_get_hilo (s);
break;
case 0x48:
break;
case 0x74:
case 0x75:
case 0x76:
case 0x77:
/* ADPCM stuff, ignore */
break;
case 0x80:
{
#ifndef VBOX
}
else {
if (s->aux_ts) {
s->aux_ts,
);
}
}
#else /* VBOX */
else
#endif /* VBOX */
}
break;
case 0xe0:
d0 = dsp_get_data (s);
s->out_data_len = 0;
dsp_out_data (s, ~d0);
break;
case 0xe2:
d0 = dsp_get_data (s);
break;
case 0xe4:
s->test_reg = dsp_get_data (s);
break;
case 0xf9:
d0 = dsp_get_data (s);
switch (d0) {
case 0x0e:
dsp_out_data (s, 0xff);
break;
case 0x0f:
dsp_out_data (s, 0x07);
break;
case 0x37:
dsp_out_data (s, 0x38);
break;
default:
dsp_out_data (s, 0x00);
break;
}
break;
default:
return;
}
}
LogFlow(("\n"));
s->cmd = -1;
return;
}
static void legacy_reset (SB16State *s)
{
s->freq = 11025;
s->fmt_signed = 0;
s->fmt_bits = 8;
s->fmt_stereo = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
int rc;
rc = s->pDrv->pfnOpenOut(s->pDrv, &s->voice, "sb16", s, SB_audio_callback, 11025, 1, AUD_FMT_U8, 0);
#else
as.endianness = 0;
s->voice = AUD_open_out (
&s->card,
s->voice,
"sb16",
s,
&as
);
#endif
/* Not sure about that... */
/* AUD_set_active_out (s->voice, 1); */
}
{
#ifndef VBOX
if (s->dma_auto) {
}
#else /* VBOX */
if (s->dma_auto) {
}
#endif /* VBOX */
s->mixer_regs[0x82] = 0;
s->dma_auto = 0;
s->in_index = 0;
s->out_data_len = 0;
s->left_till_irq = 0;
s->needed_bytes = 0;
s->block_size = -1;
s->nzero = 0;
s->highspeed = 0;
s->v2x6 = 0;
s->cmd = -1;
dsp_out_data(s, 0xaa);
speaker (s, 0);
control (s, 0);
legacy_reset (s);
}
static IO_WRITE_PROTO (dsp_write)
{
switch (iport) {
case 0x06:
switch (val) {
case 0x00:
if (s->v2x6 == 1) {
if (0 && s->highspeed) {
s->highspeed = 0;
#ifndef VBOX
#else
#endif
control (s, 0);
}
else {
reset (s);
}
}
s->v2x6 = 0;
break;
case 0x01:
case 0x03: /* FreeBSD kludge */
s->v2x6 = 1;
break;
case 0xc6:
break;
case 0xb8: /* Panic */
reset (s);
break;
case 0x39:
dsp_out_data (s, 0x38);
reset (s);
s->v2x6 = 0x39;
break;
default:
break;
}
break;
case 0x0c: /* write data or command | write status */
/* if (s->highspeed) */
/* break; */
if (0 == s->needed_bytes) {
#if 0
if (0 == s->needed_bytes) {
log_dsp (s);
}
#endif
}
else {
LogFlow(("SB16: in data overrun\n"));
}
else {
if (s->in_index == s->needed_bytes) {
s->needed_bytes = 0;
complete (s);
#if 0
log_dsp (s);
#endif
}
}
}
break;
default:
break;
}
#ifdef VBOX
return VINF_SUCCESS;
#endif
}
static IO_READ_PROTO (dsp_read)
{
#ifdef VBOX
/** @todo reject non-byte access?
* The spec does not mention a non-byte access so we should check how real hardware behaves. */
#endif
switch (iport) {
case 0x06: /* reset */
retval = 0xff;
break;
case 0x0a: /* read data */
if (s->out_data_len) {
s->last_read_byte = retval;
}
else {
if (s->cmd != -1) {
LogFlow(("SB16: empty output buffer for command %#x\n",
s->cmd));
}
retval = s->last_read_byte;
/* goto error; */
}
break;
case 0x0c: /* 0 can write */
break;
case 0x0d: /* timer interrupt clear */
/* dolog ("timer interrupt clear\n"); */
retval = 0;
break;
case 0x0e: /* data available status | irq 8 ack */
ack = 1;
#ifndef VBOX
#else
#endif
}
break;
case 0x0f: /* irq 16 ack */
retval = 0xff;
ack = 1;
#ifndef VBOX
#else
#endif
}
break;
default:
goto error;
}
if (!ack) {
}
#ifndef VBOX
return retval;
#else
return VINF_SUCCESS;
#endif
#ifndef VBOX
return 0xff;
#else
return VERR_IOM_IOPORT_UNUSED;
#endif
}
static void reset_mixer (SB16State *s)
{
int i;
/* d5=input filt, d3=lowpass filt, d1,d2=input source */
s->mixer_regs[0x0c] = 0;
/* d5=output filt, d1=stereo switch */
s->mixer_regs[0x0e] = 0;
/* voice volume L d5,d7, R d1,d3 */
/* master ... */
/* MIDI ... */
for (i = 0x30; i < 0x48; i++) {
s->mixer_regs[i] = 0x20;
}
}
static IO_WRITE_PROTO(mixer_write_indexb)
{
(void) nport;
s->mixer_nreg = val;
#ifdef VBOX
return VINF_SUCCESS;
#endif
}
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
{
u = ((u&0x55555555) + ((u>>1)&0x55555555));
u = ((u&0x33333333) + ((u>>2)&0x33333333));
u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
u = ( u&0x0000ffff) + (u>>16);
return u;
}
{
return popcount ((u&-u)-1);
}
#endif
static IO_WRITE_PROTO(mixer_write_datab)
{
bool update_master = false;
bool update_voice = false;
(void) nport;
switch (s->mixer_nreg) {
case 0x00:
reset_mixer(s);
/* And update the actual volume, too. */
update_master = true;
update_voice = true;
break;
case 0x04:
/* Translate from old style voice volume (L/R). */
update_voice = true;
break;
case 0x22:
/* Translate from old style master volume (L/R). */
update_master = true;
break;
case 0x30:
/* Translate to old style master volume (L). */
update_master = true;
break;
case 0x31:
/* Translate to old style master volume (R). */
update_master = true;
break;
case 0x32:
/* Translate to old style voice volume (L). */
update_voice = true;
break;
case 0x33:
/* Translate to old style voice volume (R). */
update_voice = true;
break;
case 0x80:
{
if (irq > 0) {
}
}
break;
case 0x81:
{
LogFlow((
"SB16: attempt to change DMA "
"8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
}
#if 0
#endif
}
break;
case 0x82:
LogFlow(("SB16: attempt to write into IRQ status register (val=%#x)\n",
val));
#ifdef VBOX
return VINF_SUCCESS;
#endif
default:
if (s->mixer_nreg >= 0x80) {
}
break;
}
#ifdef VBOX
/* Update the master (mixer) volume. */
if (update_master)
{
int mute = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
/*@todo not passinga audmixer_Ctl values as its not used in DrvAudio.c */
#else
#endif
}
/* Update the voice (PCM) volume. */
if (update_voice)
{
int mute = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
}
#endif /* VBOX */
#ifdef VBOX
return VINF_SUCCESS;
#endif
}
static IO_WRITE_PROTO(mixer_write)
{
#ifndef VBOX
#else /* VBOX */
switch (cb)
{
case 1:
switch (iport)
{
case 4:
break;
case 5:
break;
}
break;
case 2:
break;
default:
break;
}
return VINF_SUCCESS;
#endif /* VBOX */
}
static IO_READ_PROTO(mixer_read)
{
(void) nport;
#ifndef DEBUG_SB16_MOST
if (s->mixer_nreg != 0x82) {
LogFlow(("SB16: mixer_read[%#x] -> %#x\n",
}
#else
LogFlow(("SB16: mixer_read[%#x] -> %#x\n",
#endif
#ifndef VBOX
return s->mixer_regs[s->mixer_nreg];
#else
return VINF_SUCCESS;
#endif
}
{
net = 0;
while (temp) {
#ifndef VBOX
int copied;
#else
#endif
}
#ifndef VBOX
#else
#endif
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
if (!copied) {
break;
}
}
return net;
}
#ifndef VBOX
#else
static DECLCALLBACK(uint32_t) SB_read_DMA (PPDMDEVINS pDevIns, void *opaque, unsigned nchan, uint32_t dma_pos, uint32_t dma_len)
#endif
{
if (s->block_size <= 0) {
LogFlow(("SB16: invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
return dma_pos;
}
if (s->left_till_irq < 0) {
s->left_till_irq = s->block_size;
}
if (s->voice) {
return dma_pos;
}
}
else {
}
till = s->left_till_irq;
#ifdef DEBUG_SB16_MOST
LogFlow(("SB16: pos:%06d %d till:%d len:%d\n",
#endif
if (0 == s->dma_auto) {
} else {
}
}
}
s->left_till_irq -= written;
if (s->left_till_irq <= 0) {
#ifndef VBOX
#else
#endif
if (0 == s->dma_auto) {
control (s, 0);
speaker (s, 0);
}
}
#ifdef DEBUG_SB16_MOST
LogFlow(("SB16: pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
s->block_size));
#endif
while (s->left_till_irq <= 0) {
}
return dma_pos;
}
{
s->audio_free = free;
#ifdef VBOX
/* New space available, see if we can transfer more. There is no cyclic DMA timer in VBox. */
PDMDevHlpDMASchedule (s->pDevIns);
#endif
}
{
#ifndef VBOX
#else
#endif
qemu_put_be32 (f, s->irq);
qemu_put_be32 (f, s->dma);
qemu_put_be32 (f, s->hdma);
qemu_put_be32 (f, s->port);
qemu_put_be32 (f, s->ver);
qemu_put_be32 (f, s->in_index);
qemu_put_be32 (f, s->out_data_len);
qemu_put_be32 (f, s->fmt_stereo);
qemu_put_be32 (f, s->fmt_signed);
qemu_put_be32 (f, s->fmt_bits);
qemu_put_be32s (f, &s->fmt);
qemu_put_be32 (f, s->dma_auto);
qemu_put_be32 (f, s->block_size);
qemu_put_be32 (f, s->fifo);
qemu_put_be32 (f, s->freq);
qemu_put_be32 (f, s->time_const);
qemu_put_be32 (f, s->speaker);
qemu_put_be32 (f, s->needed_bytes);
qemu_put_be32 (f, s->cmd);
qemu_put_be32 (f, s->use_hdma);
qemu_put_be32 (f, s->highspeed);
qemu_put_be32 (f, s->can_write);
qemu_put_be32 (f, s->v2x6);
qemu_put_8s (f, &s->csp_param);
qemu_put_8s (f, &s->csp_value);
qemu_put_8s (f, &s->csp_mode);
qemu_put_8s (f, &s->csp_param);
qemu_put_8s (f, &s->csp_index);
qemu_put_be32 (f, s->csp_reg83r);
qemu_put_be32 (f, s->csp_reg83w);
qemu_put_8s (f, &s->test_reg);
qemu_put_8s (f, &s->last_read_byte);
qemu_put_be32 (f, s->nzero);
qemu_put_be32 (f, s->left_till_irq);
qemu_put_be32 (f, s->dma_running);
qemu_put_be32 (f, s->bytes_per_second);
qemu_put_be32 (f, s->align);
qemu_put_be32 (f, s->mixer_nreg);
}
{
#ifndef VBOX
if (version_id != 1) {
return -EINVAL;
}
#else
#endif
s->irq=qemu_get_be32 (f);
s->dma=qemu_get_be32 (f);
s->hdma=qemu_get_be32 (f);
s->port=qemu_get_be32 (f);
s->ver=qemu_get_be32 (f);
s->in_index=qemu_get_be32 (f);
s->out_data_len=qemu_get_be32 (f);
s->fmt_stereo=qemu_get_be32 (f);
s->fmt_signed=qemu_get_be32 (f);
s->fmt_bits=qemu_get_be32 (f);
s->dma_auto=qemu_get_be32 (f);
s->block_size=qemu_get_be32 (f);
s->fifo=qemu_get_be32 (f);
s->freq=qemu_get_be32 (f);
s->time_const=qemu_get_be32 (f);
s->speaker=qemu_get_be32 (f);
s->needed_bytes=qemu_get_be32 (f);
s->cmd=qemu_get_be32 (f);
s->use_hdma=qemu_get_be32 (f);
s->highspeed=qemu_get_be32 (f);
s->can_write=qemu_get_be32 (f);
s->v2x6=qemu_get_be32 (f);
qemu_get_8s (f, &s->csp_param);
qemu_get_8s (f, &s->csp_value);
qemu_get_8s (f, &s->csp_mode);
qemu_get_8s (f, &s->csp_param);
qemu_get_8s (f, &s->csp_index);
s->csp_reg83r=qemu_get_be32 (f);
s->csp_reg83w=qemu_get_be32 (f);
qemu_get_8s (f, &s->test_reg);
qemu_get_8s (f, &s->last_read_byte);
s->nzero=qemu_get_be32 (f);
s->left_till_irq=qemu_get_be32 (f);
s->dma_running=qemu_get_be32 (f);
s->bytes_per_second=qemu_get_be32 (f);
s->align=qemu_get_be32 (f);
s->mixer_nreg=qemu_get_be32 (f);
if (s->voice) {
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
}
if (s->dma_running) {
if (s->freq) {
s->audio_free = 0;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
int rc;
rc = s->pDrv->pfnOpenOut(s->pDrv, &s->voice, "sb16", s, SB_audio_callback, s->freq, 1 << s->fmt_stereo, s->fmt, 0);
#else
as.endianness = 0;
s->voice = AUD_open_out (
&s->card,
s->voice,
"sb16",
s,
&as
);
#endif
}
control (s, 1);
}
#ifdef VBOX
return VINF_SUCCESS;
#endif
}
#ifndef VBOX
{
SB16State *s;
int i;
if (!audio) {
LogFlow(("SB16: No audio state\n"));
return -1;
}
s = qemu_mallocz (sizeof (*s));
if (!s) {
LogFlow(("SB16: Could not allocate memory for SB16 (%zu bytes)\n",
sizeof (*s)));
return -1;
}
s->cmd = -1;
reset_mixer (s);
if (!s->aux_ts) {
LogFlow(("SB16: warning: Could not create auxiliary timer\n"));
}
for (i = 0; i < LENOFA (dsp_write_ports); i++) {
}
for (i = 0; i < LENOFA (dsp_read_ports); i++) {
}
s->can_write = 1;
return 0;
}
#else /* VBOX */
{
return VINF_SSM_DONT_CALL_AGAIN;
}
{
return VINF_SUCCESS;
}
{
("%u\n", uVersion),
{
}
if (uPass != SSM_PASS_FINAL)
return VINF_SUCCESS;
return VINF_SUCCESS;
}
/**
* @interface_method_impl{PDMIBASE,pfnQueryInterface}
*/
const char *pszIID)
{
return NULL;
}
{
int rc;
/*
* Validations.
*/
"IRQ\0"
"DMA\0"
"DMA16\0"
"Port\0"
"Version\0"))
N_("Invalid configuration for sb16 device"));
/*
* Read config data.
*/
if (RT_FAILURE(rc))
N_("Configuration error: Failed to get the \"IRQ\" value"));
if (RT_FAILURE(rc))
N_("Configuration error: Failed to get the \"DMA\" value"));
if (RT_FAILURE(rc))
N_("Configuration error: Failed to get the \"DMA16\" value"));
if (RT_FAILURE(rc))
N_("Configuration error: Failed to get the \"Port\" value"));
if (RT_FAILURE(rc))
N_("Configuration error: Failed to get the \"Version\" value"));
s->ver = u16Version;
s->verCfg = u16Version;
/*
* Init instance data.
*/
s->cmd = -1;
reset_mixer(s);
/*
* Create timer, register & attach stuff.
*/
if (RT_FAILURE(rc))
if (RT_FAILURE(rc))
return rc;
if (RT_FAILURE(rc))
return rc;
if (RT_FAILURE(rc))
return rc;
if (RT_FAILURE(rc))
return rc;
s->can_write = 1;
rc = PDMDevHlpSSMRegister3(pDevIns, SB16_SAVE_STATE_VERSION, sizeof(*s), sb16LiveExec, sb16SaveExec, sb16LoadExec);
if (RT_FAILURE(rc))
return rc;
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
if(RT_SUCCESS(rc))
{
AssertMsgReturn(s->pDrv,
("Configuration error: instance %d has no host audio interface!\n", iInstance),
}
else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
#else
if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
#endif
Log(("ac97: No attached driver!\n"));
else if (RT_FAILURE(rc))
{
return rc;
}
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
legacy_reset(s);
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
if (!AUD_is_host_voice_out_ok(s->voice))
#endif
{
LogRel (("SB16: WARNING: Unable to open PCM OUT!\n"));
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
#else
#endif
N_("No audio devices could be opened. Selecting the NULL audio backend "
"with the consequence that no sound is audible"));
}
return VINF_SUCCESS;
}
const PDMDEVREG g_DeviceSB16 =
{
/* u32Version */
/* szName */
"sb16",
/* szRCMod */
"",
/* szR0Mod */
"",
/* pszDescription */
"Sound Blaster 16 Controller",
/* fFlags */
/* fClass */
/* cMaxInstances */
1,
/* cbInstance */
sizeof(SB16State),
/* pfnConstruct */
/* pfnDestruct */
NULL,
/* pfnRelocate */
NULL,
/* pfnMemSetup */
NULL,
/* pfnPowerOn */
NULL,
/* pfnReset */
NULL,
/* pfnSuspend */
NULL,
/* pfnResume */
NULL,
/* pfnAttach */
NULL,
/* pfnDetach */
NULL,
/* pfnQueryInterface */
NULL,
/* pfnInitComplete */
NULL,
/* pfnPowerOff */
NULL,
/* pfnSoftReset */
NULL,
/* u32VersionEnd */
};
#endif /* VBOX */