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