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 = µ_mixemu; 903 904 if (!a->mixer) { 905 desc = µ_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 dc->reset = 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