Archipelago » qemu

/*

 * LM4549 Audio Codec Interface

 *

 * Copyright (c) 2011

 * Written by Mathieu Sonet - www.elasticsheep.com

 *

 * This code is licensed under the GPL.

 *

 * *****************************************************************

 *

 * This driver emulates the LM4549 codec.

 *

 * It supports only one playback voice and no record voice.

 */

#include "hw/hw.h"

#include "audio/audio.h"

#include "lm4549.h"

#if 0

#define LM4549_DEBUG  1

#endif

#if 0

#define LM4549_DUMP_DAC_INPUT 1

#endif

#ifdef LM4549_DEBUG

#define DPRINTF(fmt, ...) \

do { printf("lm4549: " fmt , ## __VA_ARGS__); } while (0)

#else

#define DPRINTF(fmt, ...) do {} while (0)

#endif

#if defined(LM4549_DUMP_DAC_INPUT)

#include <stdio.h>

static FILE *fp_dac_input;

#endif

/* LM4549 register list */

enum {

    LM4549_Reset                    = 0x00,

    LM4549_Master_Volume            = 0x02,

    LM4549_Line_Out_Volume          = 0x04,

    LM4549_Master_Volume_Mono       = 0x06,

    LM4549_PC_Beep_Volume           = 0x0A,

    LM4549_Phone_Volume             = 0x0C,

    LM4549_Mic_Volume               = 0x0E,

    LM4549_Line_In_Volume           = 0x10,

    LM4549_CD_Volume                = 0x12,

    LM4549_Video_Volume             = 0x14,

    LM4549_Aux_Volume               = 0x16,

    LM4549_PCM_Out_Volume           = 0x18,

    LM4549_Record_Select            = 0x1A,

    LM4549_Record_Gain              = 0x1C,

    LM4549_General_Purpose          = 0x20,

    LM4549_3D_Control               = 0x22,

    LM4549_Powerdown_Ctrl_Stat      = 0x26,

    LM4549_Ext_Audio_ID             = 0x28,

    LM4549_Ext_Audio_Stat_Ctrl      = 0x2A,

    LM4549_PCM_Front_DAC_Rate       = 0x2C,

    LM4549_PCM_ADC_Rate             = 0x32,

    LM4549_Vendor_ID1               = 0x7C,

    LM4549_Vendor_ID2               = 0x7E

};

static void lm4549_reset(lm4549_state *s)

{

    uint16_t *regfile = s->regfile;

    regfile[LM4549_Reset]               = 0x0d50;

    regfile[LM4549_Master_Volume]       = 0x8008;

    regfile[LM4549_Line_Out_Volume]     = 0x8000;

    regfile[LM4549_Master_Volume_Mono]  = 0x8000;

    regfile[LM4549_PC_Beep_Volume]      = 0x0000;

    regfile[LM4549_Phone_Volume]        = 0x8008;

    regfile[LM4549_Mic_Volume]          = 0x8008;

    regfile[LM4549_Line_In_Volume]      = 0x8808;

    regfile[LM4549_CD_Volume]           = 0x8808;

    regfile[LM4549_Video_Volume]        = 0x8808;

    regfile[LM4549_Aux_Volume]          = 0x8808;

    regfile[LM4549_PCM_Out_Volume]      = 0x8808;

    regfile[LM4549_Record_Select]       = 0x0000;

    regfile[LM4549_Record_Gain]         = 0x8000;

    regfile[LM4549_General_Purpose]     = 0x0000;

    regfile[LM4549_3D_Control]          = 0x0101;

    regfile[LM4549_Powerdown_Ctrl_Stat] = 0x000f;

    regfile[LM4549_Ext_Audio_ID]        = 0x0001;

    regfile[LM4549_Ext_Audio_Stat_Ctrl] = 0x0000;

    regfile[LM4549_PCM_Front_DAC_Rate]  = 0xbb80;

    regfile[LM4549_PCM_ADC_Rate]        = 0xbb80;

    regfile[LM4549_Vendor_ID1]          = 0x4e53;

    regfile[LM4549_Vendor_ID2]          = 0x4331;

}

static void lm4549_audio_transfer(lm4549_state *s)

{

    uint32_t written_bytes, written_samples;

    uint32_t i;

    /* Activate the voice */

    AUD_set_active_out(s->voice, 1);

    s->voice_is_active = 1;

    /* Try to write the buffer content */

    written_bytes = AUD_write(s->voice, s->buffer,

                              s->buffer_level * sizeof(uint16_t));

    written_samples = written_bytes >> 1;

#if defined(LM4549_DUMP_DAC_INPUT)

    fwrite(s->buffer, sizeof(uint8_t), written_bytes, fp_dac_input);

#endif

    s->buffer_level -= written_samples;

    if (s->buffer_level > 0) {

        /* Move the data back to the start of the buffer */

        for (i = 0; i < s->buffer_level; i++) {

            s->buffer[i] = s->buffer[i + written_samples];

        }

    }

}

static void lm4549_audio_out_callback(void *opaque, int free)

{

    lm4549_state *s = (lm4549_state *)opaque;

    static uint32_t prev_buffer_level;

#ifdef LM4549_DEBUG

    int size = AUD_get_buffer_size_out(s->voice);

    DPRINTF("audio_out_callback size = %i free = %i\n", size, free);

#endif

    /* Detect that no data are consumed

       => disable the voice */

    if (s->buffer_level == prev_buffer_level) {

        AUD_set_active_out(s->voice, 0);

        s->voice_is_active = 0;

    }

    prev_buffer_level = s->buffer_level;

    /* Check if a buffer transfer is pending */

    if (s->buffer_level == LM4549_BUFFER_SIZE) {

        lm4549_audio_transfer(s);

        /* Request more data */

        if (s->data_req_cb != NULL) {

            (s->data_req_cb)(s->opaque);

        }

    }

}

uint32_t lm4549_read(lm4549_state *s, hwaddr offset)

{

    uint16_t *regfile = s->regfile;

    uint32_t value = 0;

    /* Read the stored value */

    assert(offset < 128);

    value = regfile[offset];

    DPRINTF("read [0x%02x] = 0x%04x\n", offset, value);

    return value;

}

void lm4549_write(lm4549_state *s,

                  hwaddr offset, uint32_t value)

{

    uint16_t *regfile = s->regfile;

    assert(offset < 128);

    DPRINTF("write [0x%02x] = 0x%04x\n", offset, value);

    switch (offset) {

    case LM4549_Reset:

        lm4549_reset(s);

        break;

    case LM4549_PCM_Front_DAC_Rate:

        regfile[LM4549_PCM_Front_DAC_Rate] = value;

        DPRINTF("DAC rate change = %i\n", value);

        /* Re-open a voice with the new sample rate */

        struct audsettings as;

        as.freq = value;

        as.nchannels = 2;

        as.fmt = AUD_FMT_S16;

        as.endianness = 0;

        s->voice = AUD_open_out(

            &s->card,

            s->voice,

            "lm4549.out",

            s,

            lm4549_audio_out_callback,

            &as

        );

        break;

    case LM4549_Powerdown_Ctrl_Stat:

        value &= ~0xf;

        value |= regfile[LM4549_Powerdown_Ctrl_Stat] & 0xf;

        regfile[LM4549_Powerdown_Ctrl_Stat] = value;

        break;

    case LM4549_Ext_Audio_ID:

    case LM4549_Vendor_ID1:

    case LM4549_Vendor_ID2:

        DPRINTF("Write to read-only register 0x%x\n", (int)offset);

        break;

    default:

        /* Store the new value */

        regfile[offset] = value;

        break;

    }

}

uint32_t lm4549_write_samples(lm4549_state *s, uint32_t left, uint32_t right)

{

    /* The left and right samples are in 20-bit resolution.

       The LM4549 has 18-bit resolution and only uses the bits [19:2].

       This model supports 16-bit playback.

    */

    if (s->buffer_level > LM4549_BUFFER_SIZE - 2) {

        DPRINTF("write_sample Buffer full\n");

        return 0;

    }

    /* Store 16-bit samples in the buffer */

    s->buffer[s->buffer_level++] = (left >> 4);

    s->buffer[s->buffer_level++] = (right >> 4);

    if (s->buffer_level == LM4549_BUFFER_SIZE) {

        /* Trigger the transfer of the buffer to the audio host */

        lm4549_audio_transfer(s);

    }

    return 1;

}

static int lm4549_post_load(void *opaque, int version_id)

{

    lm4549_state *s = (lm4549_state *)opaque;

    uint16_t *regfile = s->regfile;

    /* Re-open a voice with the current sample rate */

    uint32_t freq = regfile[LM4549_PCM_Front_DAC_Rate];

    DPRINTF("post_load freq = %i\n", freq);

    DPRINTF("post_load voice_is_active = %i\n", s->voice_is_active);

    struct audsettings as;

    as.freq = freq;

    as.nchannels = 2;

    as.fmt = AUD_FMT_S16;

    as.endianness = 0;

    s->voice = AUD_open_out(

        &s->card,

        s->voice,

        "lm4549.out",

        s,

        lm4549_audio_out_callback,

        &as

    );

    /* Request data */

    if (s->voice_is_active == 1) {

        lm4549_audio_out_callback(s, AUD_get_buffer_size_out(s->voice));

    }

    return 0;

}

void lm4549_init(lm4549_state *s, lm4549_callback data_req_cb, void* opaque)

{

    struct audsettings as;

    /* Store the callback and opaque pointer */

    s->data_req_cb = data_req_cb;

    s->opaque = opaque;

    /* Init the registers */

    lm4549_reset(s);

    /* Register an audio card */

    AUD_register_card("lm4549", &s->card);

    /* Open a default voice */

    as.freq = 48000;

    as.nchannels = 2;

    as.fmt = AUD_FMT_S16;

    as.endianness = 0;

    s->voice = AUD_open_out(

        &s->card,

        s->voice,

        "lm4549.out",

        s,

        lm4549_audio_out_callback,

        &as

    );

    AUD_set_volume_out(s->voice, 0, 255, 255);

    s->voice_is_active = 0;

    /* Reset the input buffer */

    memset(s->buffer, 0x00, sizeof(s->buffer));

    s->buffer_level = 0;

#if defined(LM4549_DUMP_DAC_INPUT)

    fp_dac_input = fopen("lm4549_dac_input.pcm", "wb");

    if (!fp_dac_input) {

        hw_error("Unable to open lm4549_dac_input.pcm for writing\n");

    }

#endif

}

const VMStateDescription vmstate_lm4549_state = {

    .name = "lm4549_state",

    .version_id = 1,

    .minimum_version_id = 1,

    .minimum_version_id_old = 1,

    .post_load = &lm4549_post_load,

    .fields      = (VMStateField[]) {

        VMSTATE_UINT32(voice_is_active, lm4549_state),

        VMSTATE_UINT16_ARRAY(regfile, lm4549_state, 128),

        VMSTATE_UINT16_ARRAY(buffer, lm4549_state, LM4549_BUFFER_SIZE),

        VMSTATE_UINT32(buffer_level, lm4549_state),

        VMSTATE_END_OF_LIST()

    }

};