mirror of
https://github.com/qemu/qemu.git
synced 2024-12-11 12:43:55 +08:00
a8170e5e97
target_phys_addr_t is unwieldly, violates the C standard (_t suffixes are
reserved) and its purpose doesn't match the name (most target_phys_addr_t
addresses are not target specific). Replace it with a finger-friendly,
standards conformant hwaddr.
Outstanding patchsets can be fixed up with the command
git rebase -i --exec 'find -name "*.[ch]"
| xargs s/target_phys_addr_t/hwaddr/g' origin
Signed-off-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
337 lines
9.0 KiB
C
337 lines
9.0 KiB
C
/*
|
|
* 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.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()
|
|
}
|
|
};
|