/* * 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 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * 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. */#include "hw.h"#include "audiodev.h"#include "audio/audio.h"#include "isa.h"#include "qemu-timer.h"#define LENOFA(a) ((int) (sizeof(a)/sizeof(a[0])))#define dolog(...) AUD_log ("sb16", __VA_ARGS__)/* #define DEBUG *//* #define DEBUG_SB16_MOST */#ifdef DEBUG#define ldebug(...) dolog (__VA_ARGS__)#else#define ldebug(...)#endif#define IO_READ_PROTO(name)                             \    uint32_t name (void *opaque, uint32_t nport)#define IO_WRITE_PROTO(name)                                    \    void name (void *opaque, uint32_t nport, uint32_t val)static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";static struct {    int ver_lo;    int ver_hi;    int irq;    int dma;    int hdma;    int port;} conf = {5, 4, 5, 1, 5, 0x220};typedef struct SB16State {    QEMUSoundCard card;    qemu_irq *pic;    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;    audfmt_e fmt;    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;    uint8_t csp_param;    uint8_t csp_value;    uint8_t csp_mode;    uint8_t csp_regs[256];    uint8_t csp_index;    uint8_t csp_reg83[4];    int csp_reg83r;    int csp_reg83w;    uint8_t in2_data[10];    uint8_t out_data[50];    uint8_t test_reg;    uint8_t last_read_byte;    int nzero;    int left_till_irq;    int dma_running;    int bytes_per_second;    int align;    int audio_free;    SWVoiceOut *voice;    QEMUTimer *aux_ts;    /* mixer state */    int mixer_nreg;    uint8_t mixer_regs[256];} SB16State;static void SB_audio_callback (void *opaque, int free);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:        dolog ("bad irq %d\n", irq);        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:        dolog ("bad irq magic %d\n", magic);        return -1;    }}#if 0static void log_dsp (SB16State *dsp){    ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",            dsp->fmt_stereo ? "Stereo" : "Mono",            dsp->fmt_signed ? "Signed" : "Unsigned",            dsp->fmt_bits,            dsp->dma_auto ? "Auto" : "Single",            dsp->block_size,            dsp->freq,            dsp->time_const,            dsp->speaker);}#endifstatic void speaker (SB16State *s, int on){    s->speaker = on;    /* AUD_enable (s->voice, on); */}static void control (SB16State *s, int hold){    int dma = s->use_hdma ? s->hdma : s->dma;    s->dma_running = hold;    ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);    if (hold) {        DMA_hold_DREQ (dma);        AUD_set_active_out (s->voice, 1);    }    else {        DMA_release_DREQ (dma);        AUD_set_active_out (s->voice, 0);    }}static void aux_timer (void *opaque){    SB16State *s = opaque;    s->can_write = 1;    qemu_irq_raise (s->pic[s->irq]);}#define DMA8_AUTO 1#define DMA8_HIGH 2static void continue_dma8 (SB16State *s){    if (s->freq > 0) {        audsettings_t as;        s->audio_free = 0;        as.freq = s->freq;        as.nchannels = 1 << s->fmt_stereo;        as.fmt = s->fmt;        as.endianness = 0;        s->voice = AUD_open_out (            &s->card,            s->voice,            "sb16",            s,            SB_audio_callback,            &as            );    }    control (s, 1);}static void dma_cmd8 (SB16State *s, int mask, int dma_len){    s->fmt = AUD_FMT_U8;    s->use_hdma = 0;    s->fmt_bits = 8;    s->fmt_signed = 0;    s->fmt_stereo = (s->mixer_regs[0x0e] & 2) != 0;    if (-1 == s->time_const) {        if (s->freq <= 0)            s->freq = 11025;    }    else {        int tmp = (256 - s->time_const);        s->freq = (1000000 + (tmp / 2)) / tmp;    }    if (dma_len != -1) {        s->block_size = dma_len << s->fmt_stereo;    }    else {        /* This is apparently the only way to make both Act1/PL           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->bytes_per_second = (s->freq << s->fmt_stereo);    /* s->highspeed = (mask & DMA8_HIGH) != 0; */    s->dma_auto = (mask & DMA8_AUTO) != 0;    s->align = (1 << s->fmt_stereo) - 1;    if (s->block_size & s->align) {        dolog ("warning: misaligned block size %d, alignment %d\n",               s->block_size, s->align + 1);    }    ldebug ("freq %d, stereo %d, sign %d, bits %d, "            "dma %d, auto %d, fifo %d, high %d\n",            s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,            s->block_size, s->dma_auto, s->fifo, s->highspeed);    continue_dma8 (s);    speaker (s, 1);}static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len){    s->use_hdma = cmd < 0xc0;    s->fifo = (cmd >> 1) & 1;    s->dma_auto = (cmd >> 2) & 1;    s->fmt_signed = (d0 >> 4) & 1;    s->fmt_stereo = (d0 >> 5) & 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        int tmp = 256 - s->time_const;        s->freq = (1000000 + (tmp / 2)) / tmp;#else        /* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */        s->freq = 1000000 / ((255 - s->time_const));#endif        s->time_const = -1;    }    s->block_size = dma_len + 1;    s->block_size <<= (s->fmt_bits == 16);    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;    }    ldebug ("freq %d, stereo %d, sign %d, bits %d, "            "dma %d, auto %d, fifo %d, high %d\n",            s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,            s->block_size, s->dma_auto, s->fifo, s->highspeed);    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->bytes_per_second = (s->freq << s->fmt_stereo) << (s->fmt_bits == 16);    s->highspeed = 0;    s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;    if (s->block_size & s->align) {        dolog ("warning: misaligned block size %d, alignment %d\n",               s->block_size, s->align + 1);    }    if (s->freq) {        audsettings_t as;        s->audio_free = 0;        as.freq = s->freq;        as.nchannels = 1 << s->fmt_stereo;        as.fmt = s->fmt;        as.endianness = 0;        s->voice = AUD_open_out (            &s->card,            s->voice,            "sb16",            s,            SB_audio_callback,            &as            );    }    control (s, 1);    speaker (s, 1);}static inline void dsp_out_data (SB16State *s, uint8_t val){    ldebug ("outdata %#x\n", val);    if ((size_t) s->out_data_len < sizeof (s->out_data)) {        s->out_data[s->out_data_len++] = val;    }}static inline uint8_t dsp_get_data (SB16State *s){    if (s->in_index) {        return s->in2_data[--s->in_index];    }    else {        dolog ("buffer underflow\n");        return 0;    }}static void command (SB16State *s, uint8_t cmd){    ldebug ("command %#x\n", cmd);    if (cmd > 0xaf && cmd < 0xd0) {        if (cmd & 8) {            dolog ("ADC not yet supported (command %#x)\n", cmd);        }        switch (cmd >> 4) {        case 11:        case 12:            break;        default:            dolog ("%#x wrong bits\n", cmd);        }        s->needed_bytes = 3;    }    else {        s->needed_bytes = 0;        switch (cmd) {        case 0x03:            dsp_out_data (s, 0x10); /* s->csp_param); */            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 */            dma_cmd8 (s, DMA8_AUTO, -1);            break;        case 0x20:              /* Direct ADC, Juice/PL */            dsp_out_data (s, 0xff);            goto warn;        case 0x35:            dolog ("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;