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