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