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