1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "hw/hw.h"
22#include "hw/pci/pci.h"
23#include "intel-hda.h"
24#include "qemu/module.h"
25#include "intel-hda-defs.h"
26#include "audio/audio.h"
27#include "trace.h"
28
29
30
31typedef struct desc_param {
32 uint32_t id;
33 uint32_t val;
34} desc_param;
35
36typedef struct desc_node {
37 uint32_t nid;
38 const char *name;
39 const desc_param *params;
40 uint32_t nparams;
41 uint32_t config;
42 uint32_t pinctl;
43 uint32_t *conn;
44 uint32_t stindex;
45} desc_node;
46
47typedef struct desc_codec {
48 const char *name;
49 uint32_t iid;
50 const desc_node *nodes;
51 uint32_t nnodes;
52} desc_codec;
53
54static const desc_param* hda_codec_find_param(const desc_node *node, uint32_t id)
55{
56 int i;
57
58 for (i = 0; i < node->nparams; i++) {
59 if (node->params[i].id == id) {
60 return &node->params[i];
61 }
62 }
63 return NULL;
64}
65
66static const desc_node* hda_codec_find_node(const desc_codec *codec, uint32_t nid)
67{
68 int i;
69
70 for (i = 0; i < codec->nnodes; i++) {
71 if (codec->nodes[i].nid == nid) {
72 return &codec->nodes[i];
73 }
74 }
75 return NULL;
76}
77
78static void hda_codec_parse_fmt(uint32_t format, struct audsettings *as)
79{
80 if (format & AC_FMT_TYPE_NON_PCM) {
81 return;
82 }
83
84 as->freq = (format & AC_FMT_BASE_44K) ? 44100 : 48000;
85
86 switch ((format & AC_FMT_MULT_MASK) >> AC_FMT_MULT_SHIFT) {
87 case 1: as->freq *= 2; break;
88 case 2: as->freq *= 3; break;
89 case 3: as->freq *= 4; break;
90 }
91
92 switch ((format & AC_FMT_DIV_MASK) >> AC_FMT_DIV_SHIFT) {
93 case 1: as->freq /= 2; break;
94 case 2: as->freq /= 3; break;
95 case 3: as->freq /= 4; break;
96 case 4: as->freq /= 5; break;
97 case 5: as->freq /= 6; break;
98 case 6: as->freq /= 7; break;
99 case 7: as->freq /= 8; break;
100 }
101
102 switch (format & AC_FMT_BITS_MASK) {
103 case AC_FMT_BITS_8: as->fmt = AUDIO_FORMAT_S8; break;
104 case AC_FMT_BITS_16: as->fmt = AUDIO_FORMAT_S16; break;
105 case AC_FMT_BITS_32: as->fmt = AUDIO_FORMAT_S32; break;
106 }
107
108 as->nchannels = ((format & AC_FMT_CHAN_MASK) >> AC_FMT_CHAN_SHIFT) + 1;
109}
110
111
112
113
114
115
116
117
118#define QEMU_HDA_ID_VENDOR 0x1af4
119#define QEMU_HDA_PCM_FORMATS (AC_SUPPCM_BITS_16 | \
120 0x1fc )
121#define QEMU_HDA_AMP_NONE (0)
122#define QEMU_HDA_AMP_STEPS 0x4a
123
124#define PARAM mixemu
125#define HDA_MIXER
126#include "hda-codec-common.h"
127
128#define PARAM nomixemu
129#include "hda-codec-common.h"
130
131#define HDA_TIMER_TICKS (SCALE_MS)
132#define B_SIZE sizeof(st->buf)
133#define B_MASK (sizeof(st->buf) - 1)
134
135
136
137static const char *fmt2name[] = {
138 [ AUDIO_FORMAT_U8 ] = "PCM-U8",
139 [ AUDIO_FORMAT_S8 ] = "PCM-S8",
140 [ AUDIO_FORMAT_U16 ] = "PCM-U16",
141 [ AUDIO_FORMAT_S16 ] = "PCM-S16",
142 [ AUDIO_FORMAT_U32 ] = "PCM-U32",
143 [ AUDIO_FORMAT_S32 ] = "PCM-S32",
144};
145
146typedef struct HDAAudioState HDAAudioState;
147typedef struct HDAAudioStream HDAAudioStream;
148
149struct HDAAudioStream {
150 HDAAudioState *state;
151 const desc_node *node;
152 bool output, running;
153 uint32_t stream;
154 uint32_t channel;
155 uint32_t format;
156 uint32_t gain_left, gain_right;
157 bool mute_left, mute_right;
158 struct audsettings as;
159 union {
160 SWVoiceIn *in;
161 SWVoiceOut *out;
162 } voice;
163 uint8_t compat_buf[HDA_BUFFER_SIZE];
164 uint32_t compat_bpos;
165 uint8_t buf[8192];
166 int64_t rpos;
167 int64_t wpos;
168 QEMUTimer *buft;
169 int64_t buft_start;
170};
171
172#define TYPE_HDA_AUDIO "hda-audio"
173#define HDA_AUDIO(obj) OBJECT_CHECK(HDAAudioState, (obj), TYPE_HDA_AUDIO)
174
175struct HDAAudioState {
176 HDACodecDevice hda;
177 const char *name;
178
179 QEMUSoundCard card;
180 const desc_codec *desc;
181 HDAAudioStream st[4];
182 bool running_compat[16];
183 bool running_real[2 * 16];
184
185
186 uint32_t debug;
187 bool mixer;
188 bool use_timer;
189};
190
191static inline int64_t hda_bytes_per_second(HDAAudioStream *st)
192{
193 return 2LL * st->as.nchannels * st->as.freq;
194}
195
196static inline void hda_timer_sync_adjust(HDAAudioStream *st, int64_t target_pos)
197{
198 int64_t limit = B_SIZE / 8;
199 int64_t corr = 0;
200
201 if (target_pos > limit) {
202 corr = HDA_TIMER_TICKS;
203 }
204 if (target_pos < -limit) {
205 corr = -HDA_TIMER_TICKS;
206 }
207 if (target_pos < -(2 * limit)) {
208 corr = -(4 * HDA_TIMER_TICKS);
209 }
210 if (corr == 0) {
211 return;
212 }
213
214 trace_hda_audio_adjust(st->node->name, target_pos);
215 st->buft_start += corr;
216}
217
218static void hda_audio_input_timer(void *opaque)
219{
220 HDAAudioStream *st = opaque;
221
222 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
223
224 int64_t buft_start = st->buft_start;
225 int64_t wpos = st->wpos;
226 int64_t rpos = st->rpos;
227
228 int64_t wanted_rpos = hda_bytes_per_second(st) * (now - buft_start)
229 / NANOSECONDS_PER_SECOND;
230 wanted_rpos &= -4;
231
232 if (wanted_rpos <= rpos) {
233
234 goto out_timer;
235 }
236
237 int64_t to_transfer = audio_MIN(wpos - rpos, wanted_rpos - rpos);
238 while (to_transfer) {
239 uint32_t start = (rpos & B_MASK);
240 uint32_t chunk = audio_MIN(B_SIZE - start, to_transfer);
241 int rc = hda_codec_xfer(
242 &st->state->hda, st->stream, false, st->buf + start, chunk);
243 if (!rc) {
244 break;
245 }
246 rpos += chunk;
247 to_transfer -= chunk;
248 st->rpos += chunk;
249 }
250
251out_timer:
252
253 if (st->running) {
254 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
255 }
256}
257
258static void hda_audio_input_cb(void *opaque, int avail)
259{
260 HDAAudioStream *st = opaque;
261
262 int64_t wpos = st->wpos;
263 int64_t rpos = st->rpos;
264
265 int64_t to_transfer = audio_MIN(B_SIZE - (wpos - rpos), avail);
266
267 hda_timer_sync_adjust(st, -((wpos - rpos) + to_transfer - (B_SIZE >> 1)));
268
269 while (to_transfer) {
270 uint32_t start = (uint32_t) (wpos & B_MASK);
271 uint32_t chunk = (uint32_t) audio_MIN(B_SIZE - start, to_transfer);
272 uint32_t read = AUD_read(st->voice.in, st->buf + start, chunk);
273 wpos += read;
274 to_transfer -= read;
275 st->wpos += read;
276 if (chunk != read) {
277 break;
278 }
279 }
280}
281
282static void hda_audio_output_timer(void *opaque)
283{
284 HDAAudioStream *st = opaque;
285
286 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
287
288 int64_t buft_start = st->buft_start;
289 int64_t wpos = st->wpos;
290 int64_t rpos = st->rpos;
291
292 int64_t wanted_wpos = hda_bytes_per_second(st) * (now - buft_start)
293 / NANOSECONDS_PER_SECOND;
294 wanted_wpos &= -4;
295
296 if (wanted_wpos <= wpos) {
297
298 goto out_timer;
299 }
300
301 int64_t to_transfer = audio_MIN(B_SIZE - (wpos - rpos), wanted_wpos - wpos);
302 while (to_transfer) {
303 uint32_t start = (wpos & B_MASK);
304 uint32_t chunk = audio_MIN(B_SIZE - start, to_transfer);
305 int rc = hda_codec_xfer(
306 &st->state->hda, st->stream, true, st->buf + start, chunk);
307 if (!rc) {
308 break;
309 }
310 wpos += chunk;
311 to_transfer -= chunk;
312 st->wpos += chunk;
313 }
314
315out_timer:
316
317 if (st->running) {
318 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
319 }
320}
321
322static void hda_audio_output_cb(void *opaque, int avail)
323{
324 HDAAudioStream *st = opaque;
325
326 int64_t wpos = st->wpos;
327 int64_t rpos = st->rpos;
328
329 int64_t to_transfer = audio_MIN(wpos - rpos, avail);
330
331 if (wpos - rpos == B_SIZE) {
332
333 st->rpos = 0;
334 st->wpos = 0;
335 st->buft_start = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
336 trace_hda_audio_overrun(st->node->name);
337 return;
338 }
339
340 hda_timer_sync_adjust(st, (wpos - rpos) - to_transfer - (B_SIZE >> 1));
341
342 while (to_transfer) {
343 uint32_t start = (uint32_t) (rpos & B_MASK);
344 uint32_t chunk = (uint32_t) audio_MIN(B_SIZE - start, to_transfer);
345 uint32_t written = AUD_write(st->voice.out, st->buf + start, chunk);
346 rpos += written;
347 to_transfer -= written;
348 st->rpos += written;
349 if (chunk != written) {
350 break;
351 }
352 }
353}
354
355static void hda_audio_compat_input_cb(void *opaque, int avail)
356{
357 HDAAudioStream *st = opaque;
358 int recv = 0;
359 int len;
360 bool rc;
361
362 while (avail - recv >= sizeof(st->compat_buf)) {
363 if (st->compat_bpos != sizeof(st->compat_buf)) {
364 len = AUD_read(st->voice.in, st->compat_buf + st->compat_bpos,
365 sizeof(st->compat_buf) - st->compat_bpos);
366 st->compat_bpos += len;
367 recv += len;
368 if (st->compat_bpos != sizeof(st->compat_buf)) {
369 break;
370 }
371 }
372 rc = hda_codec_xfer(&st->state->hda, st->stream, false,
373 st->compat_buf, sizeof(st->compat_buf));
374 if (!rc) {
375 break;
376 }
377 st->compat_bpos = 0;
378 }
379}
380
381static void hda_audio_compat_output_cb(void *opaque, int avail)
382{
383 HDAAudioStream *st = opaque;
384 int sent = 0;
385 int len;
386 bool rc;
387
388 while (avail - sent >= sizeof(st->compat_buf)) {
389 if (st->compat_bpos == sizeof(st->compat_buf)) {
390 rc = hda_codec_xfer(&st->state->hda, st->stream, true,
391 st->compat_buf, sizeof(st->compat_buf));
392 if (!rc) {
393 break;
394 }
395 st->compat_bpos = 0;
396 }
397 len = AUD_write(st->voice.out, st->compat_buf + st->compat_bpos,
398 sizeof(st->compat_buf) - st->compat_bpos);
399 st->compat_bpos += len;
400 sent += len;
401 if (st->compat_bpos != sizeof(st->compat_buf)) {
402 break;
403 }
404 }
405}
406
407static void hda_audio_set_running(HDAAudioStream *st, bool running)
408{
409 if (st->node == NULL) {
410 return;
411 }
412 if (st->running == running) {
413 return;
414 }
415 st->running = running;
416 trace_hda_audio_running(st->node->name, st->stream, st->running);
417 if (st->state->use_timer) {
418 if (running) {
419 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
420 st->rpos = 0;
421 st->wpos = 0;
422 st->buft_start = now;
423 timer_mod_anticipate_ns(st->buft, now + HDA_TIMER_TICKS);
424 } else {
425 timer_del(st->buft);
426 }
427 }
428 if (st->output) {
429 AUD_set_active_out(st->voice.out, st->running);
430 } else {
431 AUD_set_active_in(st->voice.in, st->running);
432 }
433}
434
435static void hda_audio_set_amp(HDAAudioStream *st)
436{
437 bool muted;
438 uint32_t left, right;
439
440 if (st->node == NULL) {
441 return;
442 }
443
444 muted = st->mute_left && st->mute_right;
445 left = st->mute_left ? 0 : st->gain_left;
446 right = st->mute_right ? 0 : st->gain_right;
447
448 left = left * 255 / QEMU_HDA_AMP_STEPS;
449 right = right * 255 / QEMU_HDA_AMP_STEPS;
450
451 if (!st->state->mixer) {
452 return;
453 }
454 if (st->output) {
455 AUD_set_volume_out(st->voice.out, muted, left, right);
456 } else {
457 AUD_set_volume_in(st->voice.in, muted, left, right);
458 }
459}
460
461static void hda_audio_setup(HDAAudioStream *st)
462{
463 bool use_timer = st->state->use_timer;
464 audio_callback_fn cb;
465
466 if (st->node == NULL) {
467 return;
468 }
469
470 trace_hda_audio_format(st->node->name, st->as.nchannels,
471 fmt2name[st->as.fmt], st->as.freq);
472
473 if (st->output) {
474 if (use_timer) {
475 cb = hda_audio_output_cb;
476 st->buft = timer_new_ns(QEMU_CLOCK_VIRTUAL,
477 hda_audio_output_timer, st);
478 } else {
479 cb = hda_audio_compat_output_cb;
480 }
481 st->voice.out = AUD_open_out(&st->state->card, st->voice.out,
482 st->node->name, st, cb, &st->as);
483 } else {
484 if (use_timer) {
485 cb = hda_audio_input_cb;
486 st->buft = timer_new_ns(QEMU_CLOCK_VIRTUAL,
487 hda_audio_input_timer, st);
488 } else {
489 cb = hda_audio_compat_input_cb;
490 }
491 st->voice.in = AUD_open_in(&st->state->card, st->voice.in,
492 st->node->name, st, cb, &st->as);
493 }
494}
495
496static void hda_audio_command(HDACodecDevice *hda, uint32_t nid, uint32_t data)
497{
498 HDAAudioState *a = HDA_AUDIO(hda);
499 HDAAudioStream *st;
500 const desc_node *node = NULL;
501 const desc_param *param;
502 uint32_t verb, payload, response, count, shift;
503
504 if ((data & 0x70000) == 0x70000) {
505
506 verb = (data >> 8) & 0xfff;
507 payload = data & 0x00ff;
508 } else {
509
510 verb = (data >> 8) & 0xf00;
511 payload = data & 0xffff;
512 }
513
514 node = hda_codec_find_node(a->desc, nid);
515 if (node == NULL) {
516 goto fail;
517 }
518 dprint(a, 2, "%s: nid %d (%s), verb 0x%x, payload 0x%x\n",
519 __func__, nid, node->name, verb, payload);
520
521 switch (verb) {
522
523 case AC_VERB_PARAMETERS:
524 param = hda_codec_find_param(node, payload);
525 if (param == NULL) {
526 goto fail;
527 }
528 hda_codec_response(hda, true, param->val);
529 break;
530 case AC_VERB_GET_SUBSYSTEM_ID:
531 hda_codec_response(hda, true, a->desc->iid);
532 break;
533
534
535 case AC_VERB_GET_CONNECT_LIST:
536 param = hda_codec_find_param(node, AC_PAR_CONNLIST_LEN);
537 count = param ? param->val : 0;
538 response = 0;
539 shift = 0;
540 while (payload < count && shift < 32) {
541 response |= node->conn[payload] << shift;
542 payload++;
543 shift += 8;
544 }
545 hda_codec_response(hda, true, response);
546 break;
547
548
549 case AC_VERB_GET_CONFIG_DEFAULT:
550 hda_codec_response(hda, true, node->config);
551 break;
552 case AC_VERB_GET_PIN_WIDGET_CONTROL:
553 hda_codec_response(hda, true, node->pinctl);
554 break;
555 case AC_VERB_SET_PIN_WIDGET_CONTROL:
556 if (node->pinctl != payload) {
557 dprint(a, 1, "unhandled pin control bit\n");
558 }
559 hda_codec_response(hda, true, 0);
560 break;
561
562
563 case AC_VERB_SET_CHANNEL_STREAMID:
564 st = a->st + node->stindex;
565 if (st->node == NULL) {
566 goto fail;
567 }
568 hda_audio_set_running(st, false);
569 st->stream = (payload >> 4) & 0x0f;
570 st->channel = payload & 0x0f;
571 dprint(a, 2, "%s: stream %d, channel %d\n",
572 st->node->name, st->stream, st->channel);
573 hda_audio_set_running(st, a->running_real[st->output * 16 + st->stream]);
574 hda_codec_response(hda, true, 0);
575 break;
576 case AC_VERB_GET_CONV:
577 st = a->st + node->stindex;
578 if (st->node == NULL) {
579 goto fail;
580 }
581 response = st->stream << 4 | st->channel;
582 hda_codec_response(hda, true, response);
583 break;
584 case AC_VERB_SET_STREAM_FORMAT:
585 st = a->st + node->stindex;
586 if (st->node == NULL) {
587 goto fail;
588 }
589 st->format = payload;
590 hda_codec_parse_fmt(st->format, &st->as);
591 hda_audio_setup(st);
592 hda_codec_response(hda, true, 0);
593 break;
594 case AC_VERB_GET_STREAM_FORMAT:
595 st = a->st + node->stindex;
596 if (st->node == NULL) {
597 goto fail;
598 }
599 hda_codec_response(hda, true, st->format);
600 break;
601 case AC_VERB_GET_AMP_GAIN_MUTE:
602 st = a->st + node->stindex;
603 if (st->node == NULL) {
604 goto fail;
605 }
606 if (payload & AC_AMP_GET_LEFT) {
607 response = st->gain_left | (st->mute_left ? AC_AMP_MUTE : 0);
608 } else {
609 response = st->gain_right | (st->mute_right ? AC_AMP_MUTE : 0);
610 }
611 hda_codec_response(hda, true, response);
612 break;
613 case AC_VERB_SET_AMP_GAIN_MUTE:
614 st = a->st + node->stindex;
615 if (st->node == NULL) {
616 goto fail;
617 }
618 dprint(a, 1, "amp (%s): %s%s%s%s index %d gain %3d %s\n",
619 st->node->name,
620 (payload & AC_AMP_SET_OUTPUT) ? "o" : "-",
621 (payload & AC_AMP_SET_INPUT) ? "i" : "-",
622 (payload & AC_AMP_SET_LEFT) ? "l" : "-",
623 (payload & AC_AMP_SET_RIGHT) ? "r" : "-",
624 (payload & AC_AMP_SET_INDEX) >> AC_AMP_SET_INDEX_SHIFT,
625 (payload & AC_AMP_GAIN),
626 (payload & AC_AMP_MUTE) ? "muted" : "");
627 if (payload & AC_AMP_SET_LEFT) {
628 st->gain_left = payload & AC_AMP_GAIN;
629 st->mute_left = payload & AC_AMP_MUTE;
630 }
631 if (payload & AC_AMP_SET_RIGHT) {
632 st->gain_right = payload & AC_AMP_GAIN;
633 st->mute_right = payload & AC_AMP_MUTE;
634 }
635 hda_audio_set_amp(st);
636 hda_codec_response(hda, true, 0);
637 break;
638
639
640 case AC_VERB_SET_POWER_STATE:
641 case AC_VERB_GET_POWER_STATE:
642 case AC_VERB_GET_SDI_SELECT:
643 hda_codec_response(hda, true, 0);
644 break;
645 default:
646 goto fail;
647 }
648 return;
649
650fail:
651 dprint(a, 1, "%s: not handled: nid %d (%s), verb 0x%x, payload 0x%x\n",
652 __func__, nid, node ? node->name : "?", verb, payload);
653 hda_codec_response(hda, true, 0);
654}
655
656static void hda_audio_stream(HDACodecDevice *hda, uint32_t stnr, bool running, bool output)
657{
658 HDAAudioState *a = HDA_AUDIO(hda);
659 int s;
660
661 a->running_compat[stnr] = running;
662 a->running_real[output * 16 + stnr] = running;
663 for (s = 0; s < ARRAY_SIZE(a->st); s++) {
664 if (a->st[s].node == NULL) {
665 continue;
666 }
667 if (a->st[s].output != output) {
668 continue;
669 }
670 if (a->st[s].stream != stnr) {
671 continue;
672 }
673 hda_audio_set_running(&a->st[s], running);
674 }
675}
676
677static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc)
678{
679 HDAAudioState *a = HDA_AUDIO(hda);
680 HDAAudioStream *st;
681 const desc_node *node;
682 const desc_param *param;
683 uint32_t i, type;
684
685 a->desc = desc;
686 a->name = object_get_typename(OBJECT(a));
687 dprint(a, 1, "%s: cad %d\n", __func__, a->hda.cad);
688
689 AUD_register_card("hda", &a->card);
690 for (i = 0; i < a->desc->nnodes; i++) {
691 node = a->desc->nodes + i;
692 param = hda_codec_find_param(node, AC_PAR_AUDIO_WIDGET_CAP);
693 if (param == NULL) {
694 continue;
695 }
696 type = (param->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
697 switch (type) {
698 case AC_WID_AUD_OUT:
699 case AC_WID_AUD_IN:
700 assert(node->stindex < ARRAY_SIZE(a->st));
701 st = a->st + node->stindex;
702 st->state = a;
703 st->node = node;
704 if (type == AC_WID_AUD_OUT) {
705
706 st->gain_left = QEMU_HDA_AMP_STEPS;
707 st->gain_right = QEMU_HDA_AMP_STEPS;
708 st->compat_bpos = sizeof(st->compat_buf);
709 st->output = true;
710 } else {
711 st->output = false;
712 }
713 st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
714 (1 << AC_FMT_CHAN_SHIFT);
715 hda_codec_parse_fmt(st->format, &st->as);
716 hda_audio_setup(st);
717 break;
718 }
719 }
720 return 0;
721}
722
723static void hda_audio_exit(HDACodecDevice *hda)
724{
725 HDAAudioState *a = HDA_AUDIO(hda);
726 HDAAudioStream *st;
727 int i;
728
729 dprint(a, 1, "%s\n", __func__);
730 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
731 st = a->st + i;
732 if (st->node == NULL) {
733 continue;
734 }
735 if (a->use_timer) {
736 timer_del(st->buft);
737 }
738 if (st->output) {
739 AUD_close_out(&a->card, st->voice.out);
740 } else {
741 AUD_close_in(&a->card, st->voice.in);
742 }
743 }
744 AUD_remove_card(&a->card);
745}
746
747static int hda_audio_post_load(void *opaque, int version)
748{
749 HDAAudioState *a = opaque;
750 HDAAudioStream *st;
751 int i;
752
753 dprint(a, 1, "%s\n", __func__);
754 if (version == 1) {
755
756 for (i = 0; i < ARRAY_SIZE(a->running_compat); i++)
757 a->running_real[16 + i] = a->running_compat[i];
758 }
759
760 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
761 st = a->st + i;
762 if (st->node == NULL)
763 continue;
764 hda_codec_parse_fmt(st->format, &st->as);
765 hda_audio_setup(st);
766 hda_audio_set_amp(st);
767 hda_audio_set_running(st, a->running_real[st->output * 16 + st->stream]);
768 }
769 return 0;
770}
771
772static void hda_audio_reset(DeviceState *dev)
773{
774 HDAAudioState *a = HDA_AUDIO(dev);
775 HDAAudioStream *st;
776 int i;
777
778 dprint(a, 1, "%s\n", __func__);
779 for (i = 0; i < ARRAY_SIZE(a->st); i++) {
780 st = a->st + i;
781 if (st->node != NULL) {
782 hda_audio_set_running(st, false);
783 }
784 }
785}
786
787static bool vmstate_hda_audio_stream_buf_needed(void *opaque)
788{
789 HDAAudioStream *st = opaque;
790 return st->state && st->state->use_timer;
791}
792
793static const VMStateDescription vmstate_hda_audio_stream_buf = {
794 .name = "hda-audio-stream/buffer",
795 .version_id = 1,
796 .needed = vmstate_hda_audio_stream_buf_needed,
797 .fields = (VMStateField[]) {
798 VMSTATE_BUFFER(buf, HDAAudioStream),
799 VMSTATE_INT64(rpos, HDAAudioStream),
800 VMSTATE_INT64(wpos, HDAAudioStream),
801 VMSTATE_TIMER_PTR(buft, HDAAudioStream),
802 VMSTATE_INT64(buft_start, HDAAudioStream),
803 VMSTATE_END_OF_LIST()
804 }
805};
806
807static const VMStateDescription vmstate_hda_audio_stream = {
808 .name = "hda-audio-stream",
809 .version_id = 1,
810 .fields = (VMStateField[]) {
811 VMSTATE_UINT32(stream, HDAAudioStream),
812 VMSTATE_UINT32(channel, HDAAudioStream),
813 VMSTATE_UINT32(format, HDAAudioStream),
814 VMSTATE_UINT32(gain_left, HDAAudioStream),
815 VMSTATE_UINT32(gain_right, HDAAudioStream),
816 VMSTATE_BOOL(mute_left, HDAAudioStream),
817 VMSTATE_BOOL(mute_right, HDAAudioStream),
818 VMSTATE_UINT32(compat_bpos, HDAAudioStream),
819 VMSTATE_BUFFER(compat_buf, HDAAudioStream),
820 VMSTATE_END_OF_LIST()
821 },
822 .subsections = (const VMStateDescription * []) {
823 &vmstate_hda_audio_stream_buf,
824 NULL
825 }
826};
827
828static const VMStateDescription vmstate_hda_audio = {
829 .name = "hda-audio",
830 .version_id = 2,
831 .post_load = hda_audio_post_load,
832 .fields = (VMStateField[]) {
833 VMSTATE_STRUCT_ARRAY(st, HDAAudioState, 4, 0,
834 vmstate_hda_audio_stream,
835 HDAAudioStream),
836 VMSTATE_BOOL_ARRAY(running_compat, HDAAudioState, 16),
837 VMSTATE_BOOL_ARRAY_V(running_real, HDAAudioState, 2 * 16, 2),
838 VMSTATE_END_OF_LIST()
839 }
840};
841
842static Property hda_audio_properties[] = {
843 DEFINE_PROP_UINT32("debug", HDAAudioState, debug, 0),
844 DEFINE_PROP_BOOL("mixer", HDAAudioState, mixer, true),
845 DEFINE_PROP_BOOL("use-timer", HDAAudioState, use_timer, true),
846 DEFINE_PROP_END_OF_LIST(),
847};
848
849static int hda_audio_init_output(HDACodecDevice *hda)
850{
851 HDAAudioState *a = HDA_AUDIO(hda);
852
853 if (!a->mixer) {
854 return hda_audio_init(hda, &output_nomixemu);
855 } else {
856 return hda_audio_init(hda, &output_mixemu);
857 }
858}
859
860static int hda_audio_init_duplex(HDACodecDevice *hda)
861{
862 HDAAudioState *a = HDA_AUDIO(hda);
863
864 if (!a->mixer) {
865 return hda_audio_init(hda, &duplex_nomixemu);
866 } else {
867 return hda_audio_init(hda, &duplex_mixemu);
868 }
869}
870
871static int hda_audio_init_micro(HDACodecDevice *hda)
872{
873 HDAAudioState *a = HDA_AUDIO(hda);
874
875 if (!a->mixer) {
876 return hda_audio_init(hda, µ_nomixemu);
877 } else {
878 return hda_audio_init(hda, µ_mixemu);
879 }
880}
881
882static void hda_audio_base_class_init(ObjectClass *klass, void *data)
883{
884 DeviceClass *dc = DEVICE_CLASS(klass);
885 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
886
887 k->exit = hda_audio_exit;
888 k->command = hda_audio_command;
889 k->stream = hda_audio_stream;
890 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
891 dc->reset = hda_audio_reset;
892 dc->vmsd = &vmstate_hda_audio;
893 dc->props = hda_audio_properties;
894}
895
896static const TypeInfo hda_audio_info = {
897 .name = TYPE_HDA_AUDIO,
898 .parent = TYPE_HDA_CODEC_DEVICE,
899 .class_init = hda_audio_base_class_init,
900 .abstract = true,
901};
902
903static void hda_audio_output_class_init(ObjectClass *klass, void *data)
904{
905 DeviceClass *dc = DEVICE_CLASS(klass);
906 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
907
908 k->init = hda_audio_init_output;
909 dc->desc = "HDA Audio Codec, output-only (line-out)";
910}
911
912static const TypeInfo hda_audio_output_info = {
913 .name = "hda-output",
914 .parent = TYPE_HDA_AUDIO,
915 .instance_size = sizeof(HDAAudioState),
916 .class_init = hda_audio_output_class_init,
917};
918
919static void hda_audio_duplex_class_init(ObjectClass *klass, void *data)
920{
921 DeviceClass *dc = DEVICE_CLASS(klass);
922 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
923
924 k->init = hda_audio_init_duplex;
925 dc->desc = "HDA Audio Codec, duplex (line-out, line-in)";
926}
927
928static const TypeInfo hda_audio_duplex_info = {
929 .name = "hda-duplex",
930 .parent = TYPE_HDA_AUDIO,
931 .instance_size = sizeof(HDAAudioState),
932 .class_init = hda_audio_duplex_class_init,
933};
934
935static void hda_audio_micro_class_init(ObjectClass *klass, void *data)
936{
937 DeviceClass *dc = DEVICE_CLASS(klass);
938 HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
939
940 k->init = hda_audio_init_micro;
941 dc->desc = "HDA Audio Codec, duplex (speaker, microphone)";
942}
943
944static const TypeInfo hda_audio_micro_info = {
945 .name = "hda-micro",
946 .parent = TYPE_HDA_AUDIO,
947 .instance_size = sizeof(HDAAudioState),
948 .class_init = hda_audio_micro_class_init,
949};
950
951static void hda_audio_register_types(void)
952{
953 type_register_static(&hda_audio_info);
954 type_register_static(&hda_audio_output_info);
955 type_register_static(&hda_audio_duplex_info);
956 type_register_static(&hda_audio_micro_info);
957}
958
959type_init(hda_audio_register_types)
960
