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/>.
21 #include "hw/pci/pci.h"
22 #include "intel-hda.h"
23 #include "intel-hda-defs.h"
24 #include "audio/audio.h"
26 /* -------------------------------------------------------------------------- */
28 typedef struct desc_param
{
33 typedef struct desc_node
{
36 const desc_param
*params
;
44 typedef struct desc_codec
{
47 const desc_node
*nodes
;
51 static const desc_param
* hda_codec_find_param(const desc_node
*node
, uint32_t id
)
55 for (i
= 0; i
< node
->nparams
; i
++) {
56 if (node
->params
[i
].id
== id
) {
57 return &node
->params
[i
];
63 static const desc_node
* hda_codec_find_node(const desc_codec
*codec
, uint32_t nid
)
67 for (i
= 0; i
< codec
->nnodes
; i
++) {
68 if (codec
->nodes
[i
].nid
== nid
) {
69 return &codec
->nodes
[i
];
75 static void hda_codec_parse_fmt(uint32_t format
, struct audsettings
*as
)
77 if (format
& AC_FMT_TYPE_NON_PCM
) {
81 as
->freq
= (format
& AC_FMT_BASE_44K
) ? 44100 : 48000;
83 switch ((format
& AC_FMT_MULT_MASK
) >> AC_FMT_MULT_SHIFT
) {
84 case 1: as
->freq
*= 2; break;
85 case 2: as
->freq
*= 3; break;
86 case 3: as
->freq
*= 4; break;
89 switch ((format
& AC_FMT_DIV_MASK
) >> AC_FMT_DIV_SHIFT
) {
90 case 1: as
->freq
/= 2; break;
91 case 2: as
->freq
/= 3; break;
92 case 3: as
->freq
/= 4; break;
93 case 4: as
->freq
/= 5; break;
94 case 5: as
->freq
/= 6; break;
95 case 6: as
->freq
/= 7; break;
96 case 7: as
->freq
/= 8; break;
99 switch (format
& AC_FMT_BITS_MASK
) {
100 case AC_FMT_BITS_8
: as
->fmt
= AUD_FMT_S8
; break;
101 case AC_FMT_BITS_16
: as
->fmt
= AUD_FMT_S16
; break;
102 case AC_FMT_BITS_32
: as
->fmt
= AUD_FMT_S32
; break;
105 as
->nchannels
= ((format
& AC_FMT_CHAN_MASK
) >> AC_FMT_CHAN_SHIFT
) + 1;
108 /* -------------------------------------------------------------------------- */
110 * HDA codec descriptions
115 #define QEMU_HDA_ID_VENDOR 0x1af4
116 #define QEMU_HDA_PCM_FORMATS (AC_SUPPCM_BITS_16 | \
117 0x1fc /* 16 -> 96 kHz */)
118 #define QEMU_HDA_AMP_NONE (0)
119 #define QEMU_HDA_AMP_STEPS 0x4a
123 #include "hda-codec-common.h"
125 #define PARAM nomixemu
126 #include "hda-codec-common.h"
128 /* -------------------------------------------------------------------------- */
130 static const char *fmt2name
[] = {
131 [ AUD_FMT_U8
] = "PCM-U8",
132 [ AUD_FMT_S8
] = "PCM-S8",
133 [ AUD_FMT_U16
] = "PCM-U16",
134 [ AUD_FMT_S16
] = "PCM-S16",
135 [ AUD_FMT_U32
] = "PCM-U32",
136 [ AUD_FMT_S32
] = "PCM-S32",
139 typedef struct HDAAudioState HDAAudioState
;
140 typedef struct HDAAudioStream HDAAudioStream
;
142 struct HDAAudioStream
{
143 HDAAudioState
*state
;
144 const desc_node
*node
;
145 bool output
, running
;
149 uint32_t gain_left
, gain_right
;
150 bool mute_left
, mute_right
;
151 struct audsettings as
;
156 uint8_t buf
[HDA_BUFFER_SIZE
];
160 #define TYPE_HDA_AUDIO "hda-audio"
161 #define HDA_AUDIO(obj) OBJECT_CHECK(HDAAudioState, (obj), TYPE_HDA_AUDIO)
163 struct HDAAudioState
{
168 const desc_codec
*desc
;
169 HDAAudioStream st
[4];
170 bool running_compat
[16];
171 bool running_real
[2 * 16];
178 static void hda_audio_input_cb(void *opaque
, int avail
)
180 HDAAudioStream
*st
= opaque
;
185 while (avail
- recv
>= sizeof(st
->buf
)) {
186 if (st
->bpos
!= sizeof(st
->buf
)) {
187 len
= AUD_read(st
->voice
.in
, st
->buf
+ st
->bpos
,
188 sizeof(st
->buf
) - st
->bpos
);
191 if (st
->bpos
!= sizeof(st
->buf
)) {
195 rc
= hda_codec_xfer(&st
->state
->hda
, st
->stream
, false,
196 st
->buf
, sizeof(st
->buf
));
204 static void hda_audio_output_cb(void *opaque
, int avail
)
206 HDAAudioStream
*st
= opaque
;
211 while (avail
- sent
>= sizeof(st
->buf
)) {
212 if (st
->bpos
== sizeof(st
->buf
)) {
213 rc
= hda_codec_xfer(&st
->state
->hda
, st
->stream
, true,
214 st
->buf
, sizeof(st
->buf
));
220 len
= AUD_write(st
->voice
.out
, st
->buf
+ st
->bpos
,
221 sizeof(st
->buf
) - st
->bpos
);
224 if (st
->bpos
!= sizeof(st
->buf
)) {
230 static void hda_audio_set_running(HDAAudioStream
*st
, bool running
)
232 if (st
->node
== NULL
) {
235 if (st
->running
== running
) {
238 st
->running
= running
;
239 dprint(st
->state
, 1, "%s: %s (stream %d)\n", st
->node
->name
,
240 st
->running
? "on" : "off", st
->stream
);
242 AUD_set_active_out(st
->voice
.out
, st
->running
);
244 AUD_set_active_in(st
->voice
.in
, st
->running
);
248 static void hda_audio_set_amp(HDAAudioStream
*st
)
251 uint32_t left
, right
;
253 if (st
->node
== NULL
) {
257 muted
= st
->mute_left
&& st
->mute_right
;
258 left
= st
->mute_left
? 0 : st
->gain_left
;
259 right
= st
->mute_right
? 0 : st
->gain_right
;
261 left
= left
* 255 / QEMU_HDA_AMP_STEPS
;
262 right
= right
* 255 / QEMU_HDA_AMP_STEPS
;
264 if (!st
->state
->mixer
) {
268 AUD_set_volume_out(st
->voice
.out
, muted
, left
, right
);
270 AUD_set_volume_in(st
->voice
.in
, muted
, left
, right
);
274 static void hda_audio_setup(HDAAudioStream
*st
)
276 if (st
->node
== NULL
) {
280 dprint(st
->state
, 1, "%s: format: %d x %s @ %d Hz\n",
281 st
->node
->name
, st
->as
.nchannels
,
282 fmt2name
[st
->as
.fmt
], st
->as
.freq
);
285 st
->voice
.out
= AUD_open_out(&st
->state
->card
, st
->voice
.out
,
287 hda_audio_output_cb
, &st
->as
);
289 st
->voice
.in
= AUD_open_in(&st
->state
->card
, st
->voice
.in
,
291 hda_audio_input_cb
, &st
->as
);
295 static void hda_audio_command(HDACodecDevice
*hda
, uint32_t nid
, uint32_t data
)
297 HDAAudioState
*a
= HDA_AUDIO(hda
);
299 const desc_node
*node
= NULL
;
300 const desc_param
*param
;
301 uint32_t verb
, payload
, response
, count
, shift
;
303 if ((data
& 0x70000) == 0x70000) {
304 /* 12/8 id/payload */
305 verb
= (data
>> 8) & 0xfff;
306 payload
= data
& 0x00ff;
308 /* 4/16 id/payload */
309 verb
= (data
>> 8) & 0xf00;
310 payload
= data
& 0xffff;
313 node
= hda_codec_find_node(a
->desc
, nid
);
317 dprint(a
, 2, "%s: nid %d (%s), verb 0x%x, payload 0x%x\n",
318 __FUNCTION__
, nid
, node
->name
, verb
, payload
);
322 case AC_VERB_PARAMETERS
:
323 param
= hda_codec_find_param(node
, payload
);
327 hda_codec_response(hda
, true, param
->val
);
329 case AC_VERB_GET_SUBSYSTEM_ID
:
330 hda_codec_response(hda
, true, a
->desc
->iid
);
334 case AC_VERB_GET_CONNECT_LIST
:
335 param
= hda_codec_find_param(node
, AC_PAR_CONNLIST_LEN
);
336 count
= param
? param
->val
: 0;
339 while (payload
< count
&& shift
< 32) {
340 response
|= node
->conn
[payload
] << shift
;
344 hda_codec_response(hda
, true, response
);
348 case AC_VERB_GET_CONFIG_DEFAULT
:
349 hda_codec_response(hda
, true, node
->config
);
351 case AC_VERB_GET_PIN_WIDGET_CONTROL
:
352 hda_codec_response(hda
, true, node
->pinctl
);
354 case AC_VERB_SET_PIN_WIDGET_CONTROL
:
355 if (node
->pinctl
!= payload
) {
356 dprint(a
, 1, "unhandled pin control bit\n");
358 hda_codec_response(hda
, true, 0);
361 /* audio in/out widget */
362 case AC_VERB_SET_CHANNEL_STREAMID
:
363 st
= a
->st
+ node
->stindex
;
364 if (st
->node
== NULL
) {
367 hda_audio_set_running(st
, false);
368 st
->stream
= (payload
>> 4) & 0x0f;
369 st
->channel
= payload
& 0x0f;
370 dprint(a
, 2, "%s: stream %d, channel %d\n",
371 st
->node
->name
, st
->stream
, st
->channel
);
372 hda_audio_set_running(st
, a
->running_real
[st
->output
* 16 + st
->stream
]);
373 hda_codec_response(hda
, true, 0);
375 case AC_VERB_GET_CONV
:
376 st
= a
->st
+ node
->stindex
;
377 if (st
->node
== NULL
) {
380 response
= st
->stream
<< 4 | st
->channel
;
381 hda_codec_response(hda
, true, response
);
383 case AC_VERB_SET_STREAM_FORMAT
:
384 st
= a
->st
+ node
->stindex
;
385 if (st
->node
== NULL
) {
388 st
->format
= payload
;
389 hda_codec_parse_fmt(st
->format
, &st
->as
);
391 hda_codec_response(hda
, true, 0);
393 case AC_VERB_GET_STREAM_FORMAT
:
394 st
= a
->st
+ node
->stindex
;
395 if (st
->node
== NULL
) {
398 hda_codec_response(hda
, true, st
->format
);
400 case AC_VERB_GET_AMP_GAIN_MUTE
:
401 st
= a
->st
+ node
->stindex
;
402 if (st
->node
== NULL
) {
405 if (payload
& AC_AMP_GET_LEFT
) {
406 response
= st
->gain_left
| (st
->mute_left
? AC_AMP_MUTE
: 0);
408 response
= st
->gain_right
| (st
->mute_right
? AC_AMP_MUTE
: 0);
410 hda_codec_response(hda
, true, response
);
412 case AC_VERB_SET_AMP_GAIN_MUTE
:
413 st
= a
->st
+ node
->stindex
;
414 if (st
->node
== NULL
) {
417 dprint(a
, 1, "amp (%s): %s%s%s%s index %d gain %3d %s\n",
419 (payload
& AC_AMP_SET_OUTPUT
) ? "o" : "-",
420 (payload
& AC_AMP_SET_INPUT
) ? "i" : "-",
421 (payload
& AC_AMP_SET_LEFT
) ? "l" : "-",
422 (payload
& AC_AMP_SET_RIGHT
) ? "r" : "-",
423 (payload
& AC_AMP_SET_INDEX
) >> AC_AMP_SET_INDEX_SHIFT
,
424 (payload
& AC_AMP_GAIN
),
425 (payload
& AC_AMP_MUTE
) ? "muted" : "");
426 if (payload
& AC_AMP_SET_LEFT
) {
427 st
->gain_left
= payload
& AC_AMP_GAIN
;
428 st
->mute_left
= payload
& AC_AMP_MUTE
;
430 if (payload
& AC_AMP_SET_RIGHT
) {
431 st
->gain_right
= payload
& AC_AMP_GAIN
;
432 st
->mute_right
= payload
& AC_AMP_MUTE
;
434 hda_audio_set_amp(st
);
435 hda_codec_response(hda
, true, 0);
439 case AC_VERB_SET_POWER_STATE
:
440 case AC_VERB_GET_POWER_STATE
:
441 case AC_VERB_GET_SDI_SELECT
:
442 hda_codec_response(hda
, true, 0);
450 dprint(a
, 1, "%s: not handled: nid %d (%s), verb 0x%x, payload 0x%x\n",
451 __FUNCTION__
, nid
, node
? node
->name
: "?", verb
, payload
);
452 hda_codec_response(hda
, true, 0);
455 static void hda_audio_stream(HDACodecDevice
*hda
, uint32_t stnr
, bool running
, bool output
)
457 HDAAudioState
*a
= HDA_AUDIO(hda
);
460 a
->running_compat
[stnr
] = running
;
461 a
->running_real
[output
* 16 + stnr
] = running
;
462 for (s
= 0; s
< ARRAY_SIZE(a
->st
); s
++) {
463 if (a
->st
[s
].node
== NULL
) {
466 if (a
->st
[s
].output
!= output
) {
469 if (a
->st
[s
].stream
!= stnr
) {
472 hda_audio_set_running(&a
->st
[s
], running
);
476 static int hda_audio_init(HDACodecDevice
*hda
, const struct desc_codec
*desc
)
478 HDAAudioState
*a
= HDA_AUDIO(hda
);
480 const desc_node
*node
;
481 const desc_param
*param
;
485 a
->name
= object_get_typename(OBJECT(a
));
486 dprint(a
, 1, "%s: cad %d\n", __FUNCTION__
, a
->hda
.cad
);
488 AUD_register_card("hda", &a
->card
);
489 for (i
= 0; i
< a
->desc
->nnodes
; i
++) {
490 node
= a
->desc
->nodes
+ i
;
491 param
= hda_codec_find_param(node
, AC_PAR_AUDIO_WIDGET_CAP
);
494 type
= (param
->val
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
498 assert(node
->stindex
< ARRAY_SIZE(a
->st
));
499 st
= a
->st
+ node
->stindex
;
502 if (type
== AC_WID_AUD_OUT
) {
503 /* unmute output by default */
504 st
->gain_left
= QEMU_HDA_AMP_STEPS
;
505 st
->gain_right
= QEMU_HDA_AMP_STEPS
;
506 st
->bpos
= sizeof(st
->buf
);
511 st
->format
= AC_FMT_TYPE_PCM
| AC_FMT_BITS_16
|
512 (1 << AC_FMT_CHAN_SHIFT
);
513 hda_codec_parse_fmt(st
->format
, &st
->as
);
521 static int hda_audio_exit(HDACodecDevice
*hda
)
523 HDAAudioState
*a
= HDA_AUDIO(hda
);
527 dprint(a
, 1, "%s\n", __FUNCTION__
);
528 for (i
= 0; i
< ARRAY_SIZE(a
->st
); i
++) {
530 if (st
->node
== NULL
) {
534 AUD_close_out(&a
->card
, st
->voice
.out
);
536 AUD_close_in(&a
->card
, st
->voice
.in
);
539 AUD_remove_card(&a
->card
);
543 static int hda_audio_post_load(void *opaque
, int version
)
545 HDAAudioState
*a
= opaque
;
549 dprint(a
, 1, "%s\n", __FUNCTION__
);
551 /* assume running_compat[] is for output streams */
552 for (i
= 0; i
< ARRAY_SIZE(a
->running_compat
); i
++)
553 a
->running_real
[16 + i
] = a
->running_compat
[i
];
556 for (i
= 0; i
< ARRAY_SIZE(a
->st
); i
++) {
558 if (st
->node
== NULL
)
560 hda_codec_parse_fmt(st
->format
, &st
->as
);
562 hda_audio_set_amp(st
);
563 hda_audio_set_running(st
, a
->running_real
[st
->output
* 16 + st
->stream
]);
568 static void hda_audio_reset(DeviceState
*dev
)
570 HDAAudioState
*a
= HDA_AUDIO(dev
);
574 dprint(a
, 1, "%s\n", __func__
);
575 for (i
= 0; i
< ARRAY_SIZE(a
->st
); i
++) {
577 if (st
->node
!= NULL
) {
578 hda_audio_set_running(st
, false);
583 static const VMStateDescription vmstate_hda_audio_stream
= {
584 .name
= "hda-audio-stream",
586 .fields
= (VMStateField
[]) {
587 VMSTATE_UINT32(stream
, HDAAudioStream
),
588 VMSTATE_UINT32(channel
, HDAAudioStream
),
589 VMSTATE_UINT32(format
, HDAAudioStream
),
590 VMSTATE_UINT32(gain_left
, HDAAudioStream
),
591 VMSTATE_UINT32(gain_right
, HDAAudioStream
),
592 VMSTATE_BOOL(mute_left
, HDAAudioStream
),
593 VMSTATE_BOOL(mute_right
, HDAAudioStream
),
594 VMSTATE_UINT32(bpos
, HDAAudioStream
),
595 VMSTATE_BUFFER(buf
, HDAAudioStream
),
596 VMSTATE_END_OF_LIST()
600 static const VMStateDescription vmstate_hda_audio
= {
603 .post_load
= hda_audio_post_load
,
604 .fields
= (VMStateField
[]) {
605 VMSTATE_STRUCT_ARRAY(st
, HDAAudioState
, 4, 0,
606 vmstate_hda_audio_stream
,
608 VMSTATE_BOOL_ARRAY(running_compat
, HDAAudioState
, 16),
609 VMSTATE_BOOL_ARRAY_V(running_real
, HDAAudioState
, 2 * 16, 2),
610 VMSTATE_END_OF_LIST()
614 static Property hda_audio_properties
[] = {
615 DEFINE_PROP_UINT32("debug", HDAAudioState
, debug
, 0),
616 DEFINE_PROP_BOOL("mixer", HDAAudioState
, mixer
, true),
617 DEFINE_PROP_END_OF_LIST(),
620 static int hda_audio_init_output(HDACodecDevice
*hda
)
622 HDAAudioState
*a
= HDA_AUDIO(hda
);
625 return hda_audio_init(hda
, &output_nomixemu
);
627 return hda_audio_init(hda
, &output_mixemu
);
631 static int hda_audio_init_duplex(HDACodecDevice
*hda
)
633 HDAAudioState
*a
= HDA_AUDIO(hda
);
636 return hda_audio_init(hda
, &duplex_nomixemu
);
638 return hda_audio_init(hda
, &duplex_mixemu
);
642 static int hda_audio_init_micro(HDACodecDevice
*hda
)
644 HDAAudioState
*a
= HDA_AUDIO(hda
);
647 return hda_audio_init(hda
, µ_nomixemu
);
649 return hda_audio_init(hda
, µ_mixemu
);
653 static void hda_audio_base_class_init(ObjectClass
*klass
, void *data
)
655 DeviceClass
*dc
= DEVICE_CLASS(klass
);
656 HDACodecDeviceClass
*k
= HDA_CODEC_DEVICE_CLASS(klass
);
658 k
->exit
= hda_audio_exit
;
659 k
->command
= hda_audio_command
;
660 k
->stream
= hda_audio_stream
;
661 set_bit(DEVICE_CATEGORY_SOUND
, dc
->categories
);
662 dc
->reset
= hda_audio_reset
;
663 dc
->vmsd
= &vmstate_hda_audio
;
664 dc
->props
= hda_audio_properties
;
667 static const TypeInfo hda_audio_info
= {
668 .name
= TYPE_HDA_AUDIO
,
669 .parent
= TYPE_HDA_CODEC_DEVICE
,
670 .class_init
= hda_audio_base_class_init
,
674 static void hda_audio_output_class_init(ObjectClass
*klass
, void *data
)
676 DeviceClass
*dc
= DEVICE_CLASS(klass
);
677 HDACodecDeviceClass
*k
= HDA_CODEC_DEVICE_CLASS(klass
);
679 k
->init
= hda_audio_init_output
;
680 dc
->desc
= "HDA Audio Codec, output-only (line-out)";
683 static const TypeInfo hda_audio_output_info
= {
684 .name
= "hda-output",
685 .parent
= TYPE_HDA_AUDIO
,
686 .instance_size
= sizeof(HDAAudioState
),
687 .class_init
= hda_audio_output_class_init
,
690 static void hda_audio_duplex_class_init(ObjectClass
*klass
, void *data
)
692 DeviceClass
*dc
= DEVICE_CLASS(klass
);
693 HDACodecDeviceClass
*k
= HDA_CODEC_DEVICE_CLASS(klass
);
695 k
->init
= hda_audio_init_duplex
;
696 dc
->desc
= "HDA Audio Codec, duplex (line-out, line-in)";
699 static const TypeInfo hda_audio_duplex_info
= {
700 .name
= "hda-duplex",
701 .parent
= TYPE_HDA_AUDIO
,
702 .instance_size
= sizeof(HDAAudioState
),
703 .class_init
= hda_audio_duplex_class_init
,
706 static void hda_audio_micro_class_init(ObjectClass
*klass
, void *data
)
708 DeviceClass
*dc
= DEVICE_CLASS(klass
);
709 HDACodecDeviceClass
*k
= HDA_CODEC_DEVICE_CLASS(klass
);
711 k
->init
= hda_audio_init_micro
;
712 dc
->desc
= "HDA Audio Codec, duplex (speaker, microphone)";
715 static const TypeInfo hda_audio_micro_info
= {
717 .parent
= TYPE_HDA_AUDIO
,
718 .instance_size
= sizeof(HDAAudioState
),
719 .class_init
= hda_audio_micro_class_init
,
722 static void hda_audio_register_types(void)
724 type_register_static(&hda_audio_info
);
725 type_register_static(&hda_audio_output_info
);
726 type_register_static(&hda_audio_duplex_info
);
727 type_register_static(&hda_audio_micro_info
);
730 type_init(hda_audio_register_types
)