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