ALSA: hda - Merge all HDMI modules into the unified module

This patch merges all three patch_*hdmi variants to the single HDMI
parser.  There is only one snd-hda-codec-hdmi module now.

In this patch, the behavior of each parser isn't changed much.
The old ATI parser still doesn't use the dynamic parser yet.
In later patches, they'll be cleaned up.

Also, this patch gets rid of the individual snd-hda-eld module and
builds into snd-hda-codec-hdmi, since this is referred only from the
HDMI parser.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 682 insertions, 3 deletions

diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index afd6022a96a7..cb997ca0fdfa 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -3,6 +3,9 @@
  *  patch_hdmi.c - routines for HDMI/DisplayPort codecs
  *
  *  Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
+ *  Copyright (c) 2006 ATI Technologies Inc.
+ *  Copyright (c) 2008 NVIDIA Corp.  All rights reserved.
+ *  Copyright (c) 2008 Wei Ni <wni@nvidia.com>
  *
  *  Authors:
  *                      Wu Fengguang <wfg@linux.intel.com>
@@ -25,6 +28,22 @@
  *  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include "hda_codec.h"
+#include "hda_local.h"
+
+/*
+ * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
+ * could support two independent pipes, each of them can be connected to one or
+ * more ports (DVI, HDMI or DisplayPort).
+ *
+ * The HDA correspondence of pipes/ports are converter/pin nodes.
+ */
+#define MAX_HDMI_CVTS   3
+#define MAX_HDMI_PINS   3
 
 struct hdmi_spec {
         int num_cvts;
@@ -49,10 +68,10 @@ struct hdmi_spec {
         struct hda_pcm_stream codec_pcm_pars[MAX_HDMI_CVTS];
 
         /*
-         * nvhdmi specific
+         * ati/nvhdmi specific
          */
         struct hda_multi_out multiout;
-        unsigned int codec_type;
+        struct hda_pcm_stream *pcm_playback;
 
         /* misc flags */
         /* PD bit indicates only the update, not the current state */
@@ -791,7 +810,6 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
 /*
  * HDA/HDMI auto parsing
  */
-
 static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid)
 {
         struct hdmi_spec *spec = codec->spec;
@@ -922,3 +940,664 @@ static int hdmi_parse_codec(struct hda_codec *codec)
         return 0;
 }
 
+/*
+ */
+static char *generic_hdmi_pcm_names[MAX_HDMI_CVTS] = {
+        "HDMI 0",
+        "HDMI 1",
+        "HDMI 2",
+};
+
+/*
+ * HDMI callbacks
+ */
+
+static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                           struct hda_codec *codec,
+                                           unsigned int stream_tag,
+                                           unsigned int format,
+                                           struct snd_pcm_substream *substream)
+{
+        hdmi_set_channel_count(codec, hinfo->nid,
+                               substream->runtime->channels);
+
+        hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
+
+        return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
+}
+
+static struct hda_pcm_stream generic_hdmi_pcm_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .ops = {
+                .open = hdmi_pcm_open,
+                .prepare = generic_hdmi_playback_pcm_prepare,
+        },
+};
+
+static int generic_hdmi_build_pcms(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
+        int i;
+
+        codec->num_pcms = spec->num_cvts;
+        codec->pcm_info = info;
+
+        for (i = 0; i < codec->num_pcms; i++, info++) {
+                unsigned int chans;
+                struct hda_pcm_stream *pstr;
+
+                chans = get_wcaps(codec, spec->cvt[i]);
+                chans = get_wcaps_channels(chans);
+
+                info->name = generic_hdmi_pcm_names[i];
+                info->pcm_type = HDA_PCM_TYPE_HDMI;
+                pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
+                if (spec->pcm_playback)
+                        *pstr = *spec->pcm_playback;
+                else
+                        *pstr = generic_hdmi_pcm_playback;
+                pstr->nid = spec->cvt[i];
+                if (pstr->channels_max <= 2 && chans && chans <= 16)
+                        pstr->channels_max = chans;
+        }
+
+        return 0;
+}
+
+static int generic_hdmi_build_controls(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int err;
+        int i;
+
+        for (i = 0; i < codec->num_pcms; i++) {
+                err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int generic_hdmi_init(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; spec->pin[i]; i++) {
+                hdmi_enable_output(codec, spec->pin[i]);
+                snd_hda_codec_write(codec, spec->pin[i], 0,
+                                    AC_VERB_SET_UNSOLICITED_ENABLE,
+                                    AC_USRSP_EN | spec->pin[i]);
+        }
+        return 0;
+}
+
+static void generic_hdmi_free(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->num_pins; i++)
+                snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
+
+        kfree(spec);
+}
+
+static struct hda_codec_ops generic_hdmi_patch_ops = {
+        .init                   = generic_hdmi_init,
+        .free                   = generic_hdmi_free,
+        .build_pcms             = generic_hdmi_build_pcms,
+        .build_controls         = generic_hdmi_build_controls,
+        .unsol_event            = hdmi_unsol_event,
+};
+
+static int patch_generic_hdmi(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+        int i;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+        if (hdmi_parse_codec(codec) < 0) {
+                codec->spec = NULL;
+                kfree(spec);
+                return -EINVAL;
+        }
+        codec->patch_ops = generic_hdmi_patch_ops;
+
+        for (i = 0; i < spec->num_pins; i++)
+                snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
+
+        init_channel_allocations();
+
+        return 0;
+}
+
+/*
+ * Nvidia specific implementations
+ */
+
+#define Nv_VERB_SET_Channel_Allocation          0xF79
+#define Nv_VERB_SET_Info_Frame_Checksum         0xF7A
+#define Nv_VERB_SET_Audio_Protection_On         0xF98
+#define Nv_VERB_SET_Audio_Protection_Off        0xF99
+
+#define nvhdmi_master_con_nid_7x        0x04
+#define nvhdmi_master_pin_nid_7x        0x05
+
+static hda_nid_t nvhdmi_con_nids_7x[4] = {
+        /*front, rear, clfe, rear_surr */
+        0x6, 0x8, 0xa, 0xc,
+};
+
+static struct hda_verb nvhdmi_basic_init_7x[] = {
+        /* set audio protect on */
+        { 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
+        /* enable digital output on pin widget */
+        { 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
+        { 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
+        { 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
+        { 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
+        { 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
+        {} /* terminator */
+};
+
+#ifdef LIMITED_RATE_FMT_SUPPORT
+/* support only the safe format and rate */
+#define SUPPORTED_RATES         SNDRV_PCM_RATE_48000
+#define SUPPORTED_MAXBPS        16
+#define SUPPORTED_FORMATS       SNDRV_PCM_FMTBIT_S16_LE
+#else
+/* support all rates and formats */
+#define SUPPORTED_RATES \
+        (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
+        SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
+         SNDRV_PCM_RATE_192000)
+#define SUPPORTED_MAXBPS        24
+#define SUPPORTED_FORMATS \
+        (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
+#endif
+
+static int nvhdmi_7x_init(struct hda_codec *codec)
+{
+        snd_hda_sequence_write(codec, nvhdmi_basic_init_7x);
+        return 0;
+}
+
+static int simple_playback_pcm_open(struct hda_pcm_stream *hinfo,
+                                    struct hda_codec *codec,
+                                    struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
+}
+
+static int simple_playback_pcm_close(struct hda_pcm_stream *hinfo,
+                                     struct hda_codec *codec,
+                                     struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
+}
+
+static int simple_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       unsigned int stream_tag,
+                                       unsigned int format,
+                                       struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
+                                             stream_tag, format, substream);
+}
+
+static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream *hinfo,
+                                   struct hda_codec *codec,
+                                   struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x,
+                        0, AC_VERB_SET_CHANNEL_STREAMID, 0);
+        for (i = 0; i < 4; i++) {
+                /* set the stream id */
+                snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
+                                AC_VERB_SET_CHANNEL_STREAMID, 0);
+                /* set the stream format */
+                snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
+                                AC_VERB_SET_STREAM_FORMAT, 0);
+        }
+
+        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
+}
+
+static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                     struct hda_codec *codec,
+                                     unsigned int stream_tag,
+                                     unsigned int format,
+                                     struct snd_pcm_substream *substream)
+{
+        int chs;
+        unsigned int dataDCC1, dataDCC2, chan, chanmask, channel_id;
+        int i;
+
+        mutex_lock(&codec->spdif_mutex);
+
+        chs = substream->runtime->channels;
+        chan = chs ? (chs - 1) : 1;
+
+        switch (chs) {
+        default:
+        case 0:
+        case 2:
+                chanmask = 0x00;
+                break;
+        case 4:
+                chanmask = 0x08;
+                break;
+        case 6:
+                chanmask = 0x0b;
+                break;
+        case 8:
+                chanmask = 0x13;
+                break;
+        }
+        dataDCC1 = AC_DIG1_ENABLE | AC_DIG1_COPYRIGHT;
+        dataDCC2 = 0x2;
+
+        /* set the Audio InforFrame Channel Allocation */
+        snd_hda_codec_write(codec, 0x1, 0,
+                        Nv_VERB_SET_Channel_Allocation, chanmask);
+
+        /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
+        if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
+                snd_hda_codec_write(codec,
+                                nvhdmi_master_con_nid_7x,
+                                0,
+                                AC_VERB_SET_DIGI_CONVERT_1,
+                                codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
+
+        /* set the stream id */
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
+                        AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0);
+
+        /* set the stream format */
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
+                        AC_VERB_SET_STREAM_FORMAT, format);
+
+        /* turn on again (if needed) */
+        /* enable and set the channel status audio/data flag */
+        if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) {
+                snd_hda_codec_write(codec,
+                                nvhdmi_master_con_nid_7x,
+                                0,
+                                AC_VERB_SET_DIGI_CONVERT_1,
+                                codec->spdif_ctls & 0xff);
+                snd_hda_codec_write(codec,
+                                nvhdmi_master_con_nid_7x,
+                                0,
+                                AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
+        }
+
+        for (i = 0; i < 4; i++) {
+                if (chs == 2)
+                        channel_id = 0;
+                else
+                        channel_id = i * 2;
+
+                /* turn off SPDIF once;
+                 *otherwise the IEC958 bits won't be updated
+                 */
+                if (codec->spdif_status_reset &&
+                (codec->spdif_ctls & AC_DIG1_ENABLE))
+                        snd_hda_codec_write(codec,
+                                nvhdmi_con_nids_7x[i],
+                                0,
+                                AC_VERB_SET_DIGI_CONVERT_1,
+                                codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
+                /* set the stream id */
+                snd_hda_codec_write(codec,
+                                nvhdmi_con_nids_7x[i],
+                                0,
+                                AC_VERB_SET_CHANNEL_STREAMID,
+                                (stream_tag << 4) | channel_id);
+                /* set the stream format */
+                snd_hda_codec_write(codec,
+                                nvhdmi_con_nids_7x[i],
+                                0,
+                                AC_VERB_SET_STREAM_FORMAT,
+                                format);
+                /* turn on again (if needed) */
+                /* enable and set the channel status audio/data flag */
+                if (codec->spdif_status_reset &&
+                (codec->spdif_ctls & AC_DIG1_ENABLE)) {
+                        snd_hda_codec_write(codec,
+                                        nvhdmi_con_nids_7x[i],
+                                        0,
+                                        AC_VERB_SET_DIGI_CONVERT_1,
+                                        codec->spdif_ctls & 0xff);
+                        snd_hda_codec_write(codec,
+                                        nvhdmi_con_nids_7x[i],
+                                        0,
+                                        AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
+                }
+        }
+
+        /* set the Audio Info Frame Checksum */
+        snd_hda_codec_write(codec, 0x1, 0,
+                        Nv_VERB_SET_Info_Frame_Checksum,
+                        (0x71 - chan - chanmask));
+
+        mutex_unlock(&codec->spdif_mutex);
+        return 0;
+}
+
+static struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 8,
+        .nid = nvhdmi_master_con_nid_7x,
+        .rates = SUPPORTED_RATES,
+        .maxbps = SUPPORTED_MAXBPS,
+        .formats = SUPPORTED_FORMATS,
+        .ops = {
+                .open = simple_playback_pcm_open,
+                .close = nvhdmi_8ch_7x_pcm_close,
+                .prepare = nvhdmi_8ch_7x_pcm_prepare
+        },
+};
+
+static struct hda_pcm_stream nvhdmi_pcm_playback_2ch = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = nvhdmi_master_con_nid_7x,
+        .rates = SUPPORTED_RATES,
+        .maxbps = SUPPORTED_MAXBPS,
+        .formats = SUPPORTED_FORMATS,
+        .ops = {
+                .open = simple_playback_pcm_open,
+                .close = simple_playback_pcm_close,
+                .prepare = simple_playback_pcm_prepare
+        },
+};
+
+static struct hda_codec_ops nvhdmi_patch_ops_8ch_7x = {
+        .build_controls = generic_hdmi_build_controls,
+        .build_pcms = generic_hdmi_build_pcms,
+        .init = nvhdmi_7x_init,
+        .free = generic_hdmi_free,
+};
+
+static struct hda_codec_ops nvhdmi_patch_ops_2ch = {
+        .build_controls = generic_hdmi_build_controls,
+        .build_pcms = generic_hdmi_build_pcms,
+        .init = nvhdmi_7x_init,
+        .free = generic_hdmi_free,
+};
+
+static int patch_nvhdmi_8ch_89(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+        int err = patch_generic_hdmi(codec);
+
+        if (err < 0)
+                return err;
+        spec = codec->spec;
+        spec->old_pin_detect = 1;
+        return 0;
+}
+
+static int patch_nvhdmi_2ch(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        spec->multiout.num_dacs = 0;  /* no analog */
+        spec->multiout.max_channels = 2;
+        spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
+        spec->old_pin_detect = 1;
+        spec->num_cvts = 1;
+        spec->cvt[0] = nvhdmi_master_con_nid_7x;
+        spec->pcm_playback = &nvhdmi_pcm_playback_2ch;
+
+        codec->patch_ops = nvhdmi_patch_ops_2ch;
+
+        return 0;
+}
+
+static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+        int err = patch_nvhdmi_2ch(codec);
+
+        if (err < 0)
+                return err;
+        spec = codec->spec;
+        spec->multiout.max_channels = 8;
+        spec->pcm_playback = &nvhdmi_pcm_playback_8ch_7x;
+        codec->patch_ops = nvhdmi_patch_ops_8ch_7x;
+        return 0;
+}
+
+/*
+ * ATI-specific implementations
+ *
+ * FIXME: we may omit the whole this and use the generic code once after
+ * it's confirmed to work.
+ */
+
+#define ATIHDMI_CVT_NID         0x02    /* audio converter */
+#define ATIHDMI_PIN_NID         0x03    /* HDMI output pin */
+
+static int atihdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                        struct hda_codec *codec,
+                                        unsigned int stream_tag,
+                                        unsigned int format,
+                                        struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int chans = substream->runtime->channels;
+        int i, err;
+
+        err = simple_playback_pcm_prepare(hinfo, codec, stream_tag, format,
+                                          substream);
+        if (err < 0)
+                return err;
+        snd_hda_codec_write(codec, spec->cvt[0], 0, AC_VERB_SET_CVT_CHAN_COUNT,
+                            chans - 1);
+        /* FIXME: XXX */
+        for (i = 0; i < chans; i++) {
+                snd_hda_codec_write(codec, spec->cvt[0], 0,
+                                    AC_VERB_SET_HDMI_CHAN_SLOT,
+                                    (i << 4) | i);
+        }
+        return 0;
+}
+
+static struct hda_pcm_stream atihdmi_pcm_digital_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = ATIHDMI_CVT_NID,
+        .ops = {
+                .open = simple_playback_pcm_open,
+                .close = simple_playback_pcm_close,
+                .prepare = atihdmi_playback_pcm_prepare
+        },
+};
+
+static struct hda_verb atihdmi_basic_init[] = {
+        /* enable digital output on pin widget */
+        { 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {} /* terminator */
+};
+
+static int atihdmi_init(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+
+        snd_hda_sequence_write(codec, atihdmi_basic_init);
+        /* SI codec requires to unmute the pin */
+        if (get_wcaps(codec, spec->pin[0]) & AC_WCAP_OUT_AMP)
+                snd_hda_codec_write(codec, spec->pin[0], 0,
+                                    AC_VERB_SET_AMP_GAIN_MUTE,
+                                    AMP_OUT_UNMUTE);
+        return 0;
+}
+
+static struct hda_codec_ops atihdmi_patch_ops = {
+        .build_controls = generic_hdmi_build_controls,
+        .build_pcms = generic_hdmi_build_pcms,
+        .init = atihdmi_init,
+        .free = generic_hdmi_free,
+};
+
+
+static int patch_atihdmi(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        spec->multiout.num_dacs = 0;      /* no analog */
+        spec->multiout.max_channels = 2;
+        spec->multiout.dig_out_nid = ATIHDMI_CVT_NID;
+        spec->num_cvts = 1;
+        spec->cvt[0] = ATIHDMI_CVT_NID;
+        spec->pin[0] = ATIHDMI_PIN_NID;
+        spec->pcm_playback = &atihdmi_pcm_digital_playback;
+
+        codec->patch_ops = atihdmi_patch_ops;
+
+        return 0;
+}
+
+
+/*
+ * patch entries
+ */
+static struct hda_codec_preset snd_hda_preset_hdmi[] = {
+{ .id = 0x1002793c, .name = "RS600 HDMI",       .patch = patch_atihdmi },
+{ .id = 0x10027919, .name = "RS600 HDMI",       .patch = patch_atihdmi },
+{ .id = 0x1002791a, .name = "RS690/780 HDMI",   .patch = patch_atihdmi },
+{ .id = 0x1002aa01, .name = "R6xx HDMI",        .patch = patch_atihdmi },
+{ .id = 0x10951390, .name = "SiI1390 HDMI",     .patch = patch_generic_hdmi },
+{ .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_generic_hdmi },
+{ .id = 0x17e80047, .name = "Chrontel HDMI",    .patch = patch_generic_hdmi },
+{ .id = 0x10de0002, .name = "MCP77/78 HDMI",    .patch = patch_nvhdmi_8ch_7x },
+{ .id = 0x10de0003, .name = "MCP77/78 HDMI",    .patch = patch_nvhdmi_8ch_7x },
+{ .id = 0x10de0005, .name = "MCP77/78 HDMI",    .patch = patch_nvhdmi_8ch_7x },
+{ .id = 0x10de0006, .name = "MCP77/78 HDMI",    .patch = patch_nvhdmi_8ch_7x },
+{ .id = 0x10de0007, .name = "MCP79/7A HDMI",    .patch = patch_nvhdmi_8ch_7x },
+{ .id = 0x10de000a, .name = "GPU 0a HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de000b, .name = "GPU 0b HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de000c, .name = "MCP89 HDMI",       .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de000d, .name = "GPU 0d HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0010, .name = "GPU 10 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0011, .name = "GPU 11 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0012, .name = "GPU 12 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0013, .name = "GPU 13 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0014, .name = "GPU 14 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0018, .name = "GPU 18 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0019, .name = "GPU 19 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de001a, .name = "GPU 1a HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de001b, .name = "GPU 1b HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de001c, .name = "GPU 1c HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0040, .name = "GPU 40 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0041, .name = "GPU 41 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0042, .name = "GPU 42 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0043, .name = "GPU 43 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0044, .name = "GPU 44 HDMI/DP",   .patch = patch_nvhdmi_8ch_89 },
+{ .id = 0x10de0067, .name = "MCP67 HDMI",       .patch = patch_nvhdmi_2ch },
+{ .id = 0x10de8001, .name = "MCP73 HDMI",       .patch = patch_nvhdmi_2ch },
+{ .id = 0x80860054, .name = "IbexPeak HDMI",    .patch = patch_generic_hdmi },
+{ .id = 0x80862801, .name = "Bearlake HDMI",    .patch = patch_generic_hdmi },
+{ .id = 0x80862802, .name = "Cantiga HDMI",     .patch = patch_generic_hdmi },
+{ .id = 0x80862803, .name = "Eaglelake HDMI",   .patch = patch_generic_hdmi },
+{ .id = 0x80862804, .name = "IbexPeak HDMI",    .patch = patch_generic_hdmi },
+{ .id = 0x80862805, .name = "CougarPoint HDMI", .patch = patch_generic_hdmi },
+{ .id = 0x808629fb, .name = "Crestline HDMI",   .patch = patch_generic_hdmi },
+{} /* terminator */
+};
+
+MODULE_ALIAS("snd-hda-codec-id:1002793c");
+MODULE_ALIAS("snd-hda-codec-id:10027919");
+MODULE_ALIAS("snd-hda-codec-id:1002791a");
+MODULE_ALIAS("snd-hda-codec-id:1002aa01");
+MODULE_ALIAS("snd-hda-codec-id:10951390");
+MODULE_ALIAS("snd-hda-codec-id:10951392");
+MODULE_ALIAS("snd-hda-codec-id:10de0002");
+MODULE_ALIAS("snd-hda-codec-id:10de0003");
+MODULE_ALIAS("snd-hda-codec-id:10de0005");
+MODULE_ALIAS("snd-hda-codec-id:10de0006");
+MODULE_ALIAS("snd-hda-codec-id:10de0007");
+MODULE_ALIAS("snd-hda-codec-id:10de000a");
+MODULE_ALIAS("snd-hda-codec-id:10de000b");
+MODULE_ALIAS("snd-hda-codec-id:10de000c");
+MODULE_ALIAS("snd-hda-codec-id:10de000d");
+MODULE_ALIAS("snd-hda-codec-id:10de0010");
+MODULE_ALIAS("snd-hda-codec-id:10de0011");
+MODULE_ALIAS("snd-hda-codec-id:10de0012");
+MODULE_ALIAS("snd-hda-codec-id:10de0013");
+MODULE_ALIAS("snd-hda-codec-id:10de0014");
+MODULE_ALIAS("snd-hda-codec-id:10de0018");
+MODULE_ALIAS("snd-hda-codec-id:10de0019");
+MODULE_ALIAS("snd-hda-codec-id:10de001a");
+MODULE_ALIAS("snd-hda-codec-id:10de001b");
+MODULE_ALIAS("snd-hda-codec-id:10de001c");
+MODULE_ALIAS("snd-hda-codec-id:10de0040");
+MODULE_ALIAS("snd-hda-codec-id:10de0041");
+MODULE_ALIAS("snd-hda-codec-id:10de0042");
+MODULE_ALIAS("snd-hda-codec-id:10de0043");
+MODULE_ALIAS("snd-hda-codec-id:10de0044");
+MODULE_ALIAS("snd-hda-codec-id:10de0067");
+MODULE_ALIAS("snd-hda-codec-id:10de8001");
+MODULE_ALIAS("snd-hda-codec-id:17e80047");
+MODULE_ALIAS("snd-hda-codec-id:80860054");
+MODULE_ALIAS("snd-hda-codec-id:80862801");
+MODULE_ALIAS("snd-hda-codec-id:80862802");
+MODULE_ALIAS("snd-hda-codec-id:80862803");
+MODULE_ALIAS("snd-hda-codec-id:80862804");
+MODULE_ALIAS("snd-hda-codec-id:80862805");
+MODULE_ALIAS("snd-hda-codec-id:808629fb");
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("HDMI HD-audio codec");
+MODULE_ALIAS("snd-hda-codec-intelhdmi");
+MODULE_ALIAS("snd-hda-codec-nvhdmi");
+MODULE_ALIAS("snd-hda-codec-atihdmi");
+
+static struct hda_codec_preset_list intel_list = {
+        .preset = snd_hda_preset_hdmi,
+        .owner = THIS_MODULE,
+};
+
+static int __init patch_hdmi_init(void)
+{
+        return snd_hda_add_codec_preset(&intel_list);
+}
+
+static void __exit patch_hdmi_exit(void)
+{
+        snd_hda_delete_codec_preset(&intel_list);
+}
+
+module_init(patch_hdmi_init)
+module_exit(patch_hdmi_exit)