2008-11-17 20:47:52 -07:00
|
|
|
/*
|
|
|
|
* Generic routines and proc interface for ELD(EDID Like Data) information
|
|
|
|
*
|
|
|
|
* Copyright(c) 2008 Intel Corporation.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Wu Fengguang <wfg@linux.intel.com>
|
|
|
|
*
|
|
|
|
* This driver is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This driver is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-11-17 20:47:52 -07:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include "hda_codec.h"
|
|
|
|
#include "hda_local.h"
|
|
|
|
|
|
|
|
enum eld_versions {
|
|
|
|
ELD_VER_CEA_861D = 2,
|
|
|
|
ELD_VER_PARTIAL = 31,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum cea_edid_versions {
|
|
|
|
CEA_EDID_VER_NONE = 0,
|
|
|
|
CEA_EDID_VER_CEA861 = 1,
|
|
|
|
CEA_EDID_VER_CEA861A = 2,
|
|
|
|
CEA_EDID_VER_CEA861BCD = 3,
|
|
|
|
CEA_EDID_VER_RESERVED = 4,
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *cea_speaker_allocation_names[] = {
|
|
|
|
/* 0 */ "FL/FR",
|
|
|
|
/* 1 */ "LFE",
|
|
|
|
/* 2 */ "FC",
|
|
|
|
/* 3 */ "RL/RR",
|
|
|
|
/* 4 */ "RC",
|
|
|
|
/* 5 */ "FLC/FRC",
|
|
|
|
/* 6 */ "RLC/RRC",
|
|
|
|
/* 7 */ "FLW/FRW",
|
|
|
|
/* 8 */ "FLH/FRH",
|
|
|
|
/* 9 */ "TC",
|
|
|
|
/* 10 */ "FCH",
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *eld_connection_type_names[4] = {
|
|
|
|
"HDMI",
|
2008-11-21 18:40:56 -07:00
|
|
|
"DisplayPort",
|
2008-11-17 20:47:52 -07:00
|
|
|
"2-reserved",
|
|
|
|
"3-reserved"
|
|
|
|
};
|
|
|
|
|
|
|
|
enum cea_audio_coding_types {
|
|
|
|
AUDIO_CODING_TYPE_REF_STREAM_HEADER = 0,
|
|
|
|
AUDIO_CODING_TYPE_LPCM = 1,
|
|
|
|
AUDIO_CODING_TYPE_AC3 = 2,
|
|
|
|
AUDIO_CODING_TYPE_MPEG1 = 3,
|
|
|
|
AUDIO_CODING_TYPE_MP3 = 4,
|
|
|
|
AUDIO_CODING_TYPE_MPEG2 = 5,
|
|
|
|
AUDIO_CODING_TYPE_AACLC = 6,
|
|
|
|
AUDIO_CODING_TYPE_DTS = 7,
|
|
|
|
AUDIO_CODING_TYPE_ATRAC = 8,
|
|
|
|
AUDIO_CODING_TYPE_SACD = 9,
|
|
|
|
AUDIO_CODING_TYPE_EAC3 = 10,
|
|
|
|
AUDIO_CODING_TYPE_DTS_HD = 11,
|
|
|
|
AUDIO_CODING_TYPE_MLP = 12,
|
|
|
|
AUDIO_CODING_TYPE_DST = 13,
|
|
|
|
AUDIO_CODING_TYPE_WMAPRO = 14,
|
|
|
|
AUDIO_CODING_TYPE_REF_CXT = 15,
|
|
|
|
/* also include valid xtypes below */
|
|
|
|
AUDIO_CODING_TYPE_HE_AAC = 15,
|
|
|
|
AUDIO_CODING_TYPE_HE_AAC2 = 16,
|
|
|
|
AUDIO_CODING_TYPE_MPEG_SURROUND = 17,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum cea_audio_coding_xtypes {
|
|
|
|
AUDIO_CODING_XTYPE_HE_REF_CT = 0,
|
|
|
|
AUDIO_CODING_XTYPE_HE_AAC = 1,
|
|
|
|
AUDIO_CODING_XTYPE_HE_AAC2 = 2,
|
|
|
|
AUDIO_CODING_XTYPE_MPEG_SURROUND = 3,
|
|
|
|
AUDIO_CODING_XTYPE_FIRST_RESERVED = 4,
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *cea_audio_coding_type_names[] = {
|
|
|
|
/* 0 */ "undefined",
|
|
|
|
/* 1 */ "LPCM",
|
|
|
|
/* 2 */ "AC-3",
|
|
|
|
/* 3 */ "MPEG1",
|
|
|
|
/* 4 */ "MP3",
|
|
|
|
/* 5 */ "MPEG2",
|
|
|
|
/* 6 */ "AAC-LC",
|
|
|
|
/* 7 */ "DTS",
|
|
|
|
/* 8 */ "ATRAC",
|
2008-11-19 00:14:01 -07:00
|
|
|
/* 9 */ "DSD (One Bit Audio)",
|
2008-11-17 20:47:52 -07:00
|
|
|
/* 10 */ "E-AC-3/DD+ (Dolby Digital Plus)",
|
|
|
|
/* 11 */ "DTS-HD",
|
|
|
|
/* 12 */ "MLP (Dolby TrueHD)",
|
|
|
|
/* 13 */ "DST",
|
|
|
|
/* 14 */ "WMAPro",
|
|
|
|
/* 15 */ "HE-AAC",
|
|
|
|
/* 16 */ "HE-AACv2",
|
|
|
|
/* 17 */ "MPEG Surround",
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following two lists are shared between
|
|
|
|
* - HDMI audio InfoFrame (source to sink)
|
2008-11-19 00:13:59 -07:00
|
|
|
* - CEA E-EDID Extension (sink to source)
|
2008-11-17 20:47:52 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SS1:SS0 index => sample size
|
|
|
|
*/
|
|
|
|
static int cea_sample_sizes[4] = {
|
|
|
|
0, /* 0: Refer to Stream Header */
|
|
|
|
AC_SUPPCM_BITS_16, /* 1: 16 bits */
|
|
|
|
AC_SUPPCM_BITS_20, /* 2: 20 bits */
|
|
|
|
AC_SUPPCM_BITS_24, /* 3: 24 bits */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SF2:SF1:SF0 index => sampling frequency
|
|
|
|
*/
|
|
|
|
static int cea_sampling_frequencies[8] = {
|
|
|
|
0, /* 0: Refer to Stream Header */
|
|
|
|
SNDRV_PCM_RATE_32000, /* 1: 32000Hz */
|
|
|
|
SNDRV_PCM_RATE_44100, /* 2: 44100Hz */
|
|
|
|
SNDRV_PCM_RATE_48000, /* 3: 48000Hz */
|
|
|
|
SNDRV_PCM_RATE_88200, /* 4: 88200Hz */
|
|
|
|
SNDRV_PCM_RATE_96000, /* 5: 96000Hz */
|
|
|
|
SNDRV_PCM_RATE_176400, /* 6: 176400Hz */
|
|
|
|
SNDRV_PCM_RATE_192000, /* 7: 192000Hz */
|
|
|
|
};
|
|
|
|
|
2011-08-20 01:14:45 -06:00
|
|
|
static unsigned int hdmi_get_eld_data(struct hda_codec *codec, hda_nid_t nid,
|
2008-11-17 20:47:52 -07:00
|
|
|
int byte_index)
|
|
|
|
{
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
val = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_ELDD, byte_index);
|
|
|
|
#ifdef BE_PARANOID
|
2008-11-21 18:40:53 -07:00
|
|
|
printk(KERN_INFO "HDMI: ELD data byte %d: 0x%x\n", byte_index, val);
|
2008-11-17 20:47:52 -07:00
|
|
|
#endif
|
2011-08-20 01:14:45 -06:00
|
|
|
return val;
|
2008-11-17 20:47:52 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#define GRAB_BITS(buf, byte, lowbit, bits) \
|
|
|
|
({ \
|
|
|
|
BUILD_BUG_ON(lowbit > 7); \
|
|
|
|
BUILD_BUG_ON(bits > 8); \
|
|
|
|
BUILD_BUG_ON(bits <= 0); \
|
|
|
|
\
|
|
|
|
(buf[byte] >> (lowbit)) & ((1 << (bits)) - 1); \
|
|
|
|
})
|
|
|
|
|
|
|
|
static void hdmi_update_short_audio_desc(struct cea_sad *a,
|
|
|
|
const unsigned char *buf)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = GRAB_BITS(buf, 1, 0, 7);
|
|
|
|
a->rates = 0;
|
|
|
|
for (i = 0; i < 7; i++)
|
|
|
|
if (val & (1 << i))
|
|
|
|
a->rates |= cea_sampling_frequencies[i + 1];
|
|
|
|
|
|
|
|
a->channels = GRAB_BITS(buf, 0, 0, 3);
|
|
|
|
a->channels++;
|
|
|
|
|
2010-12-07 12:19:23 -07:00
|
|
|
a->sample_bits = 0;
|
|
|
|
a->max_bitrate = 0;
|
|
|
|
|
2008-11-17 20:47:52 -07:00
|
|
|
a->format = GRAB_BITS(buf, 0, 3, 4);
|
|
|
|
switch (a->format) {
|
|
|
|
case AUDIO_CODING_TYPE_REF_STREAM_HEADER:
|
|
|
|
snd_printd(KERN_INFO
|
2008-11-21 18:40:53 -07:00
|
|
|
"HDMI: audio coding type 0 not expected\n");
|
2008-11-17 20:47:52 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_LPCM:
|
|
|
|
val = GRAB_BITS(buf, 2, 0, 3);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
if (val & (1 << i))
|
|
|
|
a->sample_bits |= cea_sample_sizes[i + 1];
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_AC3:
|
|
|
|
case AUDIO_CODING_TYPE_MPEG1:
|
|
|
|
case AUDIO_CODING_TYPE_MP3:
|
|
|
|
case AUDIO_CODING_TYPE_MPEG2:
|
|
|
|
case AUDIO_CODING_TYPE_AACLC:
|
|
|
|
case AUDIO_CODING_TYPE_DTS:
|
|
|
|
case AUDIO_CODING_TYPE_ATRAC:
|
|
|
|
a->max_bitrate = GRAB_BITS(buf, 2, 0, 8);
|
|
|
|
a->max_bitrate *= 8000;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_SACD:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_EAC3:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_DTS_HD:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_MLP:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_DST:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_WMAPRO:
|
|
|
|
a->profile = GRAB_BITS(buf, 2, 0, 3);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUDIO_CODING_TYPE_REF_CXT:
|
|
|
|
a->format = GRAB_BITS(buf, 2, 3, 5);
|
|
|
|
if (a->format == AUDIO_CODING_XTYPE_HE_REF_CT ||
|
|
|
|
a->format >= AUDIO_CODING_XTYPE_FIRST_RESERVED) {
|
|
|
|
snd_printd(KERN_INFO
|
2008-11-21 18:40:53 -07:00
|
|
|
"HDMI: audio coding xtype %d not expected\n",
|
2008-11-17 20:47:52 -07:00
|
|
|
a->format);
|
|
|
|
a->format = 0;
|
|
|
|
} else
|
|
|
|
a->format += AUDIO_CODING_TYPE_HE_AAC -
|
|
|
|
AUDIO_CODING_XTYPE_HE_AAC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Be careful, ELD buf could be totally rubbish!
|
|
|
|
*/
|
2008-11-19 00:14:00 -07:00
|
|
|
static int hdmi_update_eld(struct hdmi_eld *e,
|
|
|
|
const unsigned char *buf, int size)
|
2008-11-17 20:47:52 -07:00
|
|
|
{
|
|
|
|
int mnl;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
e->eld_ver = GRAB_BITS(buf, 0, 3, 5);
|
|
|
|
if (e->eld_ver != ELD_VER_CEA_861D &&
|
|
|
|
e->eld_ver != ELD_VER_PARTIAL) {
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: Unknown ELD version %d\n",
|
|
|
|
e->eld_ver);
|
2008-11-17 20:47:52 -07:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
e->eld_size = size;
|
|
|
|
e->baseline_len = GRAB_BITS(buf, 2, 0, 8);
|
|
|
|
mnl = GRAB_BITS(buf, 4, 0, 5);
|
|
|
|
e->cea_edid_ver = GRAB_BITS(buf, 4, 5, 3);
|
|
|
|
|
|
|
|
e->support_hdcp = GRAB_BITS(buf, 5, 0, 1);
|
|
|
|
e->support_ai = GRAB_BITS(buf, 5, 1, 1);
|
|
|
|
e->conn_type = GRAB_BITS(buf, 5, 2, 2);
|
|
|
|
e->sad_count = GRAB_BITS(buf, 5, 4, 4);
|
|
|
|
|
|
|
|
e->aud_synch_delay = GRAB_BITS(buf, 6, 0, 8) * 2;
|
|
|
|
e->spk_alloc = GRAB_BITS(buf, 7, 0, 7);
|
|
|
|
|
|
|
|
e->port_id = get_unaligned_le64(buf + 8);
|
|
|
|
|
|
|
|
/* not specified, but the spec's tendency is little endian */
|
|
|
|
e->manufacture_id = get_unaligned_le16(buf + 16);
|
|
|
|
e->product_id = get_unaligned_le16(buf + 18);
|
|
|
|
|
|
|
|
if (mnl > ELD_MAX_MNL) {
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: MNL is reserved value %d\n", mnl);
|
2008-11-17 20:47:52 -07:00
|
|
|
goto out_fail;
|
|
|
|
} else if (ELD_FIXED_BYTES + mnl > size) {
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: out of range MNL %d\n", mnl);
|
2008-11-17 20:47:52 -07:00
|
|
|
goto out_fail;
|
|
|
|
} else
|
2011-06-29 00:26:07 -06:00
|
|
|
strlcpy(e->monitor_name, buf + ELD_FIXED_BYTES, mnl + 1);
|
2008-11-17 20:47:52 -07:00
|
|
|
|
|
|
|
for (i = 0; i < e->sad_count; i++) {
|
|
|
|
if (ELD_FIXED_BYTES + mnl + 3 * (i + 1) > size) {
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: out of range SAD %d\n", i);
|
2008-11-17 20:47:52 -07:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
hdmi_update_short_audio_desc(e->sad + i,
|
|
|
|
buf + ELD_FIXED_BYTES + mnl + 3 * i);
|
|
|
|
}
|
|
|
|
|
2011-11-16 01:29:48 -07:00
|
|
|
/*
|
|
|
|
* HDMI sink's ELD info cannot always be retrieved for now, e.g.
|
|
|
|
* in console or for audio devices. Assume the highest speakers
|
|
|
|
* configuration, to _not_ prohibit multi-channel audio playback.
|
|
|
|
*/
|
|
|
|
if (!e->spk_alloc)
|
|
|
|
e->spk_alloc = 0xffff;
|
|
|
|
|
2011-11-16 01:29:46 -07:00
|
|
|
e->eld_valid = true;
|
2008-11-17 20:47:52 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_fail:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE,
|
|
|
|
AC_DIPSIZE_ELD_BUF);
|
|
|
|
}
|
|
|
|
|
2008-11-19 00:14:00 -07:00
|
|
|
int snd_hdmi_get_eld(struct hdmi_eld *eld,
|
2008-11-17 20:47:52 -07:00
|
|
|
struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
int size;
|
|
|
|
unsigned char *buf;
|
|
|
|
|
2011-09-30 15:35:41 -06:00
|
|
|
/*
|
|
|
|
* ELD size is initialized to zero in caller function. If no errors and
|
|
|
|
* ELD is valid, actual eld_size is assigned in hdmi_update_eld()
|
|
|
|
*/
|
|
|
|
|
2008-11-17 20:47:52 -07:00
|
|
|
size = snd_hdmi_get_eld_size(codec, nid);
|
|
|
|
if (size == 0) {
|
|
|
|
/* wfg: workaround for ASUS P5E-VM HDMI board */
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: ELD buf size is 0, force 128\n");
|
2008-11-17 20:47:52 -07:00
|
|
|
size = 128;
|
|
|
|
}
|
2011-09-30 15:35:41 -06:00
|
|
|
if (size < ELD_FIXED_BYTES || size > ELD_MAX_SIZE) {
|
2008-11-21 18:40:53 -07:00
|
|
|
snd_printd(KERN_INFO "HDMI: invalid ELD buf size %d\n", size);
|
2008-11-17 20:47:52 -07:00
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
2011-09-30 15:35:41 -06:00
|
|
|
/* set ELD buffer */
|
|
|
|
buf = eld->eld_buffer;
|
2008-11-17 20:47:52 -07:00
|
|
|
|
2011-08-20 01:14:45 -06:00
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
unsigned int val = hdmi_get_eld_data(codec, nid, i);
|
2011-11-22 01:46:23 -07:00
|
|
|
/*
|
|
|
|
* Graphics driver might be writing to ELD buffer right now.
|
|
|
|
* Just abort. The caller will repoll after a while.
|
|
|
|
*/
|
2011-08-20 01:14:45 -06:00
|
|
|
if (!(val & AC_ELDD_ELD_VALID)) {
|
|
|
|
snd_printd(KERN_INFO
|
|
|
|
"HDMI: invalid ELD data byte %d\n", i);
|
2011-11-22 01:46:23 -07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
val &= AC_ELDD_ELD_DATA;
|
|
|
|
/*
|
|
|
|
* The first byte cannot be zero. This can happen on some DVI
|
|
|
|
* connections. Some Intel chips may also need some 250ms delay
|
|
|
|
* to return non-zero ELD data, even when the graphics driver
|
|
|
|
* correctly writes ELD content before setting ELD_valid bit.
|
|
|
|
*/
|
|
|
|
if (!val && !i) {
|
|
|
|
snd_printdd(KERN_INFO "HDMI: 0 ELD data\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-08-20 01:14:45 -06:00
|
|
|
buf[i] = val;
|
|
|
|
}
|
2008-11-17 20:47:52 -07:00
|
|
|
|
2008-11-19 00:14:00 -07:00
|
|
|
ret = hdmi_update_eld(eld, buf, size);
|
2008-11-17 20:47:52 -07:00
|
|
|
|
2011-08-20 01:14:45 -06:00
|
|
|
error:
|
2008-11-17 20:47:52 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-05 14:14:20 -06:00
|
|
|
/**
|
|
|
|
* SNDRV_PCM_RATE_* and AC_PAR_PCM values don't match, print correct rates with
|
|
|
|
* hdmi-specific routine.
|
|
|
|
*/
|
|
|
|
static void hdmi_print_pcm_rates(int pcm, char *buf, int buflen)
|
|
|
|
{
|
|
|
|
static unsigned int alsa_rates[] = {
|
2012-03-13 09:43:02 -06:00
|
|
|
5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
|
|
|
|
88200, 96000, 176400, 192000, 384000
|
2011-10-05 14:14:20 -06:00
|
|
|
};
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < ARRAY_SIZE(alsa_rates); i++)
|
|
|
|
if (pcm & (1 << i))
|
|
|
|
j += snprintf(buf + j, buflen - j, " %d",
|
|
|
|
alsa_rates[i]);
|
|
|
|
|
|
|
|
buf[j] = '\0'; /* necessary when j == 0 */
|
|
|
|
}
|
|
|
|
|
2011-10-06 00:16:29 -06:00
|
|
|
#define SND_PRINT_RATES_ADVISED_BUFSIZE 80
|
|
|
|
|
2008-11-17 20:47:52 -07:00
|
|
|
static void hdmi_show_short_audio_desc(struct cea_sad *a)
|
|
|
|
{
|
|
|
|
char buf[SND_PRINT_RATES_ADVISED_BUFSIZE];
|
2008-11-19 00:14:03 -07:00
|
|
|
char buf2[8 + SND_PRINT_BITS_ADVISED_BUFSIZE] = ", bits =";
|
2008-11-17 20:47:52 -07:00
|
|
|
|
2008-11-19 00:14:03 -07:00
|
|
|
if (!a->format)
|
|
|
|
return;
|
2008-11-17 20:47:52 -07:00
|
|
|
|
2011-10-05 14:14:20 -06:00
|
|
|
hdmi_print_pcm_rates(a->rates, buf, sizeof(buf));
|
2008-11-17 20:47:52 -07:00
|
|
|
|
|
|
|
if (a->format == AUDIO_CODING_TYPE_LPCM)
|
2011-01-25 11:44:26 -07:00
|
|
|
snd_print_pcm_bits(a->sample_bits, buf2 + 8, sizeof(buf2) - 8);
|
2008-11-19 00:14:03 -07:00
|
|
|
else if (a->max_bitrate)
|
|
|
|
snprintf(buf2, sizeof(buf2),
|
|
|
|
", max bitrate = %d", a->max_bitrate);
|
|
|
|
else
|
|
|
|
buf2[0] = '\0';
|
|
|
|
|
2012-04-10 03:00:35 -06:00
|
|
|
_snd_printd(SND_PR_VERBOSE, "HDMI: supports coding type %s:"
|
2008-11-19 00:14:03 -07:00
|
|
|
" channels = %d, rates =%s%s\n",
|
|
|
|
cea_audio_coding_type_names[a->format],
|
|
|
|
a->channels,
|
|
|
|
buf,
|
|
|
|
buf2);
|
2008-11-17 20:47:52 -07:00
|
|
|
}
|
|
|
|
|
2008-11-18 17:56:16 -07:00
|
|
|
void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen)
|
2008-11-17 20:47:52 -07:00
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < ARRAY_SIZE(cea_speaker_allocation_names); i++) {
|
|
|
|
if (spk_alloc & (1 << i))
|
2008-11-19 00:14:01 -07:00
|
|
|
j += snprintf(buf + j, buflen - j, " %s",
|
2008-11-17 20:47:52 -07:00
|
|
|
cea_speaker_allocation_names[i]);
|
|
|
|
}
|
|
|
|
buf[j] = '\0'; /* necessary when j == 0 */
|
|
|
|
}
|
|
|
|
|
2008-11-19 00:14:00 -07:00
|
|
|
void snd_hdmi_show_eld(struct hdmi_eld *e)
|
2008-11-17 20:47:52 -07:00
|
|
|
{
|
|
|
|
int i;
|
2008-11-19 00:14:03 -07:00
|
|
|
|
2012-04-10 03:00:35 -06:00
|
|
|
_snd_printd(SND_PR_VERBOSE, "HDMI: detected monitor %s at connection type %s\n",
|
2008-11-19 00:14:03 -07:00
|
|
|
e->monitor_name,
|
|
|
|
eld_connection_type_names[e->conn_type]);
|
|
|
|
|
|
|
|
if (e->spk_alloc) {
|
|
|
|
char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
|
|
|
|
snd_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
|
2012-04-10 03:00:35 -06:00
|
|
|
_snd_printd(SND_PR_VERBOSE, "HDMI: available speakers:%s\n", buf);
|
2008-11-19 00:14:03 -07:00
|
|
|
}
|
2008-11-17 20:47:52 -07:00
|
|
|
|
|
|
|
for (i = 0; i < e->sad_count; i++)
|
|
|
|
hdmi_show_short_audio_desc(e->sad + i);
|
|
|
|
}
|
2008-11-17 20:47:53 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
|
|
|
static void hdmi_print_sad_info(int i, struct cea_sad *a,
|
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
2008-11-19 00:14:02 -07:00
|
|
|
char buf[SND_PRINT_RATES_ADVISED_BUFSIZE];
|
2008-11-17 20:47:53 -07:00
|
|
|
|
|
|
|
snd_iprintf(buffer, "sad%d_coding_type\t[0x%x] %s\n",
|
|
|
|
i, a->format, cea_audio_coding_type_names[a->format]);
|
|
|
|
snd_iprintf(buffer, "sad%d_channels\t\t%d\n", i, a->channels);
|
|
|
|
|
2011-10-05 14:14:20 -06:00
|
|
|
hdmi_print_pcm_rates(a->rates, buf, sizeof(buf));
|
2008-11-19 00:14:01 -07:00
|
|
|
snd_iprintf(buffer, "sad%d_rates\t\t[0x%x]%s\n", i, a->rates, buf);
|
2008-11-17 20:47:53 -07:00
|
|
|
|
2008-11-19 00:14:02 -07:00
|
|
|
if (a->format == AUDIO_CODING_TYPE_LPCM) {
|
|
|
|
snd_print_pcm_bits(a->sample_bits, buf, sizeof(buf));
|
|
|
|
snd_iprintf(buffer, "sad%d_bits\t\t[0x%x]%s\n",
|
|
|
|
i, a->sample_bits, buf);
|
|
|
|
}
|
2008-11-17 20:47:53 -07:00
|
|
|
|
|
|
|
if (a->max_bitrate)
|
|
|
|
snd_iprintf(buffer, "sad%d_max_bitrate\t%d\n",
|
|
|
|
i, a->max_bitrate);
|
|
|
|
|
|
|
|
if (a->profile)
|
|
|
|
snd_iprintf(buffer, "sad%d_profile\t\t%d\n", i, a->profile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_print_eld_info(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
2008-11-19 00:14:00 -07:00
|
|
|
struct hdmi_eld *e = entry->private_data;
|
2008-11-18 17:56:16 -07:00
|
|
|
char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
|
2008-11-17 20:47:53 -07:00
|
|
|
int i;
|
2008-11-21 18:40:57 -07:00
|
|
|
static char *eld_versoin_names[32] = {
|
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"CEA-861D or below",
|
|
|
|
[3 ... 30] = "reserved",
|
|
|
|
[31] = "partial"
|
|
|
|
};
|
|
|
|
static char *cea_edid_version_names[8] = {
|
|
|
|
"no CEA EDID Timing Extension block present",
|
|
|
|
"CEA-861",
|
|
|
|
"CEA-861-A",
|
|
|
|
"CEA-861-B, C or D",
|
|
|
|
[4 ... 7] = "reserved"
|
|
|
|
};
|
2008-11-17 20:47:53 -07:00
|
|
|
|
2009-11-17 21:38:01 -07:00
|
|
|
snd_iprintf(buffer, "monitor_present\t\t%d\n", e->monitor_present);
|
|
|
|
snd_iprintf(buffer, "eld_valid\t\t%d\n", e->eld_valid);
|
ALSA: HDA: Unify HDMI hotplug handling.
This change unifies the initial handling of a pin's state with the code to
update a pin's state after a hotplug (unsolicited response) event. The
initial probing, and all updates, are now routed through hdmi_present_sense.
The stored PD and ELDV status is now always derived from GetPinSense verb
execution, and not from the data in the unsolicited response. This means:
a) The WAR for NVIDIA codec's UR.PD values ("old_pin_detect") can be
removed, since this only affected the no-longer-used unsolicited
response payload.
b) In turn, this means that most NVIDIA codecs can simply use
patch_generic_hdmi instead of having a custom variant just to set
old_pin_detect.
c) When PD && ELDV becomes true, no extra verbs are executed, because the
GetPinSense that was previously executed by snd_hdmi_get_eld (really,
hdmi_eld_valid) has simply moved into hdmi_present_sense.
d) When PD && ELDV becomes false, there is a single extra GetPinSense verb
executed for codecs where old_pin_detect wasn't set, i.e. some NVIDIA,
and all ATI/AMD and Intel codecs. I doubt this will be a performance
issue.
The new unified code in hdmi_present_sense also ensures that eld->eld_valid
is not set unless eld->monitor_present is also set. This protects against
potential invalid combinations of PD and ELDV received from HW, and
transitively from a graphics driver.
Also, print the derived PD/ELDV bits from hdmi_present_sense so the kernel
log always displays the actual state stored, which will differ from the
values in the unsolicited response for NVIDIA HW where old_pin_detect was
previously set.
Finally, a couple of small tweaks originally by Takashi:
* Clear the ELD content to zero before reading it, so that if it's not
read (i.e. when !(PD && ELDV)) it's in a known state.
* Don't show ELD fields in /proc ELD files when the ELD isn't valid.
The only possibility I can see for regression here is a codec where the
GetPinSense verb returns incorrect data. However, we're already exposed
to that, since that data is used (a) from hdmi_add_pin to set up the
initial pin state, and (b) within snd_hda_input_jack_report to query
a pin's presence value. As such, I don't believe any HW has bugs here.
Includes-changes-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-05-24 17:11:17 -06:00
|
|
|
if (!e->eld_valid)
|
|
|
|
return;
|
2008-11-20 21:34:05 -07:00
|
|
|
snd_iprintf(buffer, "monitor_name\t\t%s\n", e->monitor_name);
|
2008-11-17 20:47:53 -07:00
|
|
|
snd_iprintf(buffer, "connection_type\t\t%s\n",
|
|
|
|
eld_connection_type_names[e->conn_type]);
|
|
|
|
snd_iprintf(buffer, "eld_version\t\t[0x%x] %s\n", e->eld_ver,
|
|
|
|
eld_versoin_names[e->eld_ver]);
|
|
|
|
snd_iprintf(buffer, "edid_version\t\t[0x%x] %s\n", e->cea_edid_ver,
|
|
|
|
cea_edid_version_names[e->cea_edid_ver]);
|
|
|
|
snd_iprintf(buffer, "manufacture_id\t\t0x%x\n", e->manufacture_id);
|
|
|
|
snd_iprintf(buffer, "product_id\t\t0x%x\n", e->product_id);
|
|
|
|
snd_iprintf(buffer, "port_id\t\t\t0x%llx\n", (long long)e->port_id);
|
|
|
|
snd_iprintf(buffer, "support_hdcp\t\t%d\n", e->support_hdcp);
|
|
|
|
snd_iprintf(buffer, "support_ai\t\t%d\n", e->support_ai);
|
|
|
|
snd_iprintf(buffer, "audio_sync_delay\t%d\n", e->aud_synch_delay);
|
|
|
|
|
2008-11-18 17:56:16 -07:00
|
|
|
snd_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
|
2008-11-19 00:14:01 -07:00
|
|
|
snd_iprintf(buffer, "speakers\t\t[0x%x]%s\n", e->spk_alloc, buf);
|
2008-11-17 20:47:53 -07:00
|
|
|
|
|
|
|
snd_iprintf(buffer, "sad_count\t\t%d\n", e->sad_count);
|
|
|
|
|
|
|
|
for (i = 0; i < e->sad_count; i++)
|
|
|
|
hdmi_print_sad_info(i, e->sad + i, buffer);
|
|
|
|
}
|
|
|
|
|
2008-11-21 18:40:54 -07:00
|
|
|
static void hdmi_write_eld_info(struct snd_info_entry *entry,
|
2008-11-20 20:41:50 -07:00
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
|
|
|
struct hdmi_eld *e = entry->private_data;
|
|
|
|
char line[64];
|
|
|
|
char name[64];
|
|
|
|
char *sname;
|
|
|
|
long long val;
|
2009-07-29 06:35:20 -06:00
|
|
|
unsigned int n;
|
2008-11-20 20:41:50 -07:00
|
|
|
|
|
|
|
while (!snd_info_get_line(buffer, line, sizeof(line))) {
|
|
|
|
if (sscanf(line, "%s %llx", name, &val) != 2)
|
|
|
|
continue;
|
2008-11-21 18:40:54 -07:00
|
|
|
/*
|
|
|
|
* We don't allow modification to these fields:
|
|
|
|
* monitor_name manufacture_id product_id
|
|
|
|
* eld_version edid_version
|
|
|
|
*/
|
2009-11-17 21:38:01 -07:00
|
|
|
if (!strcmp(name, "monitor_present"))
|
|
|
|
e->monitor_present = val;
|
|
|
|
else if (!strcmp(name, "eld_valid"))
|
|
|
|
e->eld_valid = val;
|
|
|
|
else if (!strcmp(name, "connection_type"))
|
2008-11-20 20:41:50 -07:00
|
|
|
e->conn_type = val;
|
|
|
|
else if (!strcmp(name, "port_id"))
|
|
|
|
e->port_id = val;
|
|
|
|
else if (!strcmp(name, "support_hdcp"))
|
|
|
|
e->support_hdcp = val;
|
|
|
|
else if (!strcmp(name, "support_ai"))
|
|
|
|
e->support_ai = val;
|
|
|
|
else if (!strcmp(name, "audio_sync_delay"))
|
|
|
|
e->aud_synch_delay = val;
|
|
|
|
else if (!strcmp(name, "speakers"))
|
|
|
|
e->spk_alloc = val;
|
|
|
|
else if (!strcmp(name, "sad_count"))
|
|
|
|
e->sad_count = val;
|
|
|
|
else if (!strncmp(name, "sad", 3)) {
|
|
|
|
sname = name + 4;
|
|
|
|
n = name[3] - '0';
|
|
|
|
if (name[4] >= '0' && name[4] <= '9') {
|
|
|
|
sname++;
|
|
|
|
n = 10 * n + name[4] - '0';
|
|
|
|
}
|
2009-07-29 06:35:20 -06:00
|
|
|
if (n >= ELD_MAX_SAD)
|
2008-11-20 20:41:50 -07:00
|
|
|
continue;
|
|
|
|
if (!strcmp(sname, "_coding_type"))
|
|
|
|
e->sad[n].format = val;
|
|
|
|
else if (!strcmp(sname, "_channels"))
|
|
|
|
e->sad[n].channels = val;
|
|
|
|
else if (!strcmp(sname, "_rates"))
|
|
|
|
e->sad[n].rates = val;
|
|
|
|
else if (!strcmp(sname, "_bits"))
|
|
|
|
e->sad[n].sample_bits = val;
|
|
|
|
else if (!strcmp(sname, "_max_bitrate"))
|
|
|
|
e->sad[n].max_bitrate = val;
|
2008-11-21 18:40:54 -07:00
|
|
|
else if (!strcmp(sname, "_profile"))
|
|
|
|
e->sad[n].profile = val;
|
2008-11-20 20:41:50 -07:00
|
|
|
if (n >= e->sad_count)
|
|
|
|
e->sad_count = n + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 04:44:26 -06:00
|
|
|
int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
|
|
|
|
int index)
|
2008-11-17 20:47:53 -07:00
|
|
|
{
|
|
|
|
char name[32];
|
|
|
|
struct snd_info_entry *entry;
|
|
|
|
int err;
|
|
|
|
|
2009-10-30 04:44:26 -06:00
|
|
|
snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
|
2008-11-17 20:47:53 -07:00
|
|
|
err = snd_card_proc_new(codec->bus->card, name, &entry);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
snd_info_set_text_ops(entry, eld, hdmi_print_eld_info);
|
2008-11-21 18:40:54 -07:00
|
|
|
entry->c.text.write = hdmi_write_eld_info;
|
2008-11-20 20:41:50 -07:00
|
|
|
entry->mode |= S_IWUSR;
|
2008-11-21 01:11:50 -07:00
|
|
|
eld->proc_entry = entry;
|
2008-11-20 20:41:50 -07:00
|
|
|
|
2008-11-17 20:47:53 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-21 01:11:50 -07:00
|
|
|
void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
|
|
|
|
{
|
|
|
|
if (!codec->bus->shutdown && eld->proc_entry) {
|
|
|
|
snd_device_free(codec->bus->card, eld->proc_entry);
|
|
|
|
eld->proc_entry = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-19 00:11:53 -06:00
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
|
2010-08-13 00:45:23 -06:00
|
|
|
/* update PCM info based on ELD */
|
2011-06-01 11:14:20 -06:00
|
|
|
void snd_hdmi_eld_update_pcm_info(struct hdmi_eld *eld,
|
|
|
|
struct hda_pcm_stream *hinfo)
|
2010-08-13 00:45:23 -06:00
|
|
|
{
|
2011-06-01 11:14:20 -06:00
|
|
|
u32 rates;
|
|
|
|
u64 formats;
|
|
|
|
unsigned int maxbps;
|
|
|
|
unsigned int channels_max;
|
2010-08-13 00:45:23 -06:00
|
|
|
int i;
|
|
|
|
|
2010-12-07 11:56:19 -07:00
|
|
|
/* assume basic audio support (the basic audio flag is not in ELD;
|
|
|
|
* however, all audio capable sinks are required to support basic
|
|
|
|
* audio) */
|
2011-06-01 11:14:20 -06:00
|
|
|
rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
|
|
|
|
SNDRV_PCM_RATE_48000;
|
|
|
|
formats = SNDRV_PCM_FMTBIT_S16_LE;
|
|
|
|
maxbps = 16;
|
|
|
|
channels_max = 2;
|
2010-08-13 00:45:23 -06:00
|
|
|
for (i = 0; i < eld->sad_count; i++) {
|
|
|
|
struct cea_sad *a = &eld->sad[i];
|
2011-06-01 11:14:20 -06:00
|
|
|
rates |= a->rates;
|
|
|
|
if (a->channels > channels_max)
|
|
|
|
channels_max = a->channels;
|
2010-08-13 00:45:23 -06:00
|
|
|
if (a->format == AUDIO_CODING_TYPE_LPCM) {
|
|
|
|
if (a->sample_bits & AC_SUPPCM_BITS_20) {
|
2011-06-01 11:14:20 -06:00
|
|
|
formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
|
|
|
if (maxbps < 20)
|
|
|
|
maxbps = 20;
|
2010-08-13 00:45:23 -06:00
|
|
|
}
|
|
|
|
if (a->sample_bits & AC_SUPPCM_BITS_24) {
|
2011-06-01 11:14:20 -06:00
|
|
|
formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
|
|
|
if (maxbps < 24)
|
|
|
|
maxbps = 24;
|
2010-08-13 00:45:23 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* restrict the parameters by the values the codec provides */
|
2011-06-01 11:14:20 -06:00
|
|
|
hinfo->rates &= rates;
|
|
|
|
hinfo->formats &= formats;
|
|
|
|
hinfo->maxbps = min(hinfo->maxbps, maxbps);
|
|
|
|
hinfo->channels_max = min(hinfo->channels_max, channels_max);
|
2010-08-13 00:45:23 -06:00
|
|
|
}
|