2 * Generic routines and proc interface for ELD(EDID Like Data) information
4 * Copyright(c) 2008 Intel Corporation.
5 * Copyright (c) 2013 Anssi Hannula <anssi.hannula@iki.fi>
8 * Wu Fengguang <wfg@linux.intel.com>
10 * This driver is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This driver is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <sound/core.h>
28 #include <asm/unaligned.h>
29 #include "hda_codec.h"
30 #include "hda_local.h"
37 enum cea_edid_versions
{
38 CEA_EDID_VER_NONE
= 0,
39 CEA_EDID_VER_CEA861
= 1,
40 CEA_EDID_VER_CEA861A
= 2,
41 CEA_EDID_VER_CEA861BCD
= 3,
42 CEA_EDID_VER_RESERVED
= 4,
45 static char *cea_speaker_allocation_names
[] = {
59 static char *eld_connection_type_names
[4] = {
66 enum cea_audio_coding_types
{
67 AUDIO_CODING_TYPE_REF_STREAM_HEADER
= 0,
68 AUDIO_CODING_TYPE_LPCM
= 1,
69 AUDIO_CODING_TYPE_AC3
= 2,
70 AUDIO_CODING_TYPE_MPEG1
= 3,
71 AUDIO_CODING_TYPE_MP3
= 4,
72 AUDIO_CODING_TYPE_MPEG2
= 5,
73 AUDIO_CODING_TYPE_AACLC
= 6,
74 AUDIO_CODING_TYPE_DTS
= 7,
75 AUDIO_CODING_TYPE_ATRAC
= 8,
76 AUDIO_CODING_TYPE_SACD
= 9,
77 AUDIO_CODING_TYPE_EAC3
= 10,
78 AUDIO_CODING_TYPE_DTS_HD
= 11,
79 AUDIO_CODING_TYPE_MLP
= 12,
80 AUDIO_CODING_TYPE_DST
= 13,
81 AUDIO_CODING_TYPE_WMAPRO
= 14,
82 AUDIO_CODING_TYPE_REF_CXT
= 15,
83 /* also include valid xtypes below */
84 AUDIO_CODING_TYPE_HE_AAC
= 15,
85 AUDIO_CODING_TYPE_HE_AAC2
= 16,
86 AUDIO_CODING_TYPE_MPEG_SURROUND
= 17,
89 enum cea_audio_coding_xtypes
{
90 AUDIO_CODING_XTYPE_HE_REF_CT
= 0,
91 AUDIO_CODING_XTYPE_HE_AAC
= 1,
92 AUDIO_CODING_XTYPE_HE_AAC2
= 2,
93 AUDIO_CODING_XTYPE_MPEG_SURROUND
= 3,
94 AUDIO_CODING_XTYPE_FIRST_RESERVED
= 4,
97 static char *cea_audio_coding_type_names
[] = {
107 /* 9 */ "DSD (One Bit Audio)",
108 /* 10 */ "E-AC-3/DD+ (Dolby Digital Plus)",
110 /* 12 */ "MLP (Dolby TrueHD)",
115 /* 17 */ "MPEG Surround",
119 * The following two lists are shared between
120 * - HDMI audio InfoFrame (source to sink)
121 * - CEA E-EDID Extension (sink to source)
125 * SS1:SS0 index => sample size
127 static int cea_sample_sizes
[4] = {
128 0, /* 0: Refer to Stream Header */
129 AC_SUPPCM_BITS_16
, /* 1: 16 bits */
130 AC_SUPPCM_BITS_20
, /* 2: 20 bits */
131 AC_SUPPCM_BITS_24
, /* 3: 24 bits */
135 * SF2:SF1:SF0 index => sampling frequency
137 static int cea_sampling_frequencies
[8] = {
138 0, /* 0: Refer to Stream Header */
139 SNDRV_PCM_RATE_32000
, /* 1: 32000Hz */
140 SNDRV_PCM_RATE_44100
, /* 2: 44100Hz */
141 SNDRV_PCM_RATE_48000
, /* 3: 48000Hz */
142 SNDRV_PCM_RATE_88200
, /* 4: 88200Hz */
143 SNDRV_PCM_RATE_96000
, /* 5: 96000Hz */
144 SNDRV_PCM_RATE_176400
, /* 6: 176400Hz */
145 SNDRV_PCM_RATE_192000
, /* 7: 192000Hz */
148 static unsigned int hdmi_get_eld_data(struct hda_codec
*codec
, hda_nid_t nid
,
153 val
= snd_hda_codec_read(codec
, nid
, 0,
154 AC_VERB_GET_HDMI_ELDD
, byte_index
);
156 codec_info(codec
, "HDMI: ELD data byte %d: 0x%x\n", byte_index
, val
);
161 #define GRAB_BITS(buf, byte, lowbit, bits) \
163 BUILD_BUG_ON(lowbit > 7); \
164 BUILD_BUG_ON(bits > 8); \
165 BUILD_BUG_ON(bits <= 0); \
167 (buf[byte] >> (lowbit)) & ((1 << (bits)) - 1); \
170 static void hdmi_update_short_audio_desc(struct cea_sad
*a
,
171 const unsigned char *buf
)
176 val
= GRAB_BITS(buf
, 1, 0, 7);
178 for (i
= 0; i
< 7; i
++)
180 a
->rates
|= cea_sampling_frequencies
[i
+ 1];
182 a
->channels
= GRAB_BITS(buf
, 0, 0, 3);
188 a
->format
= GRAB_BITS(buf
, 0, 3, 4);
190 case AUDIO_CODING_TYPE_REF_STREAM_HEADER
:
192 "HDMI: audio coding type 0 not expected\n");
195 case AUDIO_CODING_TYPE_LPCM
:
196 val
= GRAB_BITS(buf
, 2, 0, 3);
197 for (i
= 0; i
< 3; i
++)
199 a
->sample_bits
|= cea_sample_sizes
[i
+ 1];
202 case AUDIO_CODING_TYPE_AC3
:
203 case AUDIO_CODING_TYPE_MPEG1
:
204 case AUDIO_CODING_TYPE_MP3
:
205 case AUDIO_CODING_TYPE_MPEG2
:
206 case AUDIO_CODING_TYPE_AACLC
:
207 case AUDIO_CODING_TYPE_DTS
:
208 case AUDIO_CODING_TYPE_ATRAC
:
209 a
->max_bitrate
= GRAB_BITS(buf
, 2, 0, 8);
210 a
->max_bitrate
*= 8000;
213 case AUDIO_CODING_TYPE_SACD
:
216 case AUDIO_CODING_TYPE_EAC3
:
219 case AUDIO_CODING_TYPE_DTS_HD
:
222 case AUDIO_CODING_TYPE_MLP
:
225 case AUDIO_CODING_TYPE_DST
:
228 case AUDIO_CODING_TYPE_WMAPRO
:
229 a
->profile
= GRAB_BITS(buf
, 2, 0, 3);
232 case AUDIO_CODING_TYPE_REF_CXT
:
233 a
->format
= GRAB_BITS(buf
, 2, 3, 5);
234 if (a
->format
== AUDIO_CODING_XTYPE_HE_REF_CT
||
235 a
->format
>= AUDIO_CODING_XTYPE_FIRST_RESERVED
) {
237 "HDMI: audio coding xtype %d not expected\n",
241 a
->format
+= AUDIO_CODING_TYPE_HE_AAC
-
242 AUDIO_CODING_XTYPE_HE_AAC
;
248 * Be careful, ELD buf could be totally rubbish!
250 int snd_hdmi_parse_eld(struct parsed_hdmi_eld
*e
,
251 const unsigned char *buf
, int size
)
256 e
->eld_ver
= GRAB_BITS(buf
, 0, 3, 5);
257 if (e
->eld_ver
!= ELD_VER_CEA_861D
&&
258 e
->eld_ver
!= ELD_VER_PARTIAL
) {
259 snd_printd(KERN_INFO
"HDMI: Unknown ELD version %d\n",
264 e
->baseline_len
= GRAB_BITS(buf
, 2, 0, 8);
265 mnl
= GRAB_BITS(buf
, 4, 0, 5);
266 e
->cea_edid_ver
= GRAB_BITS(buf
, 4, 5, 3);
268 e
->support_hdcp
= GRAB_BITS(buf
, 5, 0, 1);
269 e
->support_ai
= GRAB_BITS(buf
, 5, 1, 1);
270 e
->conn_type
= GRAB_BITS(buf
, 5, 2, 2);
271 e
->sad_count
= GRAB_BITS(buf
, 5, 4, 4);
273 e
->aud_synch_delay
= GRAB_BITS(buf
, 6, 0, 8) * 2;
274 e
->spk_alloc
= GRAB_BITS(buf
, 7, 0, 7);
276 e
->port_id
= get_unaligned_le64(buf
+ 8);
278 /* not specified, but the spec's tendency is little endian */
279 e
->manufacture_id
= get_unaligned_le16(buf
+ 16);
280 e
->product_id
= get_unaligned_le16(buf
+ 18);
282 if (mnl
> ELD_MAX_MNL
) {
283 snd_printd(KERN_INFO
"HDMI: MNL is reserved value %d\n", mnl
);
285 } else if (ELD_FIXED_BYTES
+ mnl
> size
) {
286 snd_printd(KERN_INFO
"HDMI: out of range MNL %d\n", mnl
);
289 strlcpy(e
->monitor_name
, buf
+ ELD_FIXED_BYTES
, mnl
+ 1);
291 for (i
= 0; i
< e
->sad_count
; i
++) {
292 if (ELD_FIXED_BYTES
+ mnl
+ 3 * (i
+ 1) > size
) {
293 snd_printd(KERN_INFO
"HDMI: out of range SAD %d\n", i
);
296 hdmi_update_short_audio_desc(e
->sad
+ i
,
297 buf
+ ELD_FIXED_BYTES
+ mnl
+ 3 * i
);
301 * HDMI sink's ELD info cannot always be retrieved for now, e.g.
302 * in console or for audio devices. Assume the highest speakers
303 * configuration, to _not_ prohibit multi-channel audio playback.
306 e
->spk_alloc
= 0xffff;
314 int snd_hdmi_get_eld_size(struct hda_codec
*codec
, hda_nid_t nid
)
316 return snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_HDMI_DIP_SIZE
,
320 int snd_hdmi_get_eld(struct hda_codec
*codec
, hda_nid_t nid
,
321 unsigned char *buf
, int *eld_size
)
328 * ELD size is initialized to zero in caller function. If no errors and
329 * ELD is valid, actual eld_size is assigned.
332 size
= snd_hdmi_get_eld_size(codec
, nid
);
334 /* wfg: workaround for ASUS P5E-VM HDMI board */
335 codec_info(codec
, "HDMI: ELD buf size is 0, force 128\n");
338 if (size
< ELD_FIXED_BYTES
|| size
> ELD_MAX_SIZE
) {
339 codec_info(codec
, "HDMI: invalid ELD buf size %d\n", size
);
344 for (i
= 0; i
< size
; i
++) {
345 unsigned int val
= hdmi_get_eld_data(codec
, nid
, i
);
347 * Graphics driver might be writing to ELD buffer right now.
348 * Just abort. The caller will repoll after a while.
350 if (!(val
& AC_ELDD_ELD_VALID
)) {
351 codec_info(codec
, "HDMI: invalid ELD data byte %d\n", i
);
355 val
&= AC_ELDD_ELD_DATA
;
357 * The first byte cannot be zero. This can happen on some DVI
358 * connections. Some Intel chips may also need some 250ms delay
359 * to return non-zero ELD data, even when the graphics driver
360 * correctly writes ELD content before setting ELD_valid bit.
363 codec_dbg(codec
, "HDMI: 0 ELD data\n");
376 * SNDRV_PCM_RATE_* and AC_PAR_PCM values don't match, print correct rates with
377 * hdmi-specific routine.
379 static void hdmi_print_pcm_rates(int pcm
, char *buf
, int buflen
)
381 static unsigned int alsa_rates
[] = {
382 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
383 88200, 96000, 176400, 192000, 384000
387 for (i
= 0, j
= 0; i
< ARRAY_SIZE(alsa_rates
); i
++)
389 j
+= snprintf(buf
+ j
, buflen
- j
, " %d",
392 buf
[j
] = '\0'; /* necessary when j == 0 */
395 #define SND_PRINT_RATES_ADVISED_BUFSIZE 80
397 static void hdmi_show_short_audio_desc(struct cea_sad
*a
)
399 char buf
[SND_PRINT_RATES_ADVISED_BUFSIZE
];
400 char buf2
[8 + SND_PRINT_BITS_ADVISED_BUFSIZE
] = ", bits =";
405 hdmi_print_pcm_rates(a
->rates
, buf
, sizeof(buf
));
407 if (a
->format
== AUDIO_CODING_TYPE_LPCM
)
408 snd_print_pcm_bits(a
->sample_bits
, buf2
+ 8, sizeof(buf2
) - 8);
409 else if (a
->max_bitrate
)
410 snprintf(buf2
, sizeof(buf2
),
411 ", max bitrate = %d", a
->max_bitrate
);
415 _snd_printd(SND_PR_VERBOSE
, "HDMI: supports coding type %s:"
416 " channels = %d, rates =%s%s\n",
417 cea_audio_coding_type_names
[a
->format
],
423 void snd_print_channel_allocation(int spk_alloc
, char *buf
, int buflen
)
427 for (i
= 0, j
= 0; i
< ARRAY_SIZE(cea_speaker_allocation_names
); i
++) {
428 if (spk_alloc
& (1 << i
))
429 j
+= snprintf(buf
+ j
, buflen
- j
, " %s",
430 cea_speaker_allocation_names
[i
]);
432 buf
[j
] = '\0'; /* necessary when j == 0 */
435 void snd_hdmi_show_eld(struct parsed_hdmi_eld
*e
)
439 _snd_printd(SND_PR_VERBOSE
, "HDMI: detected monitor %s at connection type %s\n",
441 eld_connection_type_names
[e
->conn_type
]);
444 char buf
[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE
];
445 snd_print_channel_allocation(e
->spk_alloc
, buf
, sizeof(buf
));
446 _snd_printd(SND_PR_VERBOSE
, "HDMI: available speakers:%s\n", 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
)
458 char buf
[SND_PRINT_RATES_ADVISED_BUFSIZE
];
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 hdmi_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_print_pcm_bits(a
->sample_bits
, buf
, sizeof(buf
));
469 snd_iprintf(buffer
, "sad%d_bits\t\t[0x%x]%s\n",
470 i
, a
->sample_bits
, buf
);
474 snd_iprintf(buffer
, "sad%d_max_bitrate\t%d\n",
478 snd_iprintf(buffer
, "sad%d_profile\t\t%d\n", i
, a
->profile
);
481 void snd_hdmi_print_eld_info(struct hdmi_eld
*eld
,
482 struct snd_info_buffer
*buffer
)
484 struct parsed_hdmi_eld
*e
= &eld
->info
;
485 char buf
[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE
];
487 static char *eld_version_names
[32] = {
491 [3 ... 30] = "reserved",
494 static char *cea_edid_version_names
[8] = {
495 "no CEA EDID Timing Extension block present",
499 [4 ... 7] = "reserved"
502 snd_iprintf(buffer
, "monitor_present\t\t%d\n", eld
->monitor_present
);
503 snd_iprintf(buffer
, "eld_valid\t\t%d\n", eld
->eld_valid
);
506 snd_iprintf(buffer
, "monitor_name\t\t%s\n", e
->monitor_name
);
507 snd_iprintf(buffer
, "connection_type\t\t%s\n",
508 eld_connection_type_names
[e
->conn_type
]);
509 snd_iprintf(buffer
, "eld_version\t\t[0x%x] %s\n", e
->eld_ver
,
510 eld_version_names
[e
->eld_ver
]);
511 snd_iprintf(buffer
, "edid_version\t\t[0x%x] %s\n", e
->cea_edid_ver
,
512 cea_edid_version_names
[e
->cea_edid_ver
]);
513 snd_iprintf(buffer
, "manufacture_id\t\t0x%x\n", e
->manufacture_id
);
514 snd_iprintf(buffer
, "product_id\t\t0x%x\n", e
->product_id
);
515 snd_iprintf(buffer
, "port_id\t\t\t0x%llx\n", (long long)e
->port_id
);
516 snd_iprintf(buffer
, "support_hdcp\t\t%d\n", e
->support_hdcp
);
517 snd_iprintf(buffer
, "support_ai\t\t%d\n", e
->support_ai
);
518 snd_iprintf(buffer
, "audio_sync_delay\t%d\n", e
->aud_synch_delay
);
520 snd_print_channel_allocation(e
->spk_alloc
, buf
, sizeof(buf
));
521 snd_iprintf(buffer
, "speakers\t\t[0x%x]%s\n", e
->spk_alloc
, buf
);
523 snd_iprintf(buffer
, "sad_count\t\t%d\n", e
->sad_count
);
525 for (i
= 0; i
< e
->sad_count
; i
++)
526 hdmi_print_sad_info(i
, e
->sad
+ i
, buffer
);
529 void snd_hdmi_write_eld_info(struct hdmi_eld
*eld
,
530 struct snd_info_buffer
*buffer
)
532 struct parsed_hdmi_eld
*e
= &eld
->info
;
539 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
540 if (sscanf(line
, "%s %llx", name
, &val
) != 2)
543 * We don't allow modification to these fields:
544 * monitor_name manufacture_id product_id
545 * eld_version edid_version
547 if (!strcmp(name
, "monitor_present"))
548 eld
->monitor_present
= val
;
549 else if (!strcmp(name
, "eld_valid"))
550 eld
->eld_valid
= val
;
551 else if (!strcmp(name
, "connection_type"))
553 else if (!strcmp(name
, "port_id"))
555 else if (!strcmp(name
, "support_hdcp"))
556 e
->support_hdcp
= val
;
557 else if (!strcmp(name
, "support_ai"))
559 else if (!strcmp(name
, "audio_sync_delay"))
560 e
->aud_synch_delay
= val
;
561 else if (!strcmp(name
, "speakers"))
563 else if (!strcmp(name
, "sad_count"))
565 else if (!strncmp(name
, "sad", 3)) {
568 if (name
[4] >= '0' && name
[4] <= '9') {
570 n
= 10 * n
+ name
[4] - '0';
572 if (n
>= ELD_MAX_SAD
)
574 if (!strcmp(sname
, "_coding_type"))
575 e
->sad
[n
].format
= val
;
576 else if (!strcmp(sname
, "_channels"))
577 e
->sad
[n
].channels
= val
;
578 else if (!strcmp(sname
, "_rates"))
579 e
->sad
[n
].rates
= val
;
580 else if (!strcmp(sname
, "_bits"))
581 e
->sad
[n
].sample_bits
= val
;
582 else if (!strcmp(sname
, "_max_bitrate"))
583 e
->sad
[n
].max_bitrate
= val
;
584 else if (!strcmp(sname
, "_profile"))
585 e
->sad
[n
].profile
= val
;
586 if (n
>= e
->sad_count
)
587 e
->sad_count
= n
+ 1;
591 #endif /* CONFIG_PROC_FS */
593 /* update PCM info based on ELD */
594 void snd_hdmi_eld_update_pcm_info(struct parsed_hdmi_eld
*e
,
595 struct hda_pcm_stream
*hinfo
)
600 unsigned int channels_max
;
603 /* assume basic audio support (the basic audio flag is not in ELD;
604 * however, all audio capable sinks are required to support basic
606 rates
= SNDRV_PCM_RATE_32000
| SNDRV_PCM_RATE_44100
|
607 SNDRV_PCM_RATE_48000
;
608 formats
= SNDRV_PCM_FMTBIT_S16_LE
;
611 for (i
= 0; i
< e
->sad_count
; i
++) {
612 struct cea_sad
*a
= &e
->sad
[i
];
614 if (a
->channels
> channels_max
)
615 channels_max
= a
->channels
;
616 if (a
->format
== AUDIO_CODING_TYPE_LPCM
) {
617 if (a
->sample_bits
& AC_SUPPCM_BITS_20
) {
618 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
622 if (a
->sample_bits
& AC_SUPPCM_BITS_24
) {
623 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
630 /* restrict the parameters by the values the codec provides */
631 hinfo
->rates
&= rates
;
632 hinfo
->formats
&= formats
;
633 hinfo
->maxbps
= min(hinfo
->maxbps
, maxbps
);
634 hinfo
->channels_max
= min(hinfo
->channels_max
, channels_max
);
638 /* ATI/AMD specific stuff (ELD emulation) */
640 #define ATI_VERB_SET_AUDIO_DESCRIPTOR 0x776
641 #define ATI_VERB_SET_SINK_INFO_INDEX 0x780
642 #define ATI_VERB_GET_SPEAKER_ALLOCATION 0xf70
643 #define ATI_VERB_GET_AUDIO_DESCRIPTOR 0xf76
644 #define ATI_VERB_GET_AUDIO_VIDEO_DELAY 0xf7b
645 #define ATI_VERB_GET_SINK_INFO_INDEX 0xf80
646 #define ATI_VERB_GET_SINK_INFO_DATA 0xf81
648 #define ATI_SPKALLOC_SPKALLOC 0x007f
649 #define ATI_SPKALLOC_TYPE_HDMI 0x0100
650 #define ATI_SPKALLOC_TYPE_DISPLAYPORT 0x0200
652 /* first three bytes are just standard SAD */
653 #define ATI_AUDIODESC_CHANNELS 0x00000007
654 #define ATI_AUDIODESC_RATES 0x0000ff00
655 #define ATI_AUDIODESC_LPCM_STEREO_RATES 0xff000000
657 /* in standard HDMI VSDB format */
658 #define ATI_DELAY_VIDEO_LATENCY 0x000000ff
659 #define ATI_DELAY_AUDIO_LATENCY 0x0000ff00
661 enum ati_sink_info_idx
{
662 ATI_INFO_IDX_MANUFACTURER_ID
= 0,
663 ATI_INFO_IDX_PRODUCT_ID
= 1,
664 ATI_INFO_IDX_SINK_DESC_LEN
= 2,
665 ATI_INFO_IDX_PORT_ID_LOW
= 3,
666 ATI_INFO_IDX_PORT_ID_HIGH
= 4,
667 ATI_INFO_IDX_SINK_DESC_FIRST
= 5,
668 ATI_INFO_IDX_SINK_DESC_LAST
= 22, /* max len 18 bytes */
671 int snd_hdmi_get_eld_ati(struct hda_codec
*codec
, hda_nid_t nid
,
672 unsigned char *buf
, int *eld_size
, bool rev3_or_later
)
674 int spkalloc
, ati_sad
, aud_synch
;
675 int sink_desc_len
= 0;
678 /* ATI/AMD does not have ELD, emulate it */
680 spkalloc
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SPEAKER_ALLOCATION
, 0);
683 codec_info(codec
, "HDMI ATI/AMD: no speaker allocation for ELD\n");
687 memset(buf
, 0, ELD_FIXED_BYTES
+ ELD_MAX_MNL
+ ELD_MAX_SAD
* 3);
690 buf
[0] = ELD_VER_CEA_861D
<< 3;
692 /* speaker allocation from EDID */
693 buf
[7] = spkalloc
& ATI_SPKALLOC_SPKALLOC
;
695 /* is DisplayPort? */
696 if (spkalloc
& ATI_SPKALLOC_TYPE_DISPLAYPORT
)
699 pos
= ELD_FIXED_BYTES
;
704 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_PORT_ID_LOW
);
705 sink_info
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
706 put_unaligned_le32(sink_info
, buf
+ 8);
708 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_PORT_ID_HIGH
);
709 sink_info
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
710 put_unaligned_le32(sink_info
, buf
+ 12);
712 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_MANUFACTURER_ID
);
713 sink_info
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
714 put_unaligned_le16(sink_info
, buf
+ 16);
716 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_PRODUCT_ID
);
717 sink_info
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
718 put_unaligned_le16(sink_info
, buf
+ 18);
720 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_SINK_DESC_LEN
);
721 sink_desc_len
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
723 if (sink_desc_len
> ELD_MAX_MNL
) {
724 codec_info(codec
, "HDMI ATI/AMD: Truncating HDMI sink description with length %d\n",
726 sink_desc_len
= ELD_MAX_MNL
;
729 buf
[4] |= sink_desc_len
;
731 for (i
= 0; i
< sink_desc_len
; i
++) {
732 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_SINK_INFO_INDEX
, ATI_INFO_IDX_SINK_DESC_FIRST
+ i
);
733 buf
[pos
++] = snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_SINK_INFO_DATA
, 0);
737 for (i
= AUDIO_CODING_TYPE_LPCM
; i
<= AUDIO_CODING_TYPE_WMAPRO
; i
++) {
738 if (i
== AUDIO_CODING_TYPE_SACD
|| i
== AUDIO_CODING_TYPE_DST
)
739 continue; /* not handled by ATI/AMD */
741 snd_hda_codec_write(codec
, nid
, 0, ATI_VERB_SET_AUDIO_DESCRIPTOR
, i
<< 3);
742 ati_sad
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_AUDIO_DESCRIPTOR
, 0);
747 if (ati_sad
& ATI_AUDIODESC_RATES
) {
748 /* format is supported, copy SAD as-is */
749 buf
[pos
++] = (ati_sad
& 0x0000ff) >> 0;
750 buf
[pos
++] = (ati_sad
& 0x00ff00) >> 8;
751 buf
[pos
++] = (ati_sad
& 0xff0000) >> 16;
754 if (i
== AUDIO_CODING_TYPE_LPCM
755 && (ati_sad
& ATI_AUDIODESC_LPCM_STEREO_RATES
)
756 && (ati_sad
& ATI_AUDIODESC_LPCM_STEREO_RATES
) >> 16 != (ati_sad
& ATI_AUDIODESC_RATES
)) {
757 /* for PCM there is a separate stereo rate mask */
758 buf
[pos
++] = ((ati_sad
& 0x000000ff) & ~ATI_AUDIODESC_CHANNELS
) | 0x1;
759 /* rates from the extra byte */
760 buf
[pos
++] = (ati_sad
& 0xff000000) >> 24;
761 buf
[pos
++] = (ati_sad
& 0x00ff0000) >> 16;
765 if (pos
== ELD_FIXED_BYTES
+ sink_desc_len
) {
766 codec_info(codec
, "HDMI ATI/AMD: no audio descriptors for ELD\n");
771 * HDMI VSDB latency format:
772 * separately for both audio and video:
773 * 0 field not valid or unknown latency
774 * [1..251] msecs = (x-1)*2 (max 500ms with x = 251 = 0xfb)
775 * 255 audio/video not supported
777 * HDA latency format:
778 * single value indicating video latency relative to audio:
780 * [1..250] msecs = x*2 (max 500ms with x = 250 = 0xfa)
781 * [251..255] reserved
783 aud_synch
= snd_hda_codec_read(codec
, nid
, 0, ATI_VERB_GET_AUDIO_VIDEO_DELAY
, 0);
784 if ((aud_synch
& ATI_DELAY_VIDEO_LATENCY
) && (aud_synch
& ATI_DELAY_AUDIO_LATENCY
)) {
785 int video_latency_hdmi
= (aud_synch
& ATI_DELAY_VIDEO_LATENCY
);
786 int audio_latency_hdmi
= (aud_synch
& ATI_DELAY_AUDIO_LATENCY
) >> 8;
788 if (video_latency_hdmi
<= 0xfb && audio_latency_hdmi
<= 0xfb &&
789 video_latency_hdmi
> audio_latency_hdmi
)
790 buf
[6] = video_latency_hdmi
- audio_latency_hdmi
;
791 /* else unknown/invalid or 0ms or video ahead of audio, so use zero */
795 buf
[5] |= ((pos
- ELD_FIXED_BYTES
- sink_desc_len
) / 3) << 4;
797 /* Baseline ELD block length is 4-byte aligned */
798 pos
= round_up(pos
, 4);
800 /* Baseline ELD length (4-byte header is not counted in) */
801 buf
[2] = (pos
- 4) / 4;