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 "hw/hw.h"
  21 #include "hw/pci/pci.h"
  22 #include "intel-hda.h"
  23 #include "intel-hda-defs.h"
  24 #include "audio/audio.h"
  25
  26 /* -------------------------------------------------------------------------- */
  27
  28 typedef struct desc_param {
  29     uint32_t id;
  30     uint32_t val;
  31 } desc_param;
  32
  33 typedef struct desc_node {
  34     uint32_t nid;
  35     const char *name;
  36     const desc_param *params;
  37     uint32_t nparams;
  38     uint32_t config;
  39     uint32_t pinctl;
  40     uint32_t *conn;
  41     uint32_t stindex;
  42 } desc_node;
  43
  44 typedef struct desc_codec {
  45     const char *name;
  46     uint32_t iid;
  47     const desc_node *nodes;
  48     uint32_t nnodes;
  49 } desc_codec;
  50
  51 static const desc_param* hda_codec_find_param(const desc_node *node, uint32_t id)
  52 {
  53     int i;
  54
  55     for (i = 0; i < node->nparams; i++) {
  56         if (node->params[i].id == id) {
  57             return &node->params[i];
  58         }
  59     }
  60     return NULL;
  61 }
  62
  63 static const desc_node* hda_codec_find_node(const desc_codec *codec, uint32_t nid)
  64 {
  65     int i;
  66
  67     for (i = 0; i < codec->nnodes; i++) {
  68         if (codec->nodes[i].nid == nid) {
  69             return &codec->nodes[i];
  70         }
  71     }
  72     return NULL;
  73 }
  74
  75 static void hda_codec_parse_fmt(uint32_t format, struct audsettings *as)
  76 {
  77     if (format & AC_FMT_TYPE_NON_PCM) {
  78         return;
  79     }
  80
  81     as->freq = (format & AC_FMT_BASE_44K) ? 44100 : 48000;
  82
  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;
  87     }
  88
  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;
  97     }
  98
  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;
 103     }
 104
 105     as->nchannels = ((format & AC_FMT_CHAN_MASK) >> AC_FMT_CHAN_SHIFT) + 1;
 106 }
 107
 108 /* -------------------------------------------------------------------------- */
 109 /*
 110  * HDA codec descriptions
 111  */
 112
 113 /* some defines */
 114
 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
 120
 121 #define   PARAM mixemu
 122 #define   HDA_MIXER
 123 #include "hda-codec-common.h"
 124
 125 #define   PARAM nomixemu
 126 #include  "hda-codec-common.h"
 127
 128 /* -------------------------------------------------------------------------- */
 129
 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",
 137 };
 138
 139 typedef struct HDAAudioState HDAAudioState;
 140 typedef struct HDAAudioStream HDAAudioStream;
 141
 142 struct HDAAudioStream {
 143     HDAAudioState *state;
 144     const desc_node *node;
 145     bool output, running;
 146     uint32_t stream;
 147     uint32_t channel;
 148     uint32_t format;
 149     uint32_t gain_left, gain_right;
 150     bool mute_left, mute_right;
 151     struct audsettings as;
 152     union {
 153         SWVoiceIn *in;
 154         SWVoiceOut *out;
 155     } voice;
 156     uint8_t buf[HDA_BUFFER_SIZE];
 157     uint32_t bpos;
 158 };
 159
 160 #define TYPE_HDA_AUDIO "hda-audio"
 161 #define HDA_AUDIO(obj) OBJECT_CHECK(HDAAudioState, (obj), TYPE_HDA_AUDIO)
 162
 163 struct HDAAudioState {
 164     HDACodecDevice hda;
 165     const char *name;
 166
 167     QEMUSoundCard card;
 168     const desc_codec *desc;
 169     HDAAudioStream st[4];
 170     bool running_compat[16];
 171     bool running_real[2 * 16];
 172
 173     /* properties */
 174     uint32_t debug;
 175     bool     mixer;
 176 };
 177
 178 static void hda_audio_input_cb(void *opaque, int avail)
 179 {
 180     HDAAudioStream *st = opaque;
 181     int recv = 0;
 182     int len;
 183     bool rc;
 184
 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);
 189             st->bpos += len;
 190             recv += len;
 191             if (st->bpos != sizeof(st->buf)) {
 192                 break;
 193             }
 194         }
 195         rc = hda_codec_xfer(&st->state->hda, st->stream, false,
 196                             st->buf, sizeof(st->buf));
 197         if (!rc) {
 198             break;
 199         }
 200         st->bpos = 0;
 201     }
 202 }
 203
 204 static void hda_audio_output_cb(void *opaque, int avail)
 205 {
 206     HDAAudioStream *st = opaque;
 207     int sent = 0;
 208     int len;
 209     bool rc;
 210
 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));
 215             if (!rc) {
 216                 break;
 217             }
 218             st->bpos = 0;
 219         }
 220         len = AUD_write(st->voice.out, st->buf + st->bpos,
 221                         sizeof(st->buf) - st->bpos);
 222         st->bpos += len;
 223         sent += len;
 224         if (st->bpos != sizeof(st->buf)) {
 225             break;
 226         }
 227     }
 228 }
 229
 230 static void hda_audio_set_running(HDAAudioStream *st, bool running)
 231 {
 232     if (st->node == NULL) {
 233         return;
 234     }
 235     if (st->running == running) {
 236         return;
 237     }
 238     st->running = running;
 239     dprint(st->state, 1, "%s: %s (stream %d)\n", st->node->name,
 240            st->running ? "on" : "off", st->stream);
 241     if (st->output) {
 242         AUD_set_active_out(st->voice.out, st->running);
 243     } else {
 244         AUD_set_active_in(st->voice.in, st->running);
 245     }
 246 }
 247
 248 static void hda_audio_set_amp(HDAAudioStream *st)
 249 {
 250     bool muted;
 251     uint32_t left, right;
 252
 253     if (st->node == NULL) {
 254         return;
 255     }
 256
 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;
 260
 261     left = left * 255 / QEMU_HDA_AMP_STEPS;
 262     right = right * 255 / QEMU_HDA_AMP_STEPS;
 263
 264     if (!st->state->mixer) {
 265         return;
 266     }
 267     if (st->output) {
 268         AUD_set_volume_out(st->voice.out, muted, left, right);
 269     } else {
 270         AUD_set_volume_in(st->voice.in, muted, left, right);
 271     }
 272 }
 273
 274 static void hda_audio_setup(HDAAudioStream *st)
 275 {
 276     if (st->node == NULL) {
 277         return;
 278     }
 279
 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);
 283
 284     if (st->output) {
 285         st->voice.out = AUD_open_out(&st->state->card, st->voice.out,
 286                                      st->node->name, st,
 287                                      hda_audio_output_cb, &st->as);
 288     } else {
 289         st->voice.in = AUD_open_in(&st->state->card, st->voice.in,
 290                                    st->node->name, st,
 291                                    hda_audio_input_cb, &st->as);
 292     }
 293 }
 294
 295 static void hda_audio_command(HDACodecDevice *hda, uint32_t nid, uint32_t data)
 296 {
 297     HDAAudioState *a = HDA_AUDIO(hda);
 298     HDAAudioStream *st;
 299     const desc_node *node = NULL;
 300     const desc_param *param;
 301     uint32_t verb, payload, response, count, shift;
 302
 303     if ((data & 0x70000) == 0x70000) {
 304         /* 12/8 id/payload */
 305         verb = (data >> 8) & 0xfff;
 306         payload = data & 0x00ff;
 307     } else {
 308         /* 4/16 id/payload */
 309         verb = (data >> 8) & 0xf00;
 310         payload = data & 0xffff;
 311     }
 312
 313     node = hda_codec_find_node(a->desc, nid);
 314     if (node == NULL) {
 315         goto fail;
 316     }
 317     dprint(a, 2, "%s: nid %d (%s), verb 0x%x, payload 0x%x\n",
 318            __FUNCTION__, nid, node->name, verb, payload);
 319
 320     switch (verb) {
 321     /* all nodes */
 322     case AC_VERB_PARAMETERS:
 323         param = hda_codec_find_param(node, payload);
 324         if (param == NULL) {
 325             goto fail;
 326         }
 327         hda_codec_response(hda, true, param->val);
 328         break;
 329     case AC_VERB_GET_SUBSYSTEM_ID:
 330         hda_codec_response(hda, true, a->desc->iid);
 331         break;
 332
 333     /* all functions */
 334     case AC_VERB_GET_CONNECT_LIST:
 335         param = hda_codec_find_param(node, AC_PAR_CONNLIST_LEN);
 336         count = param ? param->val : 0;
 337         response = 0;
 338         shift = 0;
 339         while (payload < count && shift < 32) {
 340             response |= node->conn[payload] << shift;
 341             payload++;
 342             shift += 8;
 343         }
 344         hda_codec_response(hda, true, response);
 345         break;
 346
 347     /* pin widget */
 348     case AC_VERB_GET_CONFIG_DEFAULT:
 349         hda_codec_response(hda, true, node->config);
 350         break;
 351     case AC_VERB_GET_PIN_WIDGET_CONTROL:
 352         hda_codec_response(hda, true, node->pinctl);
 353         break;
 354     case AC_VERB_SET_PIN_WIDGET_CONTROL:
 355         if (node->pinctl != payload) {
 356             dprint(a, 1, "unhandled pin control bit\n");
 357         }
 358         hda_codec_response(hda, true, 0);
 359         break;
 360
 361     /* audio in/out widget */
 362     case AC_VERB_SET_CHANNEL_STREAMID:
 363         st = a->st + node->stindex;
 364         if (st->node == NULL) {
 365             goto fail;
 366         }
 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);
 374         break;
 375     case AC_VERB_GET_CONV:
 376         st = a->st + node->stindex;
 377         if (st->node == NULL) {
 378             goto fail;
 379         }
 380         response = st->stream << 4 | st->channel;
 381         hda_codec_response(hda, true, response);
 382         break;
 383     case AC_VERB_SET_STREAM_FORMAT:
 384         st = a->st + node->stindex;
 385         if (st->node == NULL) {
 386             goto fail;
 387         }
 388         st->format = payload;
 389         hda_codec_parse_fmt(st->format, &st->as);
 390         hda_audio_setup(st);
 391         hda_codec_response(hda, true, 0);
 392         break;
 393     case AC_VERB_GET_STREAM_FORMAT:
 394         st = a->st + node->stindex;
 395         if (st->node == NULL) {
 396             goto fail;
 397         }
 398         hda_codec_response(hda, true, st->format);
 399         break;
 400     case AC_VERB_GET_AMP_GAIN_MUTE:
 401         st = a->st + node->stindex;
 402         if (st->node == NULL) {
 403             goto fail;
 404         }
 405         if (payload & AC_AMP_GET_LEFT) {
 406             response = st->gain_left | (st->mute_left ? AC_AMP_MUTE : 0);
 407         } else {
 408             response = st->gain_right | (st->mute_right ? AC_AMP_MUTE : 0);
 409         }
 410         hda_codec_response(hda, true, response);
 411         break;
 412     case AC_VERB_SET_AMP_GAIN_MUTE:
 413         st = a->st + node->stindex;
 414         if (st->node == NULL) {
 415             goto fail;
 416         }
 417         dprint(a, 1, "amp (%s): %s%s%s%s index %d  gain %3d %s\n",
 418                st->node->name,
 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;
 429         }
 430         if (payload & AC_AMP_SET_RIGHT) {
 431             st->gain_right = payload & AC_AMP_GAIN;
 432             st->mute_right = payload & AC_AMP_MUTE;
 433         }
 434         hda_audio_set_amp(st);
 435         hda_codec_response(hda, true, 0);
 436         break;
 437
 438     /* not supported */
 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);
 443         break;
 444     default:
 445         goto fail;
 446     }
 447     return;
 448
 449 fail:
 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);
 453 }
 454
 455 static void hda_audio_stream(HDACodecDevice *hda, uint32_t stnr, bool running, bool output)
 456 {
 457     HDAAudioState *a = HDA_AUDIO(hda);
 458     int s;
 459
 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) {
 464             continue;
 465         }
 466         if (a->st[s].output != output) {
 467             continue;
 468         }
 469         if (a->st[s].stream != stnr) {
 470             continue;
 471         }
 472         hda_audio_set_running(&a->st[s], running);
 473     }
 474 }
 475
 476 static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc)
 477 {
 478     HDAAudioState *a = HDA_AUDIO(hda);
 479     HDAAudioStream *st;
 480     const desc_node *node;
 481     const desc_param *param;
 482     uint32_t i, type;
 483
 484     a->desc = desc;
 485     a->name = object_get_typename(OBJECT(a));
 486     dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad);
 487
 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);
 492         if (param == NULL) {
 493             continue;
 494         }
 495         type = (param->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 496         switch (type) {
 497         case AC_WID_AUD_OUT:
 498         case AC_WID_AUD_IN:
 499             assert(node->stindex < ARRAY_SIZE(a->st));
 500             st = a->st + node->stindex;
 501             st->state = a;
 502             st->node = node;
 503             if (type == AC_WID_AUD_OUT) {
 504                 /* unmute output by default */
 505                 st->gain_left = QEMU_HDA_AMP_STEPS;
 506                 st->gain_right = QEMU_HDA_AMP_STEPS;
 507                 st->bpos = sizeof(st->buf);
 508                 st->output = true;
 509             } else {
 510                 st->output = false;
 511             }
 512             st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
 513                 (1 << AC_FMT_CHAN_SHIFT);
 514             hda_codec_parse_fmt(st->format, &st->as);
 515             hda_audio_setup(st);
 516             break;
 517         }
 518     }
 519     return 0;
 520 }
 521
 522 static int hda_audio_exit(HDACodecDevice *hda)
 523 {
 524     HDAAudioState *a = HDA_AUDIO(hda);
 525     HDAAudioStream *st;
 526     int i;
 527
 528     dprint(a, 1, "%s\n", __FUNCTION__);
 529     for (i = 0; i < ARRAY_SIZE(a->st); i++) {
 530         st = a->st + i;
 531         if (st->node == NULL) {
 532             continue;
 533         }
 534         if (st->output) {
 535             AUD_close_out(&a->card, st->voice.out);
 536         } else {
 537             AUD_close_in(&a->card, st->voice.in);
 538         }
 539     }
 540     AUD_remove_card(&a->card);
 541     return 0;
 542 }
 543
 544 static int hda_audio_post_load(void *opaque, int version)
 545 {
 546     HDAAudioState *a = opaque;
 547     HDAAudioStream *st;
 548     int i;
 549
 550     dprint(a, 1, "%s\n", __FUNCTION__);
 551     if (version == 1) {
 552         /* assume running_compat[] is for output streams */
 553         for (i = 0; i < ARRAY_SIZE(a->running_compat); i++)
 554             a->running_real[16 + i] = a->running_compat[i];
 555     }
 556
 557     for (i = 0; i < ARRAY_SIZE(a->st); i++) {
 558         st = a->st + i;
 559         if (st->node == NULL)
 560             continue;
 561         hda_codec_parse_fmt(st->format, &st->as);
 562         hda_audio_setup(st);
 563         hda_audio_set_amp(st);
 564         hda_audio_set_running(st, a->running_real[st->output * 16 + st->stream]);
 565     }
 566     return 0;
 567 }
 568
 569 static void hda_audio_reset(DeviceState *dev)
 570 {
 571     HDAAudioState *a = HDA_AUDIO(dev);
 572     HDAAudioStream *st;
 573     int i;
 574
 575     dprint(a, 1, "%s\n", __func__);
 576     for (i = 0; i < ARRAY_SIZE(a->st); i++) {
 577         st = a->st + i;
 578         if (st->node != NULL) {
 579             hda_audio_set_running(st, false);
 580         }
 581     }
 582 }
 583
 584 static const VMStateDescription vmstate_hda_audio_stream = {
 585     .name = "hda-audio-stream",
 586     .version_id = 1,
 587     .fields = (VMStateField[]) {
 588         VMSTATE_UINT32(stream, HDAAudioStream),
 589         VMSTATE_UINT32(channel, HDAAudioStream),
 590         VMSTATE_UINT32(format, HDAAudioStream),
 591         VMSTATE_UINT32(gain_left, HDAAudioStream),
 592         VMSTATE_UINT32(gain_right, HDAAudioStream),
 593         VMSTATE_BOOL(mute_left, HDAAudioStream),
 594         VMSTATE_BOOL(mute_right, HDAAudioStream),
 595         VMSTATE_UINT32(bpos, HDAAudioStream),
 596         VMSTATE_BUFFER(buf, HDAAudioStream),
 597         VMSTATE_END_OF_LIST()
 598     }
 599 };
 600
 601 static const VMStateDescription vmstate_hda_audio = {
 602     .name = "hda-audio",
 603     .version_id = 2,
 604     .post_load = hda_audio_post_load,
 605     .fields = (VMStateField[]) {
 606         VMSTATE_STRUCT_ARRAY(st, HDAAudioState, 4, 0,
 607                              vmstate_hda_audio_stream,
 608                              HDAAudioStream),
 609         VMSTATE_BOOL_ARRAY(running_compat, HDAAudioState, 16),
 610         VMSTATE_BOOL_ARRAY_V(running_real, HDAAudioState, 2 * 16, 2),
 611         VMSTATE_END_OF_LIST()
 612     }
 613 };
 614
 615 static Property hda_audio_properties[] = {
 616     DEFINE_PROP_UINT32("debug", HDAAudioState, debug,   0),
 617     DEFINE_PROP_BOOL("mixer", HDAAudioState, mixer,  true),
 618     DEFINE_PROP_END_OF_LIST(),
 619 };
 620
 621 static int hda_audio_init_output(HDACodecDevice *hda)
 622 {
 623     HDAAudioState *a = HDA_AUDIO(hda);
 624
 625     if (!a->mixer) {
 626         return hda_audio_init(hda, &output_nomixemu);
 627     } else {
 628         return hda_audio_init(hda, &output_mixemu);
 629     }
 630 }
 631
 632 static int hda_audio_init_duplex(HDACodecDevice *hda)
 633 {
 634     HDAAudioState *a = HDA_AUDIO(hda);
 635
 636     if (!a->mixer) {
 637         return hda_audio_init(hda, &duplex_nomixemu);
 638     } else {
 639         return hda_audio_init(hda, &duplex_mixemu);
 640     }
 641 }
 642
 643 static int hda_audio_init_micro(HDACodecDevice *hda)
 644 {
 645     HDAAudioState *a = HDA_AUDIO(hda);
 646
 647     if (!a->mixer) {
 648         return hda_audio_init(hda, &micro_nomixemu);
 649     } else {
 650         return hda_audio_init(hda, &micro_mixemu);
 651     }
 652 }
 653
 654 static void hda_audio_base_class_init(ObjectClass *klass, void *data)
 655 {
 656     DeviceClass *dc = DEVICE_CLASS(klass);
 657     HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
 658
 659     k->exit = hda_audio_exit;
 660     k->command = hda_audio_command;
 661     k->stream = hda_audio_stream;
 662     set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
 663     dc->reset = hda_audio_reset;
 664     dc->vmsd = &vmstate_hda_audio;
 665     dc->props = hda_audio_properties;
 666 }
 667
 668 static const TypeInfo hda_audio_info = {
 669     .name          = TYPE_HDA_AUDIO,
 670     .parent        = TYPE_HDA_CODEC_DEVICE,
 671     .class_init    = hda_audio_base_class_init,
 672     .abstract      = true,
 673 };
 674
 675 static void hda_audio_output_class_init(ObjectClass *klass, void *data)
 676 {
 677     DeviceClass *dc = DEVICE_CLASS(klass);
 678     HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
 679
 680     k->init = hda_audio_init_output;
 681     dc->desc = "HDA Audio Codec, output-only (line-out)";
 682 }
 683
 684 static const TypeInfo hda_audio_output_info = {
 685     .name          = "hda-output",
 686     .parent        = TYPE_HDA_AUDIO,
 687     .instance_size = sizeof(HDAAudioState),
 688     .class_init    = hda_audio_output_class_init,
 689 };
 690
 691 static void hda_audio_duplex_class_init(ObjectClass *klass, void *data)
 692 {
 693     DeviceClass *dc = DEVICE_CLASS(klass);
 694     HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
 695
 696     k->init = hda_audio_init_duplex;
 697     dc->desc = "HDA Audio Codec, duplex (line-out, line-in)";
 698 }
 699
 700 static const TypeInfo hda_audio_duplex_info = {
 701     .name          = "hda-duplex",
 702     .parent        = TYPE_HDA_AUDIO,
 703     .instance_size = sizeof(HDAAudioState),
 704     .class_init    = hda_audio_duplex_class_init,
 705 };
 706
 707 static void hda_audio_micro_class_init(ObjectClass *klass, void *data)
 708 {
 709     DeviceClass *dc = DEVICE_CLASS(klass);
 710     HDACodecDeviceClass *k = HDA_CODEC_DEVICE_CLASS(klass);
 711
 712     k->init = hda_audio_init_micro;
 713     dc->desc = "HDA Audio Codec, duplex (speaker, microphone)";
 714 }
 715
 716 static const TypeInfo hda_audio_micro_info = {
 717     .name          = "hda-micro",
 718     .parent        = TYPE_HDA_AUDIO,
 719     .instance_size = sizeof(HDAAudioState),
 720     .class_init    = hda_audio_micro_class_init,
 721 };
 722
 723 static void hda_audio_register_types(void)
 724 {
 725     type_register_static(&hda_audio_info);
 726     type_register_static(&hda_audio_output_info);
 727     type_register_static(&hda_audio_duplex_info);
 728     type_register_static(&hda_audio_micro_info);
 729 }
 730
 731 type_init(hda_audio_register_types)