2 * Generic routines and proc interface for ELD(EDID Like Data) information
4 * Copyright(c) 2008 Intel Corporation.
7 * Wu Fengguang <wfg@linux.intel.com>
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/init.h>
25 #include <sound/core.h>
26 #include <asm/unaligned.h>
27 #include "hda_codec.h"
28 #include "hda_local.h"
35 static char *eld_versoin_names
[32] = {
39 [3 ... 30] = "reserved",
43 enum cea_edid_versions
{
44 CEA_EDID_VER_NONE
= 0,
45 CEA_EDID_VER_CEA861
= 1,
46 CEA_EDID_VER_CEA861A
= 2,
47 CEA_EDID_VER_CEA861BCD
= 3,
48 CEA_EDID_VER_RESERVED
= 4,
51 static char *cea_edid_version_names
[8] = {
52 "no CEA EDID Timing Extension block present",
56 [4 ... 7] = "reserved"
59 static char *cea_speaker_allocation_names
[] = {
73 static char *eld_connection_type_names
[4] = {
80 enum cea_audio_coding_types
{
81 AUDIO_CODING_TYPE_REF_STREAM_HEADER
= 0,
82 AUDIO_CODING_TYPE_LPCM
= 1,
83 AUDIO_CODING_TYPE_AC3
= 2,
84 AUDIO_CODING_TYPE_MPEG1
= 3,
85 AUDIO_CODING_TYPE_MP3
= 4,
86 AUDIO_CODING_TYPE_MPEG2
= 5,
87 AUDIO_CODING_TYPE_AACLC
= 6,
88 AUDIO_CODING_TYPE_DTS
= 7,
89 AUDIO_CODING_TYPE_ATRAC
= 8,
90 AUDIO_CODING_TYPE_SACD
= 9,
91 AUDIO_CODING_TYPE_EAC3
= 10,
92 AUDIO_CODING_TYPE_DTS_HD
= 11,
93 AUDIO_CODING_TYPE_MLP
= 12,
94 AUDIO_CODING_TYPE_DST
= 13,
95 AUDIO_CODING_TYPE_WMAPRO
= 14,
96 AUDIO_CODING_TYPE_REF_CXT
= 15,
97 /* also include valid xtypes below */
98 AUDIO_CODING_TYPE_HE_AAC
= 15,
99 AUDIO_CODING_TYPE_HE_AAC2
= 16,
100 AUDIO_CODING_TYPE_MPEG_SURROUND
= 17,
103 enum cea_audio_coding_xtypes
{
104 AUDIO_CODING_XTYPE_HE_REF_CT
= 0,
105 AUDIO_CODING_XTYPE_HE_AAC
= 1,
106 AUDIO_CODING_XTYPE_HE_AAC2
= 2,
107 AUDIO_CODING_XTYPE_MPEG_SURROUND
= 3,
108 AUDIO_CODING_XTYPE_FIRST_RESERVED
= 4,
111 static char *cea_audio_coding_type_names
[] = {
121 /* 9 */ "DSD (One Bit Audio)",
122 /* 10 */ "E-AC-3/DD+ (Dolby Digital Plus)",
124 /* 12 */ "MLP (Dolby TrueHD)",
129 /* 17 */ "MPEG Surround",
133 * The following two lists are shared between
134 * - HDMI audio InfoFrame (source to sink)
135 * - CEA E-EDID Extension (sink to source)
139 * SS1:SS0 index => sample size
141 static int cea_sample_sizes
[4] = {
142 0, /* 0: Refer to Stream Header */
143 AC_SUPPCM_BITS_16
, /* 1: 16 bits */
144 AC_SUPPCM_BITS_20
, /* 2: 20 bits */
145 AC_SUPPCM_BITS_24
, /* 3: 24 bits */
149 * SF2:SF1:SF0 index => sampling frequency
151 static int cea_sampling_frequencies
[8] = {
152 0, /* 0: Refer to Stream Header */
153 SNDRV_PCM_RATE_32000
, /* 1: 32000Hz */
154 SNDRV_PCM_RATE_44100
, /* 2: 44100Hz */
155 SNDRV_PCM_RATE_48000
, /* 3: 48000Hz */
156 SNDRV_PCM_RATE_88200
, /* 4: 88200Hz */
157 SNDRV_PCM_RATE_96000
, /* 5: 96000Hz */
158 SNDRV_PCM_RATE_176400
, /* 6: 176400Hz */
159 SNDRV_PCM_RATE_192000
, /* 7: 192000Hz */
162 static unsigned char hdmi_get_eld_byte(struct hda_codec
*codec
, hda_nid_t nid
,
167 val
= snd_hda_codec_read(codec
, nid
, 0,
168 AC_VERB_GET_HDMI_ELDD
, byte_index
);
171 printk(KERN_INFO
"ELD data byte %d: 0x%x\n", byte_index
, val
);
174 if ((val
& AC_ELDD_ELD_VALID
) == 0) {
175 snd_printd(KERN_INFO
"Invalid ELD data byte %d\n",
180 return val
& AC_ELDD_ELD_DATA
;
183 #define GRAB_BITS(buf, byte, lowbit, bits) \
185 BUILD_BUG_ON(lowbit > 7); \
186 BUILD_BUG_ON(bits > 8); \
187 BUILD_BUG_ON(bits <= 0); \
189 (buf[byte] >> (lowbit)) & ((1 << (bits)) - 1); \
192 static void hdmi_update_short_audio_desc(struct cea_sad
*a
,
193 const unsigned char *buf
)
198 val
= GRAB_BITS(buf
, 1, 0, 7);
200 for (i
= 0; i
< 7; i
++)
202 a
->rates
|= cea_sampling_frequencies
[i
+ 1];
204 a
->channels
= GRAB_BITS(buf
, 0, 0, 3);
207 a
->format
= GRAB_BITS(buf
, 0, 3, 4);
209 case AUDIO_CODING_TYPE_REF_STREAM_HEADER
:
211 "audio coding type 0 not expected in ELD\n");
214 case AUDIO_CODING_TYPE_LPCM
:
215 val
= GRAB_BITS(buf
, 2, 0, 3);
217 for (i
= 0; i
< 3; i
++)
219 a
->sample_bits
|= cea_sample_sizes
[i
+ 1];
222 case AUDIO_CODING_TYPE_AC3
:
223 case AUDIO_CODING_TYPE_MPEG1
:
224 case AUDIO_CODING_TYPE_MP3
:
225 case AUDIO_CODING_TYPE_MPEG2
:
226 case AUDIO_CODING_TYPE_AACLC
:
227 case AUDIO_CODING_TYPE_DTS
:
228 case AUDIO_CODING_TYPE_ATRAC
:
229 a
->max_bitrate
= GRAB_BITS(buf
, 2, 0, 8);
230 a
->max_bitrate
*= 8000;
233 case AUDIO_CODING_TYPE_SACD
:
236 case AUDIO_CODING_TYPE_EAC3
:
239 case AUDIO_CODING_TYPE_DTS_HD
:
242 case AUDIO_CODING_TYPE_MLP
:
245 case AUDIO_CODING_TYPE_DST
:
248 case AUDIO_CODING_TYPE_WMAPRO
:
249 a
->profile
= GRAB_BITS(buf
, 2, 0, 3);
252 case AUDIO_CODING_TYPE_REF_CXT
:
253 a
->format
= GRAB_BITS(buf
, 2, 3, 5);
254 if (a
->format
== AUDIO_CODING_XTYPE_HE_REF_CT
||
255 a
->format
>= AUDIO_CODING_XTYPE_FIRST_RESERVED
) {
257 "audio coding xtype %d not expected in ELD\n",
261 a
->format
+= AUDIO_CODING_TYPE_HE_AAC
-
262 AUDIO_CODING_XTYPE_HE_AAC
;
268 * Be careful, ELD buf could be totally rubbish!
270 static int hdmi_update_eld(struct hdmi_eld
*e
,
271 const unsigned char *buf
, int size
)
276 e
->eld_ver
= GRAB_BITS(buf
, 0, 3, 5);
277 if (e
->eld_ver
!= ELD_VER_CEA_861D
&&
278 e
->eld_ver
!= ELD_VER_PARTIAL
) {
279 snd_printd(KERN_INFO
"Unknown ELD version %d\n", e
->eld_ver
);
284 e
->baseline_len
= GRAB_BITS(buf
, 2, 0, 8);
285 mnl
= GRAB_BITS(buf
, 4, 0, 5);
286 e
->cea_edid_ver
= GRAB_BITS(buf
, 4, 5, 3);
288 e
->support_hdcp
= GRAB_BITS(buf
, 5, 0, 1);
289 e
->support_ai
= GRAB_BITS(buf
, 5, 1, 1);
290 e
->conn_type
= GRAB_BITS(buf
, 5, 2, 2);
291 e
->sad_count
= GRAB_BITS(buf
, 5, 4, 4);
293 e
->aud_synch_delay
= GRAB_BITS(buf
, 6, 0, 8) * 2;
294 e
->spk_alloc
= GRAB_BITS(buf
, 7, 0, 7);
296 e
->port_id
= get_unaligned_le64(buf
+ 8);
298 /* not specified, but the spec's tendency is little endian */
299 e
->manufacture_id
= get_unaligned_le16(buf
+ 16);
300 e
->product_id
= get_unaligned_le16(buf
+ 18);
302 if (mnl
> ELD_MAX_MNL
) {
303 snd_printd(KERN_INFO
"MNL is reserved value %d\n", mnl
);
305 } else if (ELD_FIXED_BYTES
+ mnl
> size
) {
306 snd_printd(KERN_INFO
"out of range MNL %d\n", mnl
);
309 strlcpy(e
->monitor_name
, buf
+ ELD_FIXED_BYTES
, mnl
);
311 for (i
= 0; i
< e
->sad_count
; i
++) {
312 if (ELD_FIXED_BYTES
+ mnl
+ 3 * (i
+ 1) > size
) {
313 snd_printd(KERN_INFO
"out of range SAD %d\n", i
);
316 hdmi_update_short_audio_desc(e
->sad
+ i
,
317 buf
+ ELD_FIXED_BYTES
+ mnl
+ 3 * i
);
327 static int hdmi_present_sense(struct hda_codec
*codec
, hda_nid_t nid
)
329 return snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_PIN_SENSE
, 0);
332 static int hdmi_eld_valid(struct hda_codec
*codec
, hda_nid_t nid
)
337 present
= hdmi_present_sense(codec
, nid
);
338 eldv
= (present
& AC_PINSENSE_ELDV
);
339 present
= (present
& AC_PINSENSE_PRESENCE
);
341 #ifdef CONFIG_SND_DEBUG_VERBOSE
342 printk(KERN_INFO
"pinp = %d, eldv = %d\n", !!present
, !!eldv
);
345 return eldv
&& present
;
348 int snd_hdmi_get_eld_size(struct hda_codec
*codec
, hda_nid_t nid
)
350 return snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_HDMI_DIP_SIZE
,
354 int snd_hdmi_get_eld(struct hdmi_eld
*eld
,
355 struct hda_codec
*codec
, hda_nid_t nid
)
362 if (!hdmi_eld_valid(codec
, nid
))
365 size
= snd_hdmi_get_eld_size(codec
, nid
);
367 /* wfg: workaround for ASUS P5E-VM HDMI board */
368 snd_printd(KERN_INFO
"ELD buf size is 0, force 128\n");
371 if (size
< ELD_FIXED_BYTES
|| size
> PAGE_SIZE
) {
372 snd_printd(KERN_INFO
"Invalid ELD buf size %d\n", size
);
376 buf
= kmalloc(size
, GFP_KERNEL
);
380 for (i
= 0; i
< size
; i
++)
381 buf
[i
] = hdmi_get_eld_byte(codec
, nid
, i
);
383 ret
= hdmi_update_eld(eld
, buf
, size
);
389 static void hdmi_show_short_audio_desc(struct cea_sad
*a
)
391 char buf
[SND_PRINT_RATES_ADVISED_BUFSIZE
];
393 printk(KERN_INFO
"coding type: %s\n",
394 cea_audio_coding_type_names
[a
->format
]);
395 printk(KERN_INFO
"channels: %d\n", a
->channels
);
397 snd_print_pcm_rates(a
->rates
, buf
, sizeof(buf
));
398 printk(KERN_INFO
"sampling rates: %s\n", buf
);
400 if (a
->format
== AUDIO_CODING_TYPE_LPCM
)
401 printk(KERN_INFO
"sample bits: 0x%x\n", a
->sample_bits
);
404 printk(KERN_INFO
"max bitrate: %d\n", a
->max_bitrate
);
407 printk(KERN_INFO
"profile: %d\n", a
->profile
);
410 void snd_print_channel_allocation(int spk_alloc
, char *buf
, int buflen
)
414 for (i
= 0, j
= 0; i
< ARRAY_SIZE(cea_speaker_allocation_names
); i
++) {
415 if (spk_alloc
& (1 << i
))
416 j
+= snprintf(buf
+ j
, buflen
- j
, " %s",
417 cea_speaker_allocation_names
[i
]);
419 buf
[j
] = '\0'; /* necessary when j == 0 */
422 void snd_hdmi_show_eld(struct hdmi_eld
*e
)
425 char buf
[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE
];
427 printk(KERN_INFO
"ELD buffer size is %d\n", e
->eld_size
);
428 printk(KERN_INFO
"ELD baseline len is %d*4\n", e
->baseline_len
);
429 printk(KERN_INFO
"vendor block len is %d\n",
430 e
->eld_size
- e
->baseline_len
* 4 - 4);
431 printk(KERN_INFO
"ELD version is %s\n",
432 eld_versoin_names
[e
->eld_ver
]);
433 printk(KERN_INFO
"CEA EDID version is %s\n",
434 cea_edid_version_names
[e
->cea_edid_ver
]);
435 printk(KERN_INFO
"manufacture id is 0x%x\n", e
->manufacture_id
);
436 printk(KERN_INFO
"product id is 0x%x\n", e
->product_id
);
437 printk(KERN_INFO
"port id is 0x%llx\n", (long long)e
->port_id
);
438 printk(KERN_INFO
"HDCP support is %d\n", e
->support_hdcp
);
439 printk(KERN_INFO
"AI support is %d\n", e
->support_ai
);
440 printk(KERN_INFO
"SAD count is %d\n", e
->sad_count
);
441 printk(KERN_INFO
"audio sync delay is %x\n", e
->aud_synch_delay
);
442 printk(KERN_INFO
"connection type is %s\n",
443 eld_connection_type_names
[e
->conn_type
]);
444 printk(KERN_INFO
"monitor name is %s\n", e
->monitor_name
);
446 snd_print_channel_allocation(e
->spk_alloc
, buf
, sizeof(buf
));
447 printk(KERN_INFO
"speaker allocations: (0x%x)%s\n", e
->spk_alloc
, buf
);
449 for (i
= 0; i
< e
->sad_count
; i
++)
450 hdmi_show_short_audio_desc(e
->sad
+ i
);
453 #ifdef CONFIG_PROC_FS
455 static void hdmi_print_sad_info(int i
, struct cea_sad
*a
,
456 struct snd_info_buffer
*buffer
)
460 snd_iprintf(buffer
, "sad%d_coding_type\t[0x%x] %s\n",
461 i
, a
->format
, cea_audio_coding_type_names
[a
->format
]);
462 snd_iprintf(buffer
, "sad%d_channels\t\t%d\n", i
, a
->channels
);
464 snd_print_pcm_rates(a
->rates
, buf
, sizeof(buf
));
465 snd_iprintf(buffer
, "sad%d_rates\t\t[0x%x]%s\n", i
, a
->rates
, buf
);
467 if (a
->format
== AUDIO_CODING_TYPE_LPCM
)
468 snd_iprintf(buffer
, "sad%d_bits\t\t0x%x\n",
472 snd_iprintf(buffer
, "sad%d_max_bitrate\t%d\n",
476 snd_iprintf(buffer
, "sad%d_profile\t\t%d\n", i
, a
->profile
);
479 static void hdmi_print_eld_info(struct snd_info_entry
*entry
,
480 struct snd_info_buffer
*buffer
)
482 struct hdmi_eld
*e
= entry
->private_data
;
483 char buf
[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE
];
486 snd_iprintf(buffer
, "monitor name\t\t%s\n", e
->monitor_name
);
487 snd_iprintf(buffer
, "connection_type\t\t%s\n",
488 eld_connection_type_names
[e
->conn_type
]);
489 snd_iprintf(buffer
, "eld_version\t\t[0x%x] %s\n", e
->eld_ver
,
490 eld_versoin_names
[e
->eld_ver
]);
491 snd_iprintf(buffer
, "edid_version\t\t[0x%x] %s\n", e
->cea_edid_ver
,
492 cea_edid_version_names
[e
->cea_edid_ver
]);
493 snd_iprintf(buffer
, "manufacture_id\t\t0x%x\n", e
->manufacture_id
);
494 snd_iprintf(buffer
, "product_id\t\t0x%x\n", e
->product_id
);
495 snd_iprintf(buffer
, "port_id\t\t\t0x%llx\n", (long long)e
->port_id
);
496 snd_iprintf(buffer
, "support_hdcp\t\t%d\n", e
->support_hdcp
);
497 snd_iprintf(buffer
, "support_ai\t\t%d\n", e
->support_ai
);
498 snd_iprintf(buffer
, "audio_sync_delay\t%d\n", e
->aud_synch_delay
);
500 snd_print_channel_allocation(e
->spk_alloc
, buf
, sizeof(buf
));
501 snd_iprintf(buffer
, "speakers\t\t[0x%x]%s\n", e
->spk_alloc
, buf
);
503 snd_iprintf(buffer
, "sad_count\t\t%d\n", e
->sad_count
);
505 for (i
= 0; i
< e
->sad_count
; i
++)
506 hdmi_print_sad_info(i
, e
->sad
+ i
, buffer
);
509 int snd_hda_eld_proc_new(struct hda_codec
*codec
, struct hdmi_eld
*eld
)
512 struct snd_info_entry
*entry
;
515 snprintf(name
, sizeof(name
), "eld#%d", codec
->addr
);
516 err
= snd_card_proc_new(codec
->bus
->card
, name
, &entry
);
520 snd_info_set_text_ops(entry
, eld
, hdmi_print_eld_info
);