audio: deprecate -soundhw sb16
[qemu/ar7.git] / hw / audio / hda-codec.c
blobcbd92b72f27cd8f5debf98a30dc6096caad91be1
1 /*
2 * Copyright (C) 2010 Red Hat, Inc.
4 * written by Gerd Hoffmann <kraxel@redhat.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 or
9 * (at your option) version 3 of the License.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "qemu/osdep.h"
21 #include "hw/pci/pci.h"
22 #include "hw/qdev-properties.h"
23 #include "intel-hda.h"
24 #include "migration/vmstate.h"
25 #include "qemu/module.h"
26 #include "intel-hda-defs.h"
27 #include "audio/audio.h"
28 #include "trace.h"
30 /* -------------------------------------------------------------------------- */
32 typedef struct desc_param {
33 uint32_t id;
34 uint32_t val;
35 } desc_param;
37 typedef struct desc_node {
38 uint32_t nid;
39 const char *name;
40 const desc_param *params;
41 uint32_t nparams;
42 uint32_t config;
43 uint32_t pinctl;
44 uint32_t *conn;
45 uint32_t stindex;
46 } desc_node;
48 typedef struct desc_codec {
49 const char *name;
50 uint32_t iid;
51 const desc_node *nodes;
52 uint32_t nnodes;
53 } desc_codec;
55 static const desc_param* hda_codec_find_param(const desc_node *node, uint32_t id)
57 int i;
59 for (i = 0; i < node->nparams; i++) {
60 if (node->params[i].id == id) {
61 return &node->params[i];
64 return NULL;
67 static const desc_node* hda_codec_find_node(const desc_codec *codec, uint32_t nid)
69 int i;
71 for (i = 0; i < codec->nnodes; i++) {
72 if (codec->nodes[i].nid == nid) {
73 return &codec->nodes[i];
76 return NULL;
79 static void hda_codec_parse_fmt(uint32_t format, struct audsettings *as)
81 if (format & AC_FMT_TYPE_NON_PCM) {
82 return;
85 as->freq = (format & AC_FMT_BASE_44K) ? 44100 : 48000;
87 switch ((format & AC_FMT_MULT_MASK) >> AC_FMT_MULT_SHIFT) {
88 case 1: as->freq *= 2; break;
89 case 2: as->freq *= 3; break;
90 case 3: as->freq *= 4; break;
93 switch ((format & AC_FMT_DIV_MASK) >> AC_FMT_DIV_SHIFT) {
94 case 1: as->freq /= 2; break;
95 case 2: as->freq /= 3; break;
96 case 3: as->freq /= 4; break;
97 case 4: as->freq /= 5; break;
98 case 5: as->freq /= 6; break;
99 case 6: as->freq /= 7; break;
100 case 7: as->freq /= 8; break;
103 switch (format & AC_FMT_BITS_MASK) {
104 case AC_FMT_BITS_8: as->fmt = AUDIO_FORMAT_S8; break;
105 case AC_FMT_BITS_16: as->fmt = AUDIO_FORMAT_S16; break;
106 case AC_FMT_BITS_32: as->fmt = AUDIO_FORMAT_S32; break;
109 as->nchannels = ((format & AC_FMT_CHAN_MASK) >> AC_FMT_CHAN_SHIFT) + 1;
112 /* -------------------------------------------------------------------------- */
114 * HDA codec descriptions
117 /* some defines */
119 #define QEMU_HDA_ID_VENDOR 0x1af4
120 #define QEMU_HDA_PCM_FORMATS (AC_SUPPCM_BITS_16 | \
121 0x1fc /* 16 -> 96 kHz */)
122 #define QEMU_HDA_AMP_NONE (0)
123 #define QEMU_HDA_AMP_STEPS 0x4a
125 #define PARAM mixemu
126 #define HDA_MIXER
127 #include "hda-codec-common.h"
129 #define PARAM nomixemu
130 #include "hda-codec-common.h"
132 #define HDA_TIMER_TICKS (SCALE_MS)
133 #define B_SIZE sizeof(st->buf)
134 #define B_MASK (sizeof(st->buf) - 1)
136 /* -------------------------------------------------------------------------- */
138 static const char *fmt2name[] = {
139 [ AUDIO_FORMAT_U8 ] = "PCM-U8",
140 [ AUDIO_FORMAT_S8 ] = "PCM-S8",
141 [ AUDIO_FORMAT_U16 ] = "PCM-U16",
142 [ AUDIO_FORMAT_S16 ] = "PCM-S16",
143 [ AUDIO_FORMAT_U32 ] = "PCM-U32",
144 [ AUDIO_FORMAT_S32 ] = "PCM-S32",
147 typedef struct HDAAudioState HDAAudioState;
148 typedef struct HDAAudioStream HDAAudioStream;
150 struct HDAAudioStream {
151 HDAAudioState *state;
152 const desc_node *node;
153 bool output, running;
154 uint32_t stream;
155 uint32_t channel;
156 uint32_t format;
157 uint32_t gain_left, gain_right;
158 bool mute_left, mute_right;
159 struct audsettings as;
160 union {
161 SWVoiceIn *in;
162 SWVoiceOut *out;
163 } voice;
164 uint8_t compat_buf[HDA_BUFFER_SIZE];
165 uint32_t compat_bpos;
166 uint8_t buf[8192]; /* size must be power of two */
167 int64_t rpos;
168 int64_t wpos;
169 QEMUTimer *buft;
170 int64_t buft_start;
173 #define TYPE_HDA_AUDIO "hda-audio"
174 #define HDA_AUDIO(obj) OBJECT_CHECK(HDAAudioState, (obj), TYPE_HDA_AUDIO)
176 struct HDAAudioState {
177 HDACodecDevice hda;
178 const char *name;
180 QEMUSoundCard card;
181 const desc_codec *desc;
182 HDAAudioStream st[4];
183 bool running_compat[16];
184 bool running_real[2 * 16];
186 /* properties */
187 uint32_t debug;
188 bool mixer;
189 bool use_timer;
192 static inline int64_t hda_bytes_per_second(HDAAudioStream *st)
194 return 2LL * st->as.nchannels * st->as.freq;
197 static inline void hda_timer_sync_adjust(HDAAudioStream *st, int64_t target_pos)
199 int64_t limit = B_SIZE / 8;
200 int64_t corr = 0;
202 if (target_pos > limit) {
203 corr = HDA_TIMER_TICKS;
205 if (target_pos < -limit) {
206 corr = -HDA_TIMER_TICKS;
208 if (target_pos < -(2 * limit)) {
209 corr = -(4 * HDA_TIMER_TICKS);
211 if (corr == 0) {
212 return;
215 trace_hda_audio_adjust(st->node->name, target_pos);
216 st->buft_start += corr;
219 static void hda_audio_input_timer(void *opaque)
221 HDAAudioStream *st = opaque;
223 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
225 int64_t buft_start = st->buft_start;
226 int64_t wpos = st->wpos;
227 int64_t rpos = st->rpos;
229 int64_t wanted_rpos = hda_bytes_per_second(st) * (now - buft_start)
230 / NANOSECONDS_PER_SECOND;
231 wanted_rpos &= -4; /* IMPORTANT! clip to frames */
233 if (wanted_rpos <= rpos) {
234 /* we already transmitted the data */
235 goto out_timer;
238 int64_t to_transfer = MIN(wpos - rpos, wanted_rpos - rpos);
239 while (to_transfer) {
240 uint32_t start = (rpos & B_MASK);
241 uint32_t chunk = MIN(B_SIZE - start, to_transfer);
242 int rc = hda_codec_xfer(
243 &st->state->hda, st->stream, false, st->buf + start, chunk);
244 if (!rc) {
245 break;
247 rpos += chunk;
248 to_transfer -= chunk;
249 st->rpos += chunk;
252 out_timer:
254 if (st->running) {
255 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
259 static void hda_audio_input_cb(void *opaque, int avail)
261 HDAAudioStream *st = opaque;
263 int64_t wpos = st->wpos;
264 int64_t rpos = st->rpos;
266 int64_t to_transfer = MIN(B_SIZE - (wpos - rpos), avail);
268 while (to_transfer) {
269 uint32_t start = (uint32_t) (wpos & B_MASK);
270 uint32_t chunk = (uint32_t) MIN(B_SIZE - start, to_transfer);
271 uint32_t read = AUD_read(st->voice.in, st->buf + start, chunk);
272 wpos += read;
273 to_transfer -= read;
274 st->wpos += read;
275 if (chunk != read) {
276 break;
280 hda_timer_sync_adjust(st, -((wpos - rpos) - (B_SIZE >> 1)));
283 static void hda_audio_output_timer(void *opaque)
285 HDAAudioStream *st = opaque;
287 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
289 int64_t buft_start = st->buft_start;
290 int64_t wpos = st->wpos;
291 int64_t rpos = st->rpos;
293 int64_t wanted_wpos = hda_bytes_per_second(st) * (now - buft_start)
294 / NANOSECONDS_PER_SECOND;
295 wanted_wpos &= -4; /* IMPORTANT! clip to frames */
297 if (wanted_wpos <= wpos) {
298 /* we already received the data */
299 goto out_timer;
302 int64_t to_transfer = MIN(B_SIZE - (wpos - rpos), wanted_wpos - wpos);
303 while (to_transfer) {
304 uint32_t start = (wpos & B_MASK);
305 uint32_t chunk = MIN(B_SIZE - start, to_transfer);
306 int rc = hda_codec_xfer(
307 &st->state->hda, st->stream, true, st->buf + start, chunk);
308 if (!rc) {
309 break;
311 wpos += chunk;
312 to_transfer -= chunk;
313 st->wpos += chunk;
316 out_timer:
318 if (st->running) {
319 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
323 static void hda_audio_output_cb(void *opaque, int avail)
325 HDAAudioStream *st = opaque;
327 int64_t wpos = st->wpos;
328 int64_t rpos = st->rpos;
330 int64_t to_transfer = MIN(wpos - rpos, avail);
332 if (wpos - rpos == B_SIZE) {
333 /* drop buffer, reset timer adjust */
334 st->rpos = 0;
335 st->wpos = 0;
336 st->buft_start = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
337 trace_hda_audio_overrun(st->node->name);
338 return;
341 while (to_transfer) {
342 uint32_t start = (uint32_t) (rpos & B_MASK);
343 uint32_t chunk = (uint32_t) MIN(B_SIZE - start, to_transfer);
344 uint32_t written = AUD_write(st->voice.out, st->buf + start, chunk);
345 rpos += written;
346 to_transfer -= written;
347 st->rpos += written;
348 if (chunk != written) {
349 break;
353 hda_timer_sync_adjust(st, (wpos - rpos) - (B_SIZE >> 1));
356 static void hda_audio_compat_input_cb(void *opaque, int avail)
358 HDAAudioStream *st = opaque;
359 int recv = 0;
360 int len;
361 bool rc;
363 while (avail - recv >= sizeof(st->compat_buf)) {
364 if (st->compat_bpos != sizeof(st->compat_buf)) {
365 len = AUD_read(st->voice.in, st->compat_buf + st->compat_bpos,
366 sizeof(st->compat_buf) - st->compat_bpos);
367 st->compat_bpos += len;
368 recv += len;
369 if (st->compat_bpos != sizeof(st->compat_buf)) {
370 break;
373 rc = hda_codec_xfer(&st->state->hda, st->stream, false,
374 st->compat_buf, sizeof(st->compat_buf));
375 if (!rc) {
376 break;
378 st->compat_bpos = 0;
382 static void hda_audio_compat_output_cb(void *opaque, int avail)
384 HDAAudioStream *st = opaque;
385 int sent = 0;
386 int len;
387 bool rc;
389 while (avail - sent >= sizeof(st->compat_buf)) {
390 if (st->compat_bpos == sizeof(st->compat_buf)) {
391 rc = hda_codec_xfer(&st->state->hda, st->stream, true,
392 st->compat_buf, sizeof(st->compat_buf));
393 if (!rc) {
394 break;
396 st->compat_bpos = 0;
398 len = AUD_write(st->voice.out, st->compat_buf + st->compat_bpos,
399 sizeof(st->compat_buf) - st->compat_bpos);
400 st->compat_bpos += len;
401 sent += len;
402 if (st->compat_bpos != sizeof(st->compat_buf)) {
403 break;
408 static void hda_audio_set_running(HDAAudioStream *st, bool running)
410 if (st->node == NULL) {
411 return;
413 if (st->running == running) {
414 return;
416 st->running = running;
417 trace_hda_audio_running(st->node->name, st->stream, st->running);
418 if (st->state->use_timer) {
419 if (running) {
420 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
421 st->rpos = 0;
422 st->wpos = 0;
423 st->buft_start = now;
424 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
425 } else {
426 timer_del(st->buft);
429 if (st->output) {
430 AUD_set_active_out(st->voice.out, st->running);
431 } else {
432 AUD_set_active_in(st->voice.in, st->running);
436 static void hda_audio_set_amp(HDAAudioStream *st)
438 bool muted;
439 uint32_t left, right;
441 if (st->node == NULL) {
442 return;
445 muted = st->mute_left && st->mute_right;
446 left = st->mute_left ? 0 : st->gain_left;
447 right = st->mute_right ? 0 : st->gain_right;
449 left = left * 255 / QEMU_HDA_AMP_STEPS;
450 right = right * 255 / QEMU_HDA_AMP_STEPS;
452 if (!st->state->mixer) {
453 return;
455 if (st->output) {
456 AUD_set_volume_out(st->voice.out, muted, left, right);
457 } else {
458 AUD_set_volume_in(st->voice.in, muted, left, right);
462 static void hda_audio_setup(HDAAudioStream *st)
464 bool use_timer = st->state->use_timer;
465 audio_callback_fn cb;
467 if (st->node == NULL) {
468 return;
471 trace_hda_audio_format(st->node->name, st->as.nchannels,
472 fmt2name[st->as.fmt], st->as.freq);
474 if (st->output) {
475 if (use_timer) {
476 cb = hda_audio_output_cb;
477 st->buft = timer_new_ns(QEMU_CLOCK_VIRTUAL,
478 hda_audio_output_timer, st);
479 } else {
480 cb = hda_audio_compat_output_cb;
482 st->voice.out = AUD_open_out(&st->state->card, st->voice.out,
483 st->node->name, st, cb, &st->as);
484 } else {
485 if (use_timer) {
486 cb = hda_audio_input_cb;
487 st->buft = timer_new_ns(QEMU_CLOCK_VIRTUAL,
488 hda_audio_input_timer, st);
489 } else {
490 cb = hda_audio_compat_input_cb;
492 st->voice.in = AUD_open_in(&st->state->card, st->voice.in,
493 st->node->name, st, cb, &st->as);
497 static void hda_audio_command(HDACodecDevice *hda, uint32_t nid, uint32_t data)
499 HDAAudioState *a = HDA_AUDIO(hda);
500 HDAAudioStream *st;
501 const desc_node *node = NULL;
502 const desc_param *param;
503 uint32_t verb, payload, response, count, shift;
505 if ((data & 0x70000) == 0x70000) {
506 /* 12/8 id/payload */
507 verb = (data >> 8) & 0xfff;
508 payload = data & 0x00ff;
509 } else {
510 /* 4/16 id/payload */
511 verb = (data >> 8) & 0xf00;
512 payload = data & 0xffff;
515 node = hda_codec_find_node(a->desc, nid);
516 if (node == NULL) {
517 goto fail;
519 dprint(a, 2, "%s: nid %d (%s), verb 0x%x, payload 0x%x\n",
520 __func__, nid, node->name, verb, payload);
522 switch (verb) {
523 /* all nodes */
524 case AC_VERB_PARAMETERS:
525 param = hda_codec_find_param(node, payload);
526 if (param == NULL) {
527 goto fail;
529 hda_codec_response(hda, true, param->val);
530 break;
531 case AC_VERB_GET_SUBSYSTEM_ID:
532 hda_codec_response(hda, true, a->desc->iid);
533 break;
535 /* all functions */
536 case AC_VERB_GET_CONNECT_LIST:
537 param = hda_codec_find_param(node, AC_PAR_CONNLIST_LEN);
538 count = param ? param->val : 0;
539 response = 0;
540 shift = 0;
541 while (payload < count && shift < 32) {
542 response |= node->conn[payload] << shift;
543 payload++;
544 shift += 8;
546 hda_codec_response(hda, true, response);
547 break;
549 /* pin widget */
550 case AC_VERB_GET_CONFIG_DEFAULT:
551 hda_codec_response(hda, true, node->config);
552 break;
553 case AC_VERB_GET_PIN_WIDGET_CONTROL:
554 hda_codec_response(hda, true, node->pinctl);
555 break;
556 case AC_VERB_SET_PIN_WIDGET_CONTROL:
557 if (node->pinctl != payload) {
558 dprint(a, 1, "unhandled pin control bit\n");
560 hda_codec_response(hda, true, 0);
561 break;
563 /* audio in/out widget */
564 case AC_VERB_SET_CHANNEL_STREAMID:
565 st = a->st + node->stindex;
566 if (st->node == NULL) {
567 goto fail;
569 hda_audio_set_running(st, false);
570 st->stream = (payload >> 4) & 0x0f;
571 st->channel = payload & 0x0f;
572 dprint(a, 2, "%s: stream %d, channel %d\n",
573 st->node->name, st->stream, st->channel);
574 hda_audio_set_running(st, a->running_real[st->output * 16 + st->stream]);
575 hda_codec_response(hda, true, 0);
576 break;
577 case AC_VERB_GET_CONV:
578 st = a->st + node->stindex;
579 if (st->node == NULL) {
580 goto fail;
582 response = st->stream << 4 | st->channel;
583 hda_codec_response(hda, true, response);
584 break;
585 case AC_VERB_SET_STREAM_FORMAT:
586 st = a->st + node->stindex;
587 if (st->node == NULL) {
588 goto fail;
590 st->format = payload;
591 hda_codec_parse_fmt(st->format, &st->as);
592 hda_audio_setup(st);
593 hda_codec_response(hda, true, 0);
594 break;
595 case AC_VERB_GET_STREAM_FORMAT:
596 st = a->st + node->stindex;
597 if (st->node == NULL) {
598 goto fail;
600 hda_codec_response(hda, true, st->format);
601 break;
602 case AC_VERB_GET_AMP_GAIN_MUTE:
603 st = a->st + node->stindex;
604 if (st->node == NULL) {
605 goto fail;
607 if (payload & AC_AMP_GET_LEFT) {
608 response = st->gain_left | (st->mute_left ? AC_AMP_MUTE : 0);
609 } else {
610 response = st->gain_right | (st->mute_right ? AC_AMP_MUTE : 0);
612 hda_codec_response(hda, true, response);
613 break;
614 case AC_VERB_SET_AMP_GAIN_MUTE:
615 st = a->st + node->stindex;
616 if (st->node == NULL) {
617 goto fail;
619 dprint(a, 1, "amp (%s): %s%s%s%s index %d gain %3d %s\n",
620 st->node->name,
621 (payload & AC_AMP_SET_OUTPUT) ? "o" : "-",
622 (payload & AC_AMP_SET_INPUT) ? "i" : "-",
623 (payload & AC_AMP_SET_LEFT) ? "l" : "-",
624 (payload & AC_AMP_SET_RIGHT) ? "r" : "-",
625 (payload & AC_AMP_SET_INDEX) >> AC_AMP_SET_INDEX_SHIFT,
626 (payload & AC_AMP_GAIN),
627 (payload & AC_AMP_MUTE) ? "muted" : "");
628 if (payload & AC_AMP_SET_LEFT) {
629 st->gain_left = payload & AC_AMP_GAIN;
630 st->mute_left = payload & AC_AMP_MUTE;
632 if (payload & AC_AMP_SET_RIGHT) {
633 st->gain_right = payload & AC_AMP_GAIN;
634 st->mute_right = payload & AC_AMP_MUTE;
636 hda_audio_set_amp(st);
637 hda_codec_response(hda, true, 0);
638 break;
640 /* not supported */
641 case AC_VERB_SET_POWER_STATE:
642 case AC_VERB_GET_POWER_STATE:
643 case AC_VERB_GET_SDI_SELECT:
644 hda_codec_response(hda, true, 0);
645 break;
646 default:
647 goto fail;
649 return;
651 fail:
652 dprint(a, 1, "%s: not handled: nid %d (%s), verb 0x%x, payload 0x%x\n",
653 __func__, nid, node ? node->name : "?", verb, payload);
654 hda_codec_response(hda, true, 0);
657 static void hda_audio_stream(HDACodecDevice *hda, uint32_t stnr, bool running, bool output)
659 HDAAudioState *a = HDA_AUDIO(hda);
660 int s;
662 a->running_compat[stnr] = running;
663 a->running_real[output * 16 + stnr] = running;
664 for (s = 0; s < ARRAY_SIZE(a->st); s++) {
665 if (a->st[s].node == NULL) {
666 continue;
668 if (a->st[s].output != output) {
669 continue;
671 if (a->st[s].stream != stnr) {
672 continue;
674 hda_audio_set_running(&a->st[s], running);
678 static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc)
680 HDAAudioState *a = HDA_AUDIO(hda);
681 HDAAudioStream *st;
682 const desc_node *node;
683 const desc_param *param;
684 uint32_t i, type;
686 a->desc = desc;
687 a->name = object_get_typename(OBJECT(a));
688 dprint(a, 1, "%s: cad %d\n", __func__, a->hda.cad);
690 AUD_register_card("hda", &a->card);
691 for (i = 0; i < a->desc->nnodes; i++) {
692 node = a->desc->nodes + i;
693 param = hda_codec_find_param(node, AC_PAR_AUDIO_WIDGET_CAP);
694 if (param == NULL) {
695 continue;
697 type = (param->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
698 switch (type) {
699 case AC_WID_AUD_OUT:
700 case AC_WID_AUD_IN:
701 assert(node->stindex < ARRAY_SIZE(a->st));
702 st = a->st + node->stindex;
703 st->state = a;
704 st->node = node;
705 if (type == AC_WID_AUD_OUT) {
706 /* unmute output by default */
707 st->gain_left = QEMU_HDA_AMP_STEPS;
708 st->gain_right = QEMU_HDA_AMP_STEPS;
709 st->compat_bpos = sizeof(st->compat_buf);
710 st->output = true;
711 } else {
712 st->output = false;
714 st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
715 (1 << AC_FMT_CHAN_SHIFT);
716 hda_codec_parse_fmt(st->format, &st->as);
717 hda_audio_setup(st);
718 break;
721 return 0;
724 static void hda_audio_exit(HDACodecDevice *hda)
726 HDAAudioState *a = HDA_AUDIO(hda);
727 HDAAudioStream *st;
728 int i;
730 dprint(a, 1, "%s\n", __func__);
731 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
732 st = a->st + i;
733 if (st->node == NULL) {
734 continue;
736 if (a->use_timer) {
737 timer_del(st->buft);
739 if (st->output) {
740 AUD_close_out(&a->card, st->voice.out);
741 } else {
742 AUD_close_in(&a->card, st->voice.in);
745 AUD_remove_card(&a->card);
748 static int hda_audio_post_load(void *opaque, int version)
750 HDAAudioState *a = opaque;
751 HDAAudioStream *st;
752 int i;
754 dprint(a, 1, "%s\n", __func__);
755 if (version == 1) {
756 /* assume running_compat[] is for output streams */
757 for (i = 0; i < ARRAY_SIZE(a->running_compat); i++)
758 a->running_real[16 + i] = a->running_compat[i];
761 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
762 st = a->st + i;
763 if (st->node == NULL)
764 continue;
765 hda_codec_parse_fmt(st->format, &st->as);
766 hda_audio_setup(st);
767 hda_audio_set_amp(st);
768 hda_audio_set_running(st, a->running_real[st->output * 16 + st->stream]);
770 return 0;
773 static void hda_audio_reset(DeviceState *dev)
775 HDAAudioState *a = HDA_AUDIO(dev);
776 HDAAudioStream *st;
777 int i;
779 dprint(a, 1, "%s\n", __func__);
780 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
781 st = a->st + i;
782 if (st->node != NULL) {
783 hda_audio_set_running(st, false);
788 static bool vmstate_hda_audio_stream_buf_needed(void *opaque)
790 HDAAudioStream *st = opaque;
791 return st->state && st->state->use_timer;
794 static const VMStateDescription vmstate_hda_audio_stream_buf = {
795 .name = "hda-audio-stream/buffer",
796 .version_id = 1,
797 .needed = vmstate_hda_audio_stream_buf_needed,
798 .fields = (VMStateField[]) {
799 VMSTATE_BUFFER(buf, HDAAudioStream),
800 VMSTATE_INT64(rpos, HDAAudioStream),
801 VMSTATE_INT64(wpos, HDAAudioStream),
802 VMSTATE_TIMER_PTR(buft, HDAAudioStream),
803 VMSTATE_INT64(buft_start, HDAAudioStream),
804 VMSTATE_END_OF_LIST()
808 static const VMStateDescription vmstate_hda_audio_stream = {
809 .name = "hda-audio-stream",
810 .version_id = 1,
811 .fields = (VMStateField[]) {
812 VMSTATE_UINT32(stream, HDAAudioStream),
813 VMSTATE_UINT32(channel, HDAAudioStream),
814 VMSTATE_UINT32(format, HDAAudioStream),
815 VMSTATE_UINT32(gain_left, HDAAudioStream),
816 VMSTATE_UINT32(gain_right, HDAAudioStream),
817 VMSTATE_BOOL(mute_left, HDAAudioStream),
818 VMSTATE_BOOL(mute_right, HDAAudioStream),
819 VMSTATE_UINT32(compat_bpos, HDAAudioStream),
820 VMSTATE_BUFFER(compat_buf, HDAAudioStream),
821 VMSTATE_END_OF_LIST()
823 .subsections = (const VMStateDescription * []) {
824 &vmstate_hda_audio_stream_buf,
825 NULL
829 static const VMStateDescription vmstate_hda_audio = {
830 .name = "hda-audio",
831 .version_id = 2,
832 .post_load = hda_audio_post_load,
833 .fields = (VMStateField[]) {
834 VMSTATE_STRUCT_ARRAY(st, HDAAudioState, 4, 0,
835 vmstate_hda_audio_stream,
836 HDAAudioStream),
837 VMSTATE_BOOL_ARRAY(running_compat, HDAAudioState, 16),
838 VMSTATE_BOOL_ARRAY_V(running_real, HDAAudioState, 2 * 16, 2),
839 VMSTATE_END_OF_LIST()
843 static Property hda_audio_properties[] = {
844 DEFINE_AUDIO_PROPERTIES(HDAAudioState, card),
845 DEFINE_PROP_UINT32("debug", HDAAudioState, debug, 0),
846 DEFINE_PROP_BOOL("mixer", HDAAudioState, mixer, true),
847 DEFINE_PROP_BOOL("use-timer", HDAAudioState, use_timer, true),
848 DEFINE_PROP_END_OF_LIST(),
851 static int hda_audio_init_output(HDACodecDevice *hda)
853 HDAAudioState *a = HDA_AUDIO(hda);
855 if (!a->mixer) {
856 return hda_audio_init(hda, &output_nomixemu);
857 } else {
858 return hda_audio_init(hda, &output_mixemu);
862 static int hda_audio_init_duplex(HDACodecDevice *hda)
864 HDAAudioState *a = HDA_AUDIO(hda);
866 if (!a->mixer) {
867 return hda_audio_init(hda, &duplex_nomixemu);
868 } else {
869 return hda_audio_init(hda, &duplex_mixemu);
873 static int hda_audio_init_micro(HDACodecDevice *hda)
875 HDAAudioState *a = HDA_AUDIO(hda);
877 if (!a->mixer) {
878 return hda_audio_init(hda, &micro_nomixemu);
879 } else {
880 return hda_audio_init(hda, &micro_mixemu);
884 static void hda_audio_base_class_init(ObjectClass *klass, void *data)
886 DeviceClass *dc = DEVICE_CLASS(klass);
887 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
889 k->exit = hda_audio_exit;
890 k->command = hda_audio_command;
891 k->stream = hda_audio_stream;
892 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
893 dc->reset = hda_audio_reset;
894 dc->vmsd = &vmstate_hda_audio;
895 device_class_set_props(dc, hda_audio_properties);
898 static const TypeInfo hda_audio_info = {
899 .name = TYPE_HDA_AUDIO,
900 .parent = TYPE_HDA_CODEC_DEVICE,
901 .class_init = hda_audio_base_class_init,
902 .abstract = true,
905 static void hda_audio_output_class_init(ObjectClass *klass, void *data)
907 DeviceClass *dc = DEVICE_CLASS(klass);
908 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
910 k->init = hda_audio_init_output;
911 dc->desc = "HDA Audio Codec, output-only (line-out)";
914 static const TypeInfo hda_audio_output_info = {
915 .name = "hda-output",
916 .parent = TYPE_HDA_AUDIO,
917 .instance_size = sizeof(HDAAudioState),
918 .class_init = hda_audio_output_class_init,
921 static void hda_audio_duplex_class_init(ObjectClass *klass, void *data)
923 DeviceClass *dc = DEVICE_CLASS(klass);
924 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
926 k->init = hda_audio_init_duplex;
927 dc->desc = "HDA Audio Codec, duplex (line-out, line-in)";
930 static const TypeInfo hda_audio_duplex_info = {
931 .name = "hda-duplex",
932 .parent = TYPE_HDA_AUDIO,
933 .instance_size = sizeof(HDAAudioState),
934 .class_init = hda_audio_duplex_class_init,
937 static void hda_audio_micro_class_init(ObjectClass *klass, void *data)
939 DeviceClass *dc = DEVICE_CLASS(klass);
940 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
942 k->init = hda_audio_init_micro;
943 dc->desc = "HDA Audio Codec, duplex (speaker, microphone)";
946 static const TypeInfo hda_audio_micro_info = {
947 .name = "hda-micro",
948 .parent = TYPE_HDA_AUDIO,
949 .instance_size = sizeof(HDAAudioState),
950 .class_init = hda_audio_micro_class_init,
953 static void hda_audio_register_types(void)
955 type_register_static(&hda_audio_info);
956 type_register_static(&hda_audio_output_info);
957 type_register_static(&hda_audio_duplex_info);
958 type_register_static(&hda_audio_micro_info);
961 type_init(hda_audio_register_types)