git.oblomov.eu Git - linux-2.6/blob - 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 <asm/unaligned.h>
  34 #include "hda_codec.h"
  35 #include "hda_local.h"
  36 #include "hda_patch.h"
  37
  38 #define CVT_NID         0x02    /* audio converter */
  39 #define PIN_NID         0x03    /* HDMI output pin */
  40
  41 #define INTEL_HDMI_EVENT_TAG            0x08
  42
  43 /*
  44  * CEA Short Audio Descriptor data
  45  */
  46 struct cea_sad {
  47         int     channels;
  48         int     format;         /* (format == 0) indicates invalid SAD */
  49         int     rates;
  50         int     sample_bits;    /* for LPCM */
  51         int     max_bitrate;    /* for AC3...ATRAC */
  52         int     profile;        /* for WMAPRO */
  53 };
  54
  55 #define ELD_FIXED_BYTES 20
  56 #define ELD_MAX_MNL     16
  57 #define ELD_MAX_SAD     16
  58
  59 /*
  60  * ELD: EDID Like Data
  61  */
  62 struct sink_eld {
  63         int     eld_size;
  64         int     baseline_len;
  65         int     eld_ver;        /* (eld_ver == 0) indicates invalid ELD */
  66         int     cea_edid_ver;
  67         char    monitor_name[ELD_MAX_MNL + 1];
  68         int     manufacture_id;
  69         int     product_id;
  70         u64     port_id;
  71         int     support_hdcp;
  72         int     support_ai;
  73         int     conn_type;
  74         int     aud_synch_delay;
  75         int     spk_alloc;
  76         int     sad_count;
  77         struct cea_sad sad[ELD_MAX_SAD];
  78 };
  79
  80 struct intel_hdmi_spec {
  81         struct hda_multi_out multiout;
  82         struct hda_pcm pcm_rec;
  83         struct sink_eld sink;
  84 };
  85
  86 static struct hda_verb pinout_enable_verb[] = {
  87         {PIN_NID, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  88         {} /* terminator */
  89 };
  90
  91 static struct hda_verb pinout_disable_verb[] = {
  92         {PIN_NID, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00},
  93         {}
  94 };
  95
  96 static struct hda_verb unsolicited_response_verb[] = {
  97         {PIN_NID, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN |
  98                                                   INTEL_HDMI_EVENT_TAG},
  99         {}
 100 };
 101
 102 static struct hda_verb def_chan_map[] = {
 103         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x00},
 104         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x11},
 105         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x22},
 106         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x33},
 107         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x44},
 108         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x55},
 109         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x66},
 110         {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x77},
 111         {}
 112 };
 113
 114
 115 struct hdmi_audio_infoframe {
 116         u8 type; /* 0x84 */
 117         u8 ver;  /* 0x01 */
 118         u8 len;  /* 0x0a */
 119
 120         u8 checksum;    /* PB0 */
 121         u8 CC02_CT47;   /* CC in bits 0:2, CT in 4:7 */
 122         u8 SS01_SF24;
 123         u8 CXT04;
 124         u8 CA;
 125         u8 LFEPBL01_LSV36_DM_INH7;
 126         u8 reserved[5]; /* PB6  - PB10 */
 127 };
 128
 129 /*
 130  * SS1:SS0 index => sample size
 131  */
 132 static int cea_sample_sizes[4] = {
 133         0,                      /* 0: Refer to Stream Header */
 134         AC_SUPPCM_BITS_16,      /* 1: 16 bits */
 135         AC_SUPPCM_BITS_20,      /* 2: 20 bits */
 136         AC_SUPPCM_BITS_24,      /* 3: 24 bits */
 137 };
 138
 139 /*
 140  * SF2:SF1:SF0 index => sampling frequency
 141  */
 142 static int cea_sampling_frequencies[8] = {
 143         0,                      /* 0: Refer to Stream Header */
 144         SNDRV_PCM_RATE_32000,   /* 1:  32000Hz */
 145         SNDRV_PCM_RATE_44100,   /* 2:  44100Hz */
 146         SNDRV_PCM_RATE_48000,   /* 3:  48000Hz */
 147         SNDRV_PCM_RATE_88200,   /* 4:  88200Hz */
 148         SNDRV_PCM_RATE_96000,   /* 5:  96000Hz */
 149         SNDRV_PCM_RATE_176400,  /* 6: 176400Hz */
 150         SNDRV_PCM_RATE_192000,  /* 7: 192000Hz */
 151 };
 152
 153 enum eld_versions {
 154         ELD_VER_CEA_861D        = 2,
 155         ELD_VER_PARTIAL         = 31,
 156 };
 157
 158 static char *eld_versoin_names[32] = {
 159         "0-reserved",
 160         "1-reserved",
 161         "CEA-861D or below",
 162         "3-reserved",
 163         [4 ... 30] = "reserved",
 164         [31] = "partial"
 165 };
 166
 167 enum cea_edid_versions {
 168         CEA_EDID_VER_NONE       = 0,
 169         CEA_EDID_VER_CEA861     = 1,
 170         CEA_EDID_VER_CEA861A    = 2,
 171         CEA_EDID_VER_CEA861BCD  = 3,
 172         CEA_EDID_VER_RESERVED   = 4,
 173 };
 174
 175 static char *cea_edid_version_names[8] = {
 176         "no CEA EDID Timing Extension block present",
 177         "CEA-861",
 178         "CEA-861-A",
 179         "CEA-861-B, C or D",
 180         "4-reserved",
 181         [5 ... 7] = "reserved"
 182 };
 183
 184 /*
 185  * CEA Speaker Allocation data block bits
 186  */
 187 #define CEA_SA_FLR      (0 << 0)
 188 #define CEA_SA_LFE      (1 << 1)
 189 #define CEA_SA_FC       (1 << 2)
 190 #define CEA_SA_RLR      (1 << 3)
 191 #define CEA_SA_RC       (1 << 4)
 192 #define CEA_SA_FLRC     (1 << 5)
 193 #define CEA_SA_RLRC     (1 << 6)
 194 /* the following are not defined in ELD yet */
 195 #define CEA_SA_FLRW     (1 << 7)
 196 #define CEA_SA_FLRH     (1 << 8)
 197 #define CEA_SA_TC       (1 << 9)
 198 #define CEA_SA_FCH      (1 << 10)
 199
 200 static char *cea_speaker_allocation_names[] = {
 201         /*  0 */ "FL/FR",
 202         /*  1 */ "LFE",
 203         /*  2 */ "FC",
 204         /*  3 */ "RL/RR",
 205         /*  4 */ "RC",
 206         /*  5 */ "FLC/FRC",
 207         /*  6 */ "RLC/RRC",
 208         /*  7 */ "FLW/FRW",
 209         /*  8 */ "FLH/FRH",
 210         /*  9 */ "TC",
 211         /* 10 */ "FCH",
 212 };
 213
 214 static char *eld_connection_type_names[4] = {
 215         "HDMI",
 216         "Display Port",
 217         "2-reserved",
 218         "3-reserved"
 219 };
 220
 221 enum cea_audio_coding_types {
 222         AUDIO_CODING_TYPE_REF_STREAM_HEADER     =  0,
 223         AUDIO_CODING_TYPE_LPCM                  =  1,
 224         AUDIO_CODING_TYPE_AC3                   =  2,
 225         AUDIO_CODING_TYPE_MPEG1                 =  3,
 226         AUDIO_CODING_TYPE_MP3                   =  4,
 227         AUDIO_CODING_TYPE_MPEG2                 =  5,
 228         AUDIO_CODING_TYPE_AACLC                 =  6,
 229         AUDIO_CODING_TYPE_DTS                   =  7,
 230         AUDIO_CODING_TYPE_ATRAC                 =  8,
 231         AUDIO_CODING_TYPE_SACD                  =  9,
 232         AUDIO_CODING_TYPE_EAC3                  = 10,
 233         AUDIO_CODING_TYPE_DTS_HD                = 11,
 234         AUDIO_CODING_TYPE_MLP                   = 12,
 235         AUDIO_CODING_TYPE_DST                   = 13,
 236         AUDIO_CODING_TYPE_WMAPRO                = 14,
 237         AUDIO_CODING_TYPE_REF_CXT               = 15,
 238         /* also include valid xtypes below */
 239         AUDIO_CODING_TYPE_HE_AAC                = 15,
 240         AUDIO_CODING_TYPE_HE_AAC2               = 16,
 241         AUDIO_CODING_TYPE_MPEG_SURROUND         = 17,
 242 };
 243
 244 enum cea_audio_coding_xtypes {
 245         AUDIO_CODING_XTYPE_HE_REF_CT            = 0,
 246         AUDIO_CODING_XTYPE_HE_AAC               = 1,
 247         AUDIO_CODING_XTYPE_HE_AAC2              = 2,
 248         AUDIO_CODING_XTYPE_MPEG_SURROUND        = 3,
 249         AUDIO_CODING_XTYPE_FIRST_RESERVED       = 4,
 250 };
 251
 252 static char *cea_audio_coding_type_names[] = {
 253         /*  0 */ "undefined",
 254         /*  1 */ "LPCM",
 255         /*  2 */ "AC-3",
 256         /*  3 */ "MPEG1",
 257         /*  4 */ "MP3",
 258         /*  5 */ "MPEG2",
 259         /*  6 */ "AAC-LC",
 260         /*  7 */ "DTS",
 261         /*  8 */ "ATRAC",
 262         /*  9 */ "DSD(1-bit audio)",
 263         /* 10 */ "Dolby Digital Plus(E-AC-3/DD+)",
 264         /* 11 */ "DTS-HD",
 265         /* 12 */ "Dolby TrueHD(MLP)",
 266         /* 13 */ "DST",
 267         /* 14 */ "WMAPro",
 268         /* 15 */ "HE-AAC",
 269         /* 16 */ "HE-AACv2",
 270         /* 17 */ "MPEG Surround",
 271 };
 272
 273
 274 /*
 275  * HDMI routines
 276  */
 277
 278 static int hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid)
 279 {
 280         return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE,
 281                                                  AC_DIPSIZE_ELD_BUF);
 282 }
 283
 284 #ifdef BE_PARANOID
 285 static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t nid,
 286                                 int *packet_index, int *byte_index)
 287 {
 288         int val;
 289
 290         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_INDEX, 0);
 291
 292         *packet_index = val >> 5;
 293         *byte_index = val & 0x1f;
 294 }
 295 #endif
 296
 297 static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t nid,
 298                                 int packet_index, int byte_index)
 299 {
 300         int val;
 301
 302         val = (packet_index << 5) | (byte_index & 0x1f);
 303
 304         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
 305 }
 306
 307 static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t nid,
 308                                 unsigned char val)
 309 {
 310         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
 311 }
 312
 313 static void hdmi_enable_output(struct hda_codec *codec)
 314 {
 315         /* Enable pin out and unmute */
 316         snd_hda_sequence_write(codec, pinout_enable_verb);
 317         if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP)
 318                 snd_hda_codec_write(codec, PIN_NID, 0,
 319                                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
 320
 321         /* Enable Audio InfoFrame Transmission */
 322         hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
 323         snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
 324                                                 AC_DIPXMIT_BEST);
 325 }
 326
 327 static void hdmi_disable_output(struct hda_codec *codec)
 328 {
 329         snd_hda_sequence_write(codec, pinout_disable_verb);
 330         if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP)
 331                 snd_hda_codec_write(codec, PIN_NID, 0,
 332                                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 333
 334         /*
 335          * FIXME: noises may arise when playing music after reloading the
 336          * kernel module, until the next X restart or monitor repower.
 337          */
 338 }
 339
 340 static int hdmi_get_channel_count(struct hda_codec *codec)
 341 {
 342         return 1 + snd_hda_codec_read(codec, CVT_NID, 0,
 343                                         AC_VERB_GET_CVT_CHAN_COUNT, 0);
 344 }
 345
 346 static void hdmi_set_channel_count(struct hda_codec *codec, int chs)
 347 {
 348         snd_hda_codec_write(codec, CVT_NID, 0,
 349                                         AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
 350
 351         if (chs != hdmi_get_channel_count(codec))
 352                 snd_printd(KERN_INFO "Channel count expect=%d, real=%d\n",
 353                                 chs, hdmi_get_channel_count(codec));
 354 }
 355
 356 static void hdmi_debug_slot_mapping(struct hda_codec *codec)
 357 {
 358 #ifdef CONFIG_SND_DEBUG_VERBOSE
 359         int i;
 360         int slot;
 361
 362         for (i = 0; i < 8; i++) {
 363                 slot = snd_hda_codec_read(codec, CVT_NID, 0,
 364                                                 AC_VERB_GET_HDMI_CHAN_SLOT, i);
 365                 printk(KERN_DEBUG "ASP channel %d => slot %d\n",
 366                                 slot >> 4, slot & 0x7);
 367         }
 368 #endif
 369 }
 370
 371 static void hdmi_setup_channel_mapping(struct hda_codec *codec)
 372 {
 373         snd_hda_sequence_write(codec, def_chan_map);
 374         hdmi_debug_slot_mapping(codec);
 375 }
 376
 377
 378 /*
 379  * ELD(EDID Like Data) routines
 380  */
 381
 382 static int hdmi_present_sense(struct hda_codec *codec, hda_nid_t nid)
 383 {
 384         return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0);
 385 }
 386
 387 static void hdmi_debug_present_sense(struct hda_codec *codec)
 388 {
 389 #ifdef CONFIG_SND_DEBUG_VERBOSE
 390         int eldv;
 391         int present;
 392
 393         present = hdmi_present_sense(codec, PIN_NID);
 394         eldv    = (present & AC_PINSENSE_ELDV);
 395         present = (present & AC_PINSENSE_PRESENCE);
 396
 397         printk(KERN_INFO "pinp = %d, eldv = %d\n", !!present, !!eldv);
 398 #endif
 399 }
 400
 401 static unsigned char hdmi_get_eld_byte(struct hda_codec *codec, int byte_index)
 402 {
 403         unsigned int val;
 404
 405         val = snd_hda_codec_read(codec, PIN_NID, 0,
 406                                         AC_VERB_GET_HDMI_ELDD, byte_index);
 407
 408 #ifdef BE_PARANOID
 409         printk(KERN_INFO "ELD data byte %d: 0x%x\n", byte_index, val);
 410 #endif
 411
 412         if ((val & AC_ELDD_ELD_VALID) == 0) {
 413                 snd_printd(KERN_INFO "Invalid ELD data byte %d\n",
 414                                                                 byte_index);
 415                 val = 0;
 416         }
 417
 418         return val & AC_ELDD_ELD_DATA;
 419 }
 420
 421 static inline unsigned char grab_bits(const unsigned char *buf,
 422                                                 int byte, int lowbit, int bits)
 423 {
 424         BUG_ON(lowbit > 7);
 425         BUG_ON(bits > 8);
 426         BUG_ON(bits <= 0);
 427
 428         return (buf[byte] >> lowbit) & ((1 << bits) - 1);
 429 }
 430
 431 static void hdmi_update_short_audio_desc(struct cea_sad *a,
 432                                          const unsigned char *buf)
 433 {
 434         int i;
 435         int val;
 436
 437         val = grab_bits(buf, 1, 0, 7);
 438         a->rates = 0;
 439         for (i = 0; i < 7; i++)
 440                 if (val & (1 << i))
 441                         a->rates |= cea_sampling_frequencies[i + 1];
 442
 443         a->channels = grab_bits(buf, 0, 0, 3);
 444         a->channels++;
 445
 446         a->format = grab_bits(buf, 0, 3, 4);
 447         switch (a->format) {
 448         case AUDIO_CODING_TYPE_REF_STREAM_HEADER:
 449                 snd_printd(KERN_INFO
 450                                 "audio coding type 0 not expected in ELD\n");
 451                 break;
 452
 453         case AUDIO_CODING_TYPE_LPCM:
 454                 val = grab_bits(buf, 2, 0, 3);
 455                 a->sample_bits = 0;
 456                 for (i = 0; i < 3; i++)
 457                         if (val & (1 << i))
 458                                 a->sample_bits |= cea_sample_sizes[i + 1];
 459                 break;
 460
 461         case AUDIO_CODING_TYPE_AC3:
 462         case AUDIO_CODING_TYPE_MPEG1:
 463         case AUDIO_CODING_TYPE_MP3:
 464         case AUDIO_CODING_TYPE_MPEG2:
 465         case AUDIO_CODING_TYPE_AACLC:
 466         case AUDIO_CODING_TYPE_DTS:
 467         case AUDIO_CODING_TYPE_ATRAC:
 468                 a->max_bitrate = grab_bits(buf, 2, 0, 8);
 469                 a->max_bitrate *= 8000;
 470                 break;
 471
 472         case AUDIO_CODING_TYPE_SACD:
 473                 break;
 474
 475         case AUDIO_CODING_TYPE_EAC3:
 476                 break;
 477
 478         case AUDIO_CODING_TYPE_DTS_HD:
 479                 break;
 480
 481         case AUDIO_CODING_TYPE_MLP:
 482                 break;
 483
 484         case AUDIO_CODING_TYPE_DST:
 485                 break;
 486
 487         case AUDIO_CODING_TYPE_WMAPRO:
 488                 a->profile = grab_bits(buf, 2, 0, 3);
 489                 break;
 490
 491         case AUDIO_CODING_TYPE_REF_CXT:
 492                 a->format = grab_bits(buf, 2, 3, 5);
 493                 if (a->format == AUDIO_CODING_XTYPE_HE_REF_CT ||
 494                     a->format >= AUDIO_CODING_XTYPE_FIRST_RESERVED) {
 495                         snd_printd(KERN_INFO
 496                                 "audio coding xtype %d not expected in ELD\n",
 497                                 a->format);
 498                         a->format = 0;
 499                 } else
 500                         a->format += AUDIO_CODING_TYPE_HE_AAC -
 501                                      AUDIO_CODING_XTYPE_HE_AAC;
 502                 break;
 503         }
 504 }
 505
 506 static int hdmi_update_sink_eld(struct hda_codec *codec,
 507                                 const unsigned char *buf, int size)
 508 {
 509         struct intel_hdmi_spec *spec = codec->spec;
 510         struct sink_eld *e = &spec->sink;
 511         int mnl;
 512         int i;
 513
 514         e->eld_ver = grab_bits(buf, 0, 3, 5);
 515         if (e->eld_ver != ELD_VER_CEA_861D &&
 516             e->eld_ver != ELD_VER_PARTIAL) {
 517                 snd_printd(KERN_INFO "Unknown ELD version %d\n", e->eld_ver);
 518                 goto out_fail;
 519         }
 520
 521         e->eld_size = size;
 522         e->baseline_len = grab_bits(buf, 2, 0, 8);
 523         mnl             = grab_bits(buf, 4, 0, 5);
 524         e->cea_edid_ver = grab_bits(buf, 4, 5, 3);
 525
 526         e->support_hdcp = grab_bits(buf, 5, 0, 1);
 527         e->support_ai   = grab_bits(buf, 5, 1, 1);
 528         e->conn_type    = grab_bits(buf, 5, 2, 2);
 529         e->sad_count    = grab_bits(buf, 5, 4, 4);
 530
 531         e->aud_synch_delay = grab_bits(buf, 6, 0, 8);
 532         e->spk_alloc    = grab_bits(buf, 7, 0, 7);
 533
 534         e->port_id        = get_unaligned_le64(buf + 8);
 535
 536         /* not specified, but the spec's tendency is little endian */
 537         e->manufacture_id = get_unaligned_le16(buf + 16);
 538         e->product_id     = get_unaligned_le16(buf + 18);
 539
 540         if (mnl > ELD_MAX_MNL) {
 541                 snd_printd(KERN_INFO "MNL is reserved value %d\n", mnl);
 542                 goto out_fail;
 543         } else if (ELD_FIXED_BYTES + mnl > size) {
 544                 snd_printd(KERN_INFO "out of range MNL %d\n", mnl);
 545                 goto out_fail;
 546         } else
 547                 strlcpy(e->monitor_name, buf + ELD_FIXED_BYTES, mnl);
 548
 549         for (i = 0; i < e->sad_count; i++) {
 550                 if (ELD_FIXED_BYTES + mnl + 3 * (i + 1) > size) {
 551                         snd_printd(KERN_INFO "out of range SAD %d\n", i);
 552                         goto out_fail;
 553                 }
 554                 hdmi_update_short_audio_desc(e->sad + i,
 555                                         buf + ELD_FIXED_BYTES + mnl + 3 * i);
 556         }
 557
 558         return 0;
 559
 560 out_fail:
 561         e->eld_ver = 0;
 562         return -EINVAL;
 563 }
 564
 565 static int hdmi_get_eld(struct hda_codec *codec)
 566 {
 567         int i;
 568         int ret;
 569         int size;
 570         unsigned char *buf;
 571
 572         i = hdmi_present_sense(codec, PIN_NID) & AC_PINSENSE_ELDV;
 573         if (!i)
 574                 return -ENOENT;
 575
 576         size = hdmi_get_eld_size(codec, PIN_NID);
 577         if (size == 0) {
 578                 /* wfg: workaround for ASUS P5E-VM HDMI board */
 579                 snd_printd(KERN_INFO "ELD buf size is 0, force 128\n");
 580                 size = 128;
 581         }
 582         if (size < ELD_FIXED_BYTES || size > PAGE_SIZE) {
 583                 snd_printd(KERN_INFO "Invalid ELD buf size %d\n", size);
 584                 return -ERANGE;
 585         }
 586
 587         buf = kmalloc(size, GFP_KERNEL);
 588         if (!buf)
 589                 return -ENOMEM;
 590
 591         for (i = 0; i < size; i++)
 592                 buf[i] = hdmi_get_eld_byte(codec, i);
 593
 594         ret = hdmi_update_sink_eld(codec, buf, size);
 595
 596         kfree(buf);
 597         return ret;
 598 }
 599
 600 static void hdmi_show_short_audio_desc(struct cea_sad *a)
 601 {
 602         printk(KERN_INFO "coding type: %s\n",
 603                                         cea_audio_coding_type_names[a->format]);
 604         printk(KERN_INFO "channels: %d\n", a->channels);
 605         printk(KERN_INFO "sampling frequencies: 0x%x\n", a->rates);
 606
 607         if (a->format == AUDIO_CODING_TYPE_LPCM)
 608                 printk(KERN_INFO "sample bits: 0x%x\n", a->sample_bits);
 609
 610         if (a->max_bitrate)
 611                 printk(KERN_INFO "max bitrate: %d HZ\n", a->max_bitrate);
 612
 613         if (a->profile)
 614                 printk(KERN_INFO "profile: %d\n", a->profile);
 615 }
 616
 617 static void hdmi_show_eld(struct hda_codec *codec)
 618 {
 619         int i;
 620         int j;
 621         struct intel_hdmi_spec *spec = codec->spec;
 622         struct sink_eld *e = &spec->sink;
 623         char buf[80];
 624
 625         printk(KERN_INFO "ELD buffer size  is %d\n", e->eld_size);
 626         printk(KERN_INFO "ELD baseline len is %d*4\n", e->baseline_len);
 627         printk(KERN_INFO "vendor block len is %d\n",
 628                                         e->eld_size - e->baseline_len * 4 - 4);
 629         printk(KERN_INFO "ELD version      is %s\n",
 630                                         eld_versoin_names[e->eld_ver]);
 631         printk(KERN_INFO "CEA EDID version is %s\n",
 632                                 cea_edid_version_names[e->cea_edid_ver]);
 633         printk(KERN_INFO "manufacture id   is 0x%x\n", e->manufacture_id);
 634         printk(KERN_INFO "product id       is 0x%x\n", e->product_id);
 635         printk(KERN_INFO "port id          is 0x%llx\n", (long long)e->port_id);
 636         printk(KERN_INFO "HDCP support     is %d\n", e->support_hdcp);
 637         printk(KERN_INFO "AI support       is %d\n", e->support_ai);
 638         printk(KERN_INFO "SAD count        is %d\n", e->sad_count);
 639         printk(KERN_INFO "audio sync delay is %x\n", e->aud_synch_delay);
 640         printk(KERN_INFO "connection type  is %s\n",
 641                                 eld_connection_type_names[e->conn_type]);
 642         printk(KERN_INFO "monitor name     is %s\n", e->monitor_name);
 643
 644         j = 0;
 645         for (i = 0; i < ARRAY_SIZE(cea_speaker_allocation_names); i++) {
 646                 if (e->spk_alloc & (1 << i))
 647                         j += snprintf(buf + j, sizeof(buf) - j,  " %s",
 648                                         cea_speaker_allocation_names[i]);
 649         }
 650         buf[j] = '\0'; /* necessary when j == 0 */
 651         printk(KERN_INFO "speaker allocations: (0x%x)%s\n", e->spk_alloc, buf);
 652
 653         for (i = 0; i < e->sad_count; i++)
 654                 hdmi_show_short_audio_desc(e->sad + i);
 655 }
 656
 657 /*
 658  * Be careful, ELD buf could be totally rubbish!
 659  */
 660 static void hdmi_parse_eld(struct hda_codec *codec)
 661 {
 662         hdmi_debug_present_sense(codec);
 663
 664         if (!hdmi_get_eld(codec))
 665                 hdmi_show_eld(codec);
 666 }
 667
 668
 669 /*
 670  * Audio Infoframe routines
 671  */
 672
 673 static void hdmi_debug_dip_size(struct hda_codec *codec)
 674 {
 675 #ifdef CONFIG_SND_DEBUG_VERBOSE
 676         int i;
 677         int size;
 678
 679         size = hdmi_get_eld_size(codec, PIN_NID);
 680         printk(KERN_DEBUG "ELD buf size is %d\n", size);
 681
 682         for (i = 0; i < 8; i++) {
 683                 size = snd_hda_codec_read(codec, PIN_NID, 0,
 684                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
 685                 printk(KERN_DEBUG "DIP GP[%d] buf size is %d\n", i, size);
 686         }
 687 #endif
 688 }
 689
 690 static void hdmi_clear_dip_buffers(struct hda_codec *codec)
 691 {
 692 #ifdef BE_PARANOID
 693         int i, j;
 694         int size;
 695         int pi, bi;
 696         for (i = 0; i < 8; i++) {
 697                 size = snd_hda_codec_read(codec, PIN_NID, 0,
 698                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
 699                 if (size == 0)
 700                         continue;
 701
 702                 hdmi_set_dip_index(codec, PIN_NID, i, 0x0);
 703                 for (j = 1; j < 1000; j++) {
 704                         hdmi_write_dip_byte(codec, PIN_NID, 0x0);
 705                         hdmi_get_dip_index(codec, PIN_NID, &pi, &bi);
 706                         if (pi != i)
 707                                 snd_printd(KERN_INFO "dip index %d: %d != %d\n",
 708                                                 bi, pi, i);
 709                         if (bi == 0) /* byte index wrapped around */
 710                                 break;
 711                 }
 712                 snd_printd(KERN_INFO
 713                                 "DIP GP[%d] buf reported size=%d, written=%d\n",
 714                                 i, size, j);
 715         }
 716 #endif
 717 }
 718
 719 static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
 720                                         struct snd_pcm_substream *substream)
 721 {
 722         struct hdmi_audio_infoframe audio_infoframe = {
 723                 .type           = 0x84,
 724                 .ver            = 0x01,
 725                 .len            = 0x0a,
 726                 .CC02_CT47      = substream->runtime->channels - 1,
 727         };
 728         u8 *params = (u8 *)&audio_infoframe;
 729         int i;
 730
 731         hdmi_debug_dip_size(codec);
 732         hdmi_clear_dip_buffers(codec); /* be paranoid */
 733
 734         hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
 735         for (i = 0; i < sizeof(audio_infoframe); i++)
 736                 hdmi_write_dip_byte(codec, PIN_NID, params[i]);
 737 }
 738
 739
 740 /*
 741  * Unsolicited events
 742  */
 743
 744 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
 745 {
 746         int pind = !!(res & AC_UNSOL_RES_PD);
 747         int eldv = !!(res & AC_UNSOL_RES_ELDV);
 748
 749         printk(KERN_INFO "HDMI intrinsic event: PD=%d ELDV=%d\n", pind, eldv);
 750
 751         if (pind && eldv) {
 752                 hdmi_parse_eld(codec);
 753                 /* TODO: do real things about ELD */
 754         }
 755 }
 756
 757 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
 758 {
 759         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 760         int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
 761         int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
 762
 763         printk(KERN_INFO "HDMI non-intrinsic event: "
 764                         "SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
 765                         subtag,
 766                         cp_state,
 767                         cp_ready);
 768
 769         /* who cares? */
 770         if (cp_state)
 771                 ;
 772         if (cp_ready)
 773                 ;
 774 }
 775
 776
 777 static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
 778 {
 779         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
 780         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 781
 782         if (tag != INTEL_HDMI_EVENT_TAG) {
 783                 snd_printd(KERN_INFO
 784                                 "Unexpected HDMI unsolicited event tag 0x%x\n",
 785                                 tag);
 786                 return;
 787         }
 788
 789         if (subtag == 0)
 790                 hdmi_intrinsic_event(codec, res);
 791         else
 792                 hdmi_non_intrinsic_event(codec, res);
 793 }
 794
 795 /*
 796  * Callbacks
 797  */
 798
 799 static int intel_hdmi_playback_pcm_open(struct hda_pcm_stream *hinfo,
 800                                      struct hda_codec *codec,
 801                                      struct snd_pcm_substream *substream)
 802 {
 803         struct intel_hdmi_spec *spec = codec->spec;
 804
 805         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 806 }
 807
 808 static int intel_hdmi_playback_pcm_close(struct hda_pcm_stream *hinfo,
 809                                       struct hda_codec *codec,
 810                                       struct snd_pcm_substream *substream)
 811 {
 812         struct intel_hdmi_spec *spec = codec->spec;
 813
 814         hdmi_disable_output(codec);
 815
 816         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 817 }
 818
 819 static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 820                                            struct hda_codec *codec,
 821                                            unsigned int stream_tag,
 822                                            unsigned int format,
 823                                            struct snd_pcm_substream *substream)
 824 {
 825         struct intel_hdmi_spec *spec = codec->spec;
 826
 827         snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
 828                                              format, substream);
 829
 830         hdmi_set_channel_count(codec, substream->runtime->channels);
 831
 832         /* wfg: channel mapping not supported by DEVCTG */
 833         hdmi_setup_channel_mapping(codec);
 834
 835         hdmi_setup_audio_infoframe(codec, substream);
 836
 837         hdmi_enable_output(codec);
 838
 839         return 0;
 840 }
 841
 842 static struct hda_pcm_stream intel_hdmi_pcm_playback = {
 843         .substreams = 1,
 844         .channels_min = 2,
 845         .channels_max = 8,
 846         .nid = CVT_NID, /* NID to query formats and rates and setup streams */
 847         .ops = {
 848                 .open = intel_hdmi_playback_pcm_open,
 849                 .close = intel_hdmi_playback_pcm_close,
 850                 .prepare = intel_hdmi_playback_pcm_prepare
 851         },
 852 };
 853
 854 static int intel_hdmi_build_pcms(struct hda_codec *codec)
 855 {
 856         struct intel_hdmi_spec *spec = codec->spec;
 857         struct hda_pcm *info = &spec->pcm_rec;
 858
 859         codec->num_pcms = 1;
 860         codec->pcm_info = info;
 861
 862         info->name = "INTEL HDMI";
 863         info->pcm_type = HDA_PCM_TYPE_HDMI;
 864         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = intel_hdmi_pcm_playback;
 865
 866         return 0;
 867 }
 868
 869 static int intel_hdmi_build_controls(struct hda_codec *codec)
 870 {
 871         struct intel_hdmi_spec *spec = codec->spec;
 872         int err;
 873
 874         err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 875         if (err < 0)
 876                 return err;
 877
 878         return 0;
 879 }
 880
 881 static int intel_hdmi_init(struct hda_codec *codec)
 882 {
 883         /* disable audio output as early as possible */
 884         hdmi_disable_output(codec);
 885
 886         snd_hda_sequence_write(codec, unsolicited_response_verb);
 887
 888         return 0;
 889 }
 890
 891 static void intel_hdmi_free(struct hda_codec *codec)
 892 {
 893         kfree(codec->spec);
 894 }
 895
 896 static struct hda_codec_ops intel_hdmi_patch_ops = {
 897         .init                   = intel_hdmi_init,
 898         .free                   = intel_hdmi_free,
 899         .build_pcms             = intel_hdmi_build_pcms,
 900         .build_controls         = intel_hdmi_build_controls,
 901         .unsol_event            = intel_hdmi_unsol_event,
 902 };
 903
 904 static int patch_intel_hdmi(struct hda_codec *codec)
 905 {
 906         struct intel_hdmi_spec *spec;
 907
 908         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 909         if (spec == NULL)
 910                 return -ENOMEM;
 911
 912         spec->multiout.num_dacs = 0;      /* no analog */
 913         spec->multiout.max_channels = 8;
 914         spec->multiout.dig_out_nid = CVT_NID;
 915
 916         codec->spec = spec;
 917         codec->patch_ops = intel_hdmi_patch_ops;
 918
 919         return 0;
 920 }
 921
 922 struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
 923         { .id = 0x808629fb, .name = "INTEL G45 DEVCL",  .patch = patch_intel_hdmi },
 924         { .id = 0x80862801, .name = "INTEL G45 DEVBLC", .patch = patch_intel_hdmi },
 925         { .id = 0x80862802, .name = "INTEL G45 DEVCTG", .patch = patch_intel_hdmi },
 926         { .id = 0x80862803, .name = "INTEL G45 DEVELK", .patch = patch_intel_hdmi },
 927         {} /* terminator */
 928 };