xref: /openbmc/qemu/hw/audio/lm4549.c (revision 3e964275)
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