qemu

1
/*
2
 * LM4549 Audio Codec Interface
3
 *
4
 * Copyright (c) 2011
5
 * Written by Mathieu Sonet - www.elasticsheep.com
6
 *
7
 * This code is licensed under the GPL.
8
 *
9
 * *****************************************************************
10
 *
11
 * This driver emulates the LM4549 codec.
12
 *
13
 * It supports only one playback voice and no record voice.
14
 */
15

16
#include "qemu/osdep.h"
17
#include "hw/hw.h"
18
#include "audio/audio.h"
19
#include "lm4549.h"
20
#include "migration/vmstate.h"
21

22
#if 0
23
#define LM4549_DEBUG  1
24
#endif
25

26
#if 0
27
#define LM4549_DUMP_DAC_INPUT 1
28
#endif
29

30
#ifdef LM4549_DEBUG
31
#define DPRINTF(fmt, ...) \
32
do { printf("lm4549: " fmt , ## __VA_ARGS__); } while (0)
33
#else
34
#define DPRINTF(fmt, ...) do {} while (0)
35
#endif
36

37
#if defined(LM4549_DUMP_DAC_INPUT)
38
static FILE *fp_dac_input;
39
#endif
40

41
/* LM4549 register list */
42
enum {
43
    LM4549_Reset                    = 0x00,
44
    LM4549_Master_Volume            = 0x02,
45
    LM4549_Line_Out_Volume          = 0x04,
46
    LM4549_Master_Volume_Mono       = 0x06,
47
    LM4549_PC_Beep_Volume           = 0x0A,
48
    LM4549_Phone_Volume             = 0x0C,
49
    LM4549_Mic_Volume               = 0x0E,
50
    LM4549_Line_In_Volume           = 0x10,
51
    LM4549_CD_Volume                = 0x12,
52
    LM4549_Video_Volume             = 0x14,
53
    LM4549_Aux_Volume               = 0x16,
54
    LM4549_PCM_Out_Volume           = 0x18,
55
    LM4549_Record_Select            = 0x1A,
56
    LM4549_Record_Gain              = 0x1C,
57
    LM4549_General_Purpose          = 0x20,
58
    LM4549_3D_Control               = 0x22,
59
    LM4549_Powerdown_Ctrl_Stat      = 0x26,
60
    LM4549_Ext_Audio_ID             = 0x28,
61
    LM4549_Ext_Audio_Stat_Ctrl      = 0x2A,
62
    LM4549_PCM_Front_DAC_Rate       = 0x2C,
63
    LM4549_PCM_ADC_Rate             = 0x32,
64
    LM4549_Vendor_ID1               = 0x7C,
65
    LM4549_Vendor_ID2               = 0x7E
66
};
67

68
static void lm4549_reset(lm4549_state *s)
69
{
70
    uint16_t *regfile = s->regfile;
71

72
    regfile[LM4549_Reset]               = 0x0d50;
73
    regfile[LM4549_Master_Volume]       = 0x8008;
74
    regfile[LM4549_Line_Out_Volume]     = 0x8000;
75
    regfile[LM4549_Master_Volume_Mono]  = 0x8000;
76
    regfile[LM4549_PC_Beep_Volume]      = 0x0000;
77
    regfile[LM4549_Phone_Volume]        = 0x8008;
78
    regfile[LM4549_Mic_Volume]          = 0x8008;
79
    regfile[LM4549_Line_In_Volume]      = 0x8808;
80
    regfile[LM4549_CD_Volume]           = 0x8808;
81
    regfile[LM4549_Video_Volume]        = 0x8808;
82
    regfile[LM4549_Aux_Volume]          = 0x8808;
83
    regfile[LM4549_PCM_Out_Volume]      = 0x8808;
84
    regfile[LM4549_Record_Select]       = 0x0000;
85
    regfile[LM4549_Record_Gain]         = 0x8000;
86
    regfile[LM4549_General_Purpose]     = 0x0000;
87
    regfile[LM4549_3D_Control]          = 0x0101;
88
    regfile[LM4549_Powerdown_Ctrl_Stat] = 0x000f;
89
    regfile[LM4549_Ext_Audio_ID]        = 0x0001;
90
    regfile[LM4549_Ext_Audio_Stat_Ctrl] = 0x0000;
91
    regfile[LM4549_PCM_Front_DAC_Rate]  = 0xbb80;
92
    regfile[LM4549_PCM_ADC_Rate]        = 0xbb80;
93
    regfile[LM4549_Vendor_ID1]          = 0x4e53;
94
    regfile[LM4549_Vendor_ID2]          = 0x4331;
95
}
96

97
static void lm4549_audio_transfer(lm4549_state *s)
98
{
99
    uint32_t written_bytes, written_samples;
100
    uint32_t i;
101

102
    /* Activate the voice */
103
    AUD_set_active_out(s->voice, 1);
104
    s->voice_is_active = 1;
105

106
    /* Try to write the buffer content */
107
    written_bytes = AUD_write(s->voice, s->buffer,
108
                              s->buffer_level * sizeof(uint16_t));
109
    written_samples = written_bytes >> 1;
110

111
#if defined(LM4549_DUMP_DAC_INPUT)
112
    fwrite(s->buffer, sizeof(uint8_t), written_bytes, fp_dac_input);
113
#endif
114

115
    s->buffer_level -= written_samples;
116

117
    if (s->buffer_level > 0) {
118
        /* Move the data back to the start of the buffer */
119
        for (i = 0; i < s->buffer_level; i++) {
120
            s->buffer[i] = s->buffer[i + written_samples];
121
        }
122
    }
123
}
124

125
static void lm4549_audio_out_callback(void *opaque, int free)
126
{
127
    lm4549_state *s = (lm4549_state *)opaque;
128
    static uint32_t prev_buffer_level;
129

130
#ifdef LM4549_DEBUG
131
    int size = AUD_get_buffer_size_out(s->voice);
132
    DPRINTF("audio_out_callback size = %i free = %i\n", size, free);
133
#endif
134

135
    /* Detect that no data are consumed
136
       => disable the voice */
137
    if (s->buffer_level == prev_buffer_level) {
138
        AUD_set_active_out(s->voice, 0);
139
        s->voice_is_active = 0;
140
    }
141
    prev_buffer_level = s->buffer_level;
142

143
    /* Check if a buffer transfer is pending */
144
    if (s->buffer_level == LM4549_BUFFER_SIZE) {
145
        lm4549_audio_transfer(s);
146

147
        /* Request more data */
148
        if (s->data_req_cb != NULL) {
149
            (s->data_req_cb)(s->opaque);
150
        }
151
    }
152
}
153

154
uint32_t lm4549_read(lm4549_state *s, hwaddr offset)
155
{
156
    uint16_t *regfile = s->regfile;
157
    uint32_t value = 0;
158

159
    /* Read the stored value */
160
    assert(offset < 128);
161
    value = regfile[offset];
162

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

165
    return value;
166
}
167

168
void lm4549_write(lm4549_state *s,
169
                  hwaddr offset, uint32_t value)
170
{
171
    uint16_t *regfile = s->regfile;
172

173
    assert(offset < 128);
174
    DPRINTF("write [0x%02x] = 0x%04x\n", offset, value);
175

176
    switch (offset) {
177
    case LM4549_Reset:
178
        lm4549_reset(s);
179
        break;
180

181
    case LM4549_PCM_Front_DAC_Rate:
182
        regfile[LM4549_PCM_Front_DAC_Rate] = value;
183
        DPRINTF("DAC rate change = %i\n", value);
184

185
        /* Re-open a voice with the new sample rate */
186
        struct audsettings as;
187
        as.freq = value;
188
        as.nchannels = 2;
189
        as.fmt = AUDIO_FORMAT_S16;
190
        as.endianness = 0;
191

192
        s->voice = AUD_open_out(
193
            &s->card,
194
            s->voice,
195
            "lm4549.out",
196
            s,
197
            lm4549_audio_out_callback,
198
            &as
199
        );
200
        break;
201

202
    case LM4549_Powerdown_Ctrl_Stat:
203
        value &= ~0xf;
204
        value |= regfile[LM4549_Powerdown_Ctrl_Stat] & 0xf;
205
        regfile[LM4549_Powerdown_Ctrl_Stat] = value;
206
        break;
207

208
    case LM4549_Ext_Audio_ID:
209
    case LM4549_Vendor_ID1:
210
    case LM4549_Vendor_ID2:
211
        DPRINTF("Write to read-only register 0x%x\n", (int)offset);
212
        break;
213

214
    default:
215
        /* Store the new value */
216
        regfile[offset] = value;
217
        break;
218
    }
219
}
220

221
uint32_t lm4549_write_samples(lm4549_state *s, uint32_t left, uint32_t right)
222
{
223
    /* The left and right samples are in 20-bit resolution.
224
       The LM4549 has 18-bit resolution and only uses the bits [19:2].
225
       This model supports 16-bit playback.
226
    */
227

228
    if (s->buffer_level > LM4549_BUFFER_SIZE - 2) {
229
        DPRINTF("write_sample Buffer full\n");
230
        return 0;
231
    }
232

233
    /* Store 16-bit samples in the buffer */
234
    s->buffer[s->buffer_level++] = (left >> 4);
235
    s->buffer[s->buffer_level++] = (right >> 4);
236

237
    if (s->buffer_level == LM4549_BUFFER_SIZE) {
238
        /* Trigger the transfer of the buffer to the audio host */
239
        lm4549_audio_transfer(s);
240
    }
241

242
    return 1;
243
}
244

245
static int lm4549_post_load(void *opaque, int version_id)
246
{
247
    lm4549_state *s = (lm4549_state *)opaque;
248
    uint16_t *regfile = s->regfile;
249

250
    /* Re-open a voice with the current sample rate */
251
    uint32_t freq = regfile[LM4549_PCM_Front_DAC_Rate];
252

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

256
    struct audsettings as;
257
    as.freq = freq;
258
    as.nchannels = 2;
259
    as.fmt = AUDIO_FORMAT_S16;
260
    as.endianness = 0;
261

262
    s->voice = AUD_open_out(
263
        &s->card,
264
        s->voice,
265
        "lm4549.out",
266
        s,
267
        lm4549_audio_out_callback,
268
        &as
269
    );
270

271
    /* Request data */
272
    if (s->voice_is_active == 1) {
273
        lm4549_audio_out_callback(s, AUD_get_buffer_size_out(s->voice));
274
    }
275

276
    return 0;
277
}
278

279
void lm4549_init(lm4549_state *s, lm4549_callback data_req_cb, void* opaque,
280
                 Error **errp)
281
{
282
    struct audsettings as;
283

284
    /* Register an audio card */
285
    if (!AUD_register_card("lm4549", &s->card, errp)) {
286
        return;
287
    }
288

289
    /* Store the callback and opaque pointer */
290
    s->data_req_cb = data_req_cb;
291
    s->opaque = opaque;
292

293
    /* Init the registers */
294
    lm4549_reset(s);
295

296
    /* Open a default voice */
297
    as.freq = 48000;
298
    as.nchannels = 2;
299
    as.fmt = AUDIO_FORMAT_S16;
300
    as.endianness = 0;
301

302
    s->voice = AUD_open_out(
303
        &s->card,
304
        s->voice,
305
        "lm4549.out",
306
        s,
307
        lm4549_audio_out_callback,
308
        &as
309
    );
310

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

313
    s->voice_is_active = 0;
314

315
    /* Reset the input buffer */
316
    memset(s->buffer, 0x00, sizeof(s->buffer));
317
    s->buffer_level = 0;
318

319
#if defined(LM4549_DUMP_DAC_INPUT)
320
    fp_dac_input = fopen("lm4549_dac_input.pcm", "wb");
321
    if (!fp_dac_input) {
322
        hw_error("Unable to open lm4549_dac_input.pcm for writing\n");
323
    }
324
#endif
325
}
326

327
const VMStateDescription vmstate_lm4549_state = {
328
    .name = "lm4549_state",
329
    .version_id = 1,
330
    .minimum_version_id = 1,
331
    .post_load = lm4549_post_load,
332
    .fields = (const VMStateField[]) {
333
        VMSTATE_UINT32(voice_is_active, lm4549_state),
334
        VMSTATE_UINT16_ARRAY(regfile, lm4549_state, 128),
335
        VMSTATE_UINT16_ARRAY(buffer, lm4549_state, LM4549_BUFFER_SIZE),
336
        VMSTATE_UINT32(buffer_level, lm4549_state),
337
        VMSTATE_END_OF_LIST()
338
    }
339
};
340