hw/audio/hda-codec.c

   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)