sound/pci/hda/patch_intelhdmi.c

   1 /*
   2  *
   3  *  patch_intelhdmi.c - Patch for Intel HDMI codecs
   4  *
   5  *  Copyright(c) 2008 Intel Corporation. All rights reserved.
   6  *
   7  *  Authors:
   8  *                      Jiang Zhe <zhe.jiang@intel.com>
   9  *                      Wu Fengguang <wfg@linux.intel.com>
  10  *
  11  *  Maintained by:
  12  *                      Wu Fengguang <wfg@linux.intel.com>
  13  *
  14  *  This program is free software; you can redistribute it and/or modify it
  15  *  under the terms of the GNU General Public License as published by the Free
  16  *  Software Foundation; either version 2 of the License, or (at your option)
  17  *  any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful, but
  20  *  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  21  *  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  22  *  for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software Foundation,
  26  *  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27  */
  28
  29 #include <linux/init.h>
  30 #include <linux/delay.h>
  31 #include <linux/slab.h>
  32 #include <sound/core.h>
  33 #include "hda_codec.h"
  34 #include "hda_local.h"
  35
  36 /*
  37  * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
  38  * could support two independent pipes, each of them can be connected to one or
  39  * more ports (DVI, HDMI or DisplayPort).
  40  *
  41  * The HDA correspondence of pipes/ports are converter/pin nodes.
  42  */
  43 #define MAX_HDMI_CVTS   2
  44 #define MAX_HDMI_PINS   3
  45
  46 #include "patch_hdmi.c"
  47
  48 static char *intel_hdmi_pcm_names[MAX_HDMI_CVTS] = {
  49         "INTEL HDMI 0",
  50         "INTEL HDMI 1",
  51 };
  52
  53 /*
  54  * HDMI callbacks
  55  */
  56
  57 static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  58                                            struct hda_codec *codec,
  59                                            unsigned int stream_tag,
  60                                            unsigned int format,
  61                                            struct snd_pcm_substream *substream)
  62 {
  63         hdmi_set_channel_count(codec, hinfo->nid,
  64                                substream->runtime->channels);
  65
  66         hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
  67
  68         hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
  69         return 0;
  70 }
  71
  72 static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
  73                                            struct hda_codec *codec,
  74                                            struct snd_pcm_substream *substream)
  75 {
  76         return 0;
  77 }
  78
  79 static struct hda_pcm_stream intel_hdmi_pcm_playback = {
  80         .substreams = 1,
  81         .channels_min = 2,
  82         .ops = {
  83                 .prepare = intel_hdmi_playback_pcm_prepare,
  84                 .cleanup = intel_hdmi_playback_pcm_cleanup,
  85         },
  86 };
  87
  88 static int intel_hdmi_build_pcms(struct hda_codec *codec)
  89 {
  90         struct hdmi_spec *spec = codec->spec;
  91         struct hda_pcm *info = spec->pcm_rec;
  92         int i;
  93
  94         codec->num_pcms = spec->num_cvts;
  95         codec->pcm_info = info;
  96
  97         for (i = 0; i < codec->num_pcms; i++, info++) {
  98                 unsigned int chans;
  99
 100                 chans = get_wcaps(codec, spec->cvt[i]);
 101                 chans = get_wcaps_channels(chans);
 102
 103                 info->name = intel_hdmi_pcm_names[i];
 104                 info->pcm_type = HDA_PCM_TYPE_HDMI;
 105                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 106                                                         intel_hdmi_pcm_playback;
 107                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i];
 108                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans;
 109         }
 110
 111         return 0;
 112 }
 113
 114 static int intel_hdmi_build_controls(struct hda_codec *codec)
 115 {
 116         struct hdmi_spec *spec = codec->spec;
 117         int err;
 118         int i;
 119
 120         for (i = 0; i < codec->num_pcms; i++) {
 121                 err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]);
 122                 if (err < 0)
 123                         return err;
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int intel_hdmi_init(struct hda_codec *codec)
 130 {
 131         struct hdmi_spec *spec = codec->spec;
 132         int i;
 133
 134         for (i = 0; spec->pin[i]; i++) {
 135                 hdmi_enable_output(codec, spec->pin[i]);
 136                 snd_hda_codec_write(codec, spec->pin[i], 0,
 137                                     AC_VERB_SET_UNSOLICITED_ENABLE,
 138                                     AC_USRSP_EN | spec->pin[i]);
 139         }
 140         return 0;
 141 }
 142
 143 static void intel_hdmi_free(struct hda_codec *codec)
 144 {
 145         struct hdmi_spec *spec = codec->spec;
 146         int i;
 147
 148         for (i = 0; i < spec->num_pins; i++)
 149                 snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
 150
 151         kfree(spec);
 152 }
 153
 154 static struct hda_codec_ops intel_hdmi_patch_ops = {
 155         .init                   = intel_hdmi_init,
 156         .free                   = intel_hdmi_free,
 157         .build_pcms             = intel_hdmi_build_pcms,
 158         .build_controls         = intel_hdmi_build_controls,
 159         .unsol_event            = hdmi_unsol_event,
 160 };
 161
 162 static int patch_intel_hdmi(struct hda_codec *codec)
 163 {
 164         struct hdmi_spec *spec;
 165         int i;
 166
 167         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 168         if (spec == NULL)
 169                 return -ENOMEM;
 170
 171         codec->spec = spec;
 172         if (hdmi_parse_codec(codec) < 0) {
 173                 codec->spec = NULL;
 174                 kfree(spec);
 175                 return -EINVAL;
 176         }
 177         codec->patch_ops = intel_hdmi_patch_ops;
 178
 179         for (i = 0; i < spec->num_pins; i++)
 180                 snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
 181
 182         init_channel_allocations();
 183
 184         return 0;
 185 }
 186
 187 static struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
 188         { .id = 0x808629fb, .name = "G45 DEVCL",  .patch = patch_intel_hdmi },
 189         { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi },
 190         { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi },
 191         { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi },
 192         { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi },
 193         { .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi },
 194         { .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
 195         {} /* terminator */
 196 };
 197
 198 MODULE_ALIAS("snd-hda-codec-id:808629fb");
 199 MODULE_ALIAS("snd-hda-codec-id:80862801");
 200 MODULE_ALIAS("snd-hda-codec-id:80862802");
 201 MODULE_ALIAS("snd-hda-codec-id:80862803");
 202 MODULE_ALIAS("snd-hda-codec-id:80862804");
 203 MODULE_ALIAS("snd-hda-codec-id:80860054");
 204 MODULE_ALIAS("snd-hda-codec-id:10951392");
 205
 206 MODULE_LICENSE("GPL");
 207 MODULE_DESCRIPTION("Intel HDMI HD-audio codec");
 208
 209 static struct hda_codec_preset_list intel_list = {
 210         .preset = snd_hda_preset_intelhdmi,
 211         .owner = THIS_MODULE,
 212 };
 213
 214 static int __init patch_intelhdmi_init(void)
 215 {
 216         return snd_hda_add_codec_preset(&intel_list);
 217 }
 218
 219 static void __exit patch_intelhdmi_exit(void)
 220 {
 221         snd_hda_delete_codec_preset(&intel_list);
 222 }
 223
 224 module_init(patch_intelhdmi_init)
 225 module_exit(patch_intelhdmi_exit)