1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Generic routines and proc interface for ELD(EDID Like Data) information
4 *
5 * Copyright(c) 2008 Intel Corporation.
6 * Copyright (c) 2013 Anssi Hannula <anssi.hannula@iki.fi>
7 *
8 * Authors:
9 * Wu Fengguang <wfg@linux.intel.com>
10 */
11
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <sound/core.h>
15 #include <linux/unaligned.h>
16 #include <sound/hda_chmap.h>
17 #include <sound/hda_codec.h>
18 #include "hda_local.h"
19
20 enum cea_edid_versions {
21 CEA_EDID_VER_NONE = 0,
22 CEA_EDID_VER_CEA861 = 1,
23 CEA_EDID_VER_CEA861A = 2,
24 CEA_EDID_VER_CEA861BCD = 3,
25 CEA_EDID_VER_RESERVED = 4,
26 };
27
28 /*
29 * The following two lists are shared between
30 * - HDMI audio InfoFrame (source to sink)
31 * - CEA E-EDID Extension (sink to source)
32 */
33
hdmi_get_eld_data(struct hda_codec * codec,hda_nid_t nid,int byte_index)34 static unsigned int hdmi_get_eld_data(struct hda_codec *codec, hda_nid_t nid,
35 int byte_index)
36 {
37 unsigned int val;
38
39 val = snd_hda_codec_read(codec, nid, 0,
40 AC_VERB_GET_HDMI_ELDD, byte_index);
41 #ifdef BE_PARANOID
42 codec_info(codec, "HDMI: ELD data byte %d: 0x%x\n", byte_index, val);
43 #endif
44 return val;
45 }
46
snd_hdmi_get_eld_size(struct hda_codec * codec,hda_nid_t nid)47 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid)
48 {
49 return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE,
50 AC_DIPSIZE_ELD_BUF);
51 }
52
snd_hdmi_get_eld(struct hda_codec * codec,hda_nid_t nid,unsigned char * buf,int * eld_size)53 int snd_hdmi_get_eld(struct hda_codec *codec, hda_nid_t nid,
54 unsigned char *buf, int *eld_size)
55 {
56 int i;
57 int ret = 0;
58 int size;
59
60 /*
61 * ELD size is initialized to zero in caller function. If no errors and
62 * ELD is valid, actual eld_size is assigned.
63 */
64
65 size = snd_hdmi_get_eld_size(codec, nid);
66 if (size == 0) {
67 /* wfg: workaround for ASUS P5E-VM HDMI board */
68 codec_info(codec, "HDMI: ELD buf size is 0, force 128\n");
69 size = 128;
70 }
71 if (size < ELD_FIXED_BYTES || size > ELD_MAX_SIZE) {
72 codec_info(codec, "HDMI: invalid ELD buf size %d\n", size);
73 return -ERANGE;
74 }
75
76 /* set ELD buffer */
77 for (i = 0; i < size; i++) {
78 unsigned int val = hdmi_get_eld_data(codec, nid, i);
79 /*
80 * Graphics driver might be writing to ELD buffer right now.
81 * Just abort. The caller will repoll after a while.
82 */
83 if (!(val & AC_ELDD_ELD_VALID)) {
84 codec_info(codec, "HDMI: invalid ELD data byte %d\n", i);
85 ret = -EINVAL;
86 goto error;
87 }
88 val &= AC_ELDD_ELD_DATA;
89 /*
90 * The first byte cannot be zero. This can happen on some DVI
91 * connections. Some Intel chips may also need some 250ms delay
92 * to return non-zero ELD data, even when the graphics driver
93 * correctly writes ELD content before setting ELD_valid bit.
94 */
95 if (!val && !i) {
96 codec_dbg(codec, "HDMI: 0 ELD data\n");
97 ret = -EINVAL;
98 goto error;
99 }
100 buf[i] = val;
101 }
102
103 *eld_size = size;
104 error:
105 return ret;
106 }
107
108 #ifdef CONFIG_SND_PROC_FS
snd_hdmi_print_eld_info(struct hdmi_eld * eld,struct snd_info_buffer * buffer,hda_nid_t pin_nid,int dev_id,hda_nid_t cvt_nid)109 void snd_hdmi_print_eld_info(struct hdmi_eld *eld,
110 struct snd_info_buffer *buffer,
111 hda_nid_t pin_nid, int dev_id, hda_nid_t cvt_nid)
112 {
113 snd_iprintf(buffer, "monitor_present\t\t%d\n", eld->monitor_present);
114 snd_iprintf(buffer, "eld_valid\t\t%d\n", eld->eld_valid);
115 snd_iprintf(buffer, "codec_pin_nid\t\t0x%x\n", pin_nid);
116 snd_iprintf(buffer, "codec_dev_id\t\t0x%x\n", dev_id);
117 snd_iprintf(buffer, "codec_cvt_nid\t\t0x%x\n", cvt_nid);
118
119 if (!eld->eld_valid)
120 return;
121
122 snd_print_eld_info(&eld->info, buffer);
123 }
124
snd_hdmi_write_eld_info(struct hdmi_eld * eld,struct snd_info_buffer * buffer)125 void snd_hdmi_write_eld_info(struct hdmi_eld *eld,
126 struct snd_info_buffer *buffer)
127 {
128 struct snd_parsed_hdmi_eld *e = &eld->info;
129 char line[64];
130 char name[64];
131 char *sname;
132 long long val;
133 unsigned int n;
134
135 while (!snd_info_get_line(buffer, line, sizeof(line))) {
136 if (sscanf(line, "%s %llx", name, &val) != 2)
137 continue;
138 /*
139 * We don't allow modification to these fields:
140 * monitor_name manufacture_id product_id
141 * eld_version edid_version
142 */
143 if (!strcmp(name, "monitor_present"))
144 eld->monitor_present = val;
145 else if (!strcmp(name, "eld_valid"))
146 eld->eld_valid = val;
147 else if (!strcmp(name, "connection_type"))
148 e->conn_type = val;
149 else if (!strcmp(name, "port_id"))
150 e->port_id = val;
151 else if (!strcmp(name, "support_hdcp"))
152 e->support_hdcp = val;
153 else if (!strcmp(name, "support_ai"))
154 e->support_ai = val;
155 else if (!strcmp(name, "audio_sync_delay"))
156 e->aud_synch_delay = val;
157 else if (!strcmp(name, "speakers"))
158 e->spk_alloc = val;
159 else if (!strcmp(name, "sad_count"))
160 e->sad_count = val;
161 else if (!strncmp(name, "sad", 3)) {
162 sname = name + 4;
163 n = name[3] - '0';
164 if (name[4] >= '0' && name[4] <= '9') {
165 sname++;
166 n = 10 * n + name[4] - '0';
167 }
168 if (n >= ELD_MAX_SAD)
169 continue;
170 if (!strcmp(sname, "_coding_type"))
171 e->sad[n].format = val;
172 else if (!strcmp(sname, "_channels"))
173 e->sad[n].channels = val;
174 else if (!strcmp(sname, "_rates"))
175 e->sad[n].rates = val;
176 else if (!strcmp(sname, "_bits"))
177 e->sad[n].sample_bits = val;
178 else if (!strcmp(sname, "_max_bitrate"))
179 e->sad[n].max_bitrate = val;
180 else if (!strcmp(sname, "_profile"))
181 e->sad[n].profile = val;
182 if (n >= e->sad_count)
183 e->sad_count = n + 1;
184 }
185 }
186 }
187 #endif /* CONFIG_SND_PROC_FS */
188
189 /* update PCM info based on ELD */
snd_hdmi_eld_update_pcm_info(struct snd_parsed_hdmi_eld * e,struct hda_pcm_stream * hinfo)190 void snd_hdmi_eld_update_pcm_info(struct snd_parsed_hdmi_eld *e,
191 struct hda_pcm_stream *hinfo)
192 {
193 u32 rates;
194 u64 formats;
195 unsigned int maxbps;
196 unsigned int channels_max;
197 int i;
198
199 /* assume basic audio support (the basic audio flag is not in ELD;
200 * however, all audio capable sinks are required to support basic
201 * audio) */
202 rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
203 SNDRV_PCM_RATE_48000;
204 formats = SNDRV_PCM_FMTBIT_S16_LE;
205 maxbps = 16;
206 channels_max = 2;
207 for (i = 0; i < e->sad_count; i++) {
208 struct snd_cea_sad *a = &e->sad[i];
209 rates |= a->rates;
210 if (a->channels > channels_max)
211 channels_max = a->channels;
212 if (a->format == AUDIO_CODING_TYPE_LPCM) {
213 if (a->sample_bits & ELD_PCM_BITS_20) {
214 formats |= SNDRV_PCM_FMTBIT_S32_LE;
215 if (maxbps < 20)
216 maxbps = 20;
217 }
218 if (a->sample_bits & ELD_PCM_BITS_24) {
219 formats |= SNDRV_PCM_FMTBIT_S32_LE;
220 if (maxbps < 24)
221 maxbps = 24;
222 }
223 }
224 }
225
226 /* restrict the parameters by the values the codec provides */
227 hinfo->rates &= rates;
228 hinfo->formats &= formats;
229 hinfo->maxbps = min(hinfo->maxbps, maxbps);
230 hinfo->channels_max = min(hinfo->channels_max, channels_max);
231 }
232
233
234 /* ATI/AMD specific stuff (ELD emulation) */
235
236 #define ATI_VERB_SET_AUDIO_DESCRIPTOR 0x776
237 #define ATI_VERB_SET_SINK_INFO_INDEX 0x780
238 #define ATI_VERB_GET_SPEAKER_ALLOCATION 0xf70
239 #define ATI_VERB_GET_AUDIO_DESCRIPTOR 0xf76
240 #define ATI_VERB_GET_AUDIO_VIDEO_DELAY 0xf7b
241 #define ATI_VERB_GET_SINK_INFO_INDEX 0xf80
242 #define ATI_VERB_GET_SINK_INFO_DATA 0xf81
243
244 #define ATI_SPKALLOC_SPKALLOC 0x007f
245 #define ATI_SPKALLOC_TYPE_HDMI 0x0100
246 #define ATI_SPKALLOC_TYPE_DISPLAYPORT 0x0200
247
248 /* first three bytes are just standard SAD */
249 #define ATI_AUDIODESC_CHANNELS 0x00000007
250 #define ATI_AUDIODESC_RATES 0x0000ff00
251 #define ATI_AUDIODESC_LPCM_STEREO_RATES 0xff000000
252
253 /* in standard HDMI VSDB format */
254 #define ATI_DELAY_VIDEO_LATENCY 0x000000ff
255 #define ATI_DELAY_AUDIO_LATENCY 0x0000ff00
256
257 enum ati_sink_info_idx {
258 ATI_INFO_IDX_MANUFACTURER_ID = 0,
259 ATI_INFO_IDX_PRODUCT_ID = 1,
260 ATI_INFO_IDX_SINK_DESC_LEN = 2,
261 ATI_INFO_IDX_PORT_ID_LOW = 3,
262 ATI_INFO_IDX_PORT_ID_HIGH = 4,
263 ATI_INFO_IDX_SINK_DESC_FIRST = 5,
264 ATI_INFO_IDX_SINK_DESC_LAST = 22, /* max len 18 bytes */
265 };
266
snd_hdmi_get_eld_ati(struct hda_codec * codec,hda_nid_t nid,unsigned char * buf,int * eld_size,bool rev3_or_later)267 int snd_hdmi_get_eld_ati(struct hda_codec *codec, hda_nid_t nid,
268 unsigned char *buf, int *eld_size, bool rev3_or_later)
269 {
270 int spkalloc, ati_sad, aud_synch;
271 int sink_desc_len = 0;
272 int pos, i;
273
274 /* ATI/AMD does not have ELD, emulate it */
275
276 spkalloc = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SPEAKER_ALLOCATION, 0);
277
278 if (spkalloc <= 0) {
279 codec_info(codec, "HDMI ATI/AMD: no speaker allocation for ELD\n");
280 return -EINVAL;
281 }
282
283 memset(buf, 0, ELD_FIXED_BYTES + ELD_MAX_MNL + ELD_MAX_SAD * 3);
284
285 /* version */
286 buf[0] = ELD_VER_CEA_861D << 3;
287
288 /* speaker allocation from EDID */
289 buf[7] = spkalloc & ATI_SPKALLOC_SPKALLOC;
290
291 /* is DisplayPort? */
292 if (spkalloc & ATI_SPKALLOC_TYPE_DISPLAYPORT)
293 buf[5] |= 0x04;
294
295 pos = ELD_FIXED_BYTES;
296
297 if (rev3_or_later) {
298 int sink_info;
299
300 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_LOW);
301 sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
302 put_unaligned_le32(sink_info, buf + 8);
303
304 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_HIGH);
305 sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
306 put_unaligned_le32(sink_info, buf + 12);
307
308 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_MANUFACTURER_ID);
309 sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
310 put_unaligned_le16(sink_info, buf + 16);
311
312 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PRODUCT_ID);
313 sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
314 put_unaligned_le16(sink_info, buf + 18);
315
316 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_LEN);
317 sink_desc_len = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
318
319 if (sink_desc_len > ELD_MAX_MNL) {
320 codec_info(codec, "HDMI ATI/AMD: Truncating HDMI sink description with length %d\n",
321 sink_desc_len);
322 sink_desc_len = ELD_MAX_MNL;
323 }
324
325 buf[4] |= sink_desc_len;
326
327 for (i = 0; i < sink_desc_len; i++) {
328 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_FIRST + i);
329 buf[pos++] = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
330 }
331 }
332
333 for (i = AUDIO_CODING_TYPE_LPCM; i <= AUDIO_CODING_TYPE_WMAPRO; i++) {
334 if (i == AUDIO_CODING_TYPE_SACD || i == AUDIO_CODING_TYPE_DST)
335 continue; /* not handled by ATI/AMD */
336
337 snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_AUDIO_DESCRIPTOR, i << 3);
338 ati_sad = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_DESCRIPTOR, 0);
339
340 if (ati_sad <= 0)
341 continue;
342
343 if (ati_sad & ATI_AUDIODESC_RATES) {
344 /* format is supported, copy SAD as-is */
345 buf[pos++] = (ati_sad & 0x0000ff) >> 0;
346 buf[pos++] = (ati_sad & 0x00ff00) >> 8;
347 buf[pos++] = (ati_sad & 0xff0000) >> 16;
348 }
349
350 if (i == AUDIO_CODING_TYPE_LPCM
351 && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES)
352 && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES) >> 16 != (ati_sad & ATI_AUDIODESC_RATES)) {
353 /* for PCM there is a separate stereo rate mask */
354 buf[pos++] = ((ati_sad & 0x000000ff) & ~ATI_AUDIODESC_CHANNELS) | 0x1;
355 /* rates from the extra byte */
356 buf[pos++] = (ati_sad & 0xff000000) >> 24;
357 buf[pos++] = (ati_sad & 0x00ff0000) >> 16;
358 }
359 }
360
361 if (pos == ELD_FIXED_BYTES + sink_desc_len) {
362 codec_info(codec, "HDMI ATI/AMD: no audio descriptors for ELD\n");
363 return -EINVAL;
364 }
365
366 /*
367 * HDMI VSDB latency format:
368 * separately for both audio and video:
369 * 0 field not valid or unknown latency
370 * [1..251] msecs = (x-1)*2 (max 500ms with x = 251 = 0xfb)
371 * 255 audio/video not supported
372 *
373 * HDA latency format:
374 * single value indicating video latency relative to audio:
375 * 0 unknown or 0ms
376 * [1..250] msecs = x*2 (max 500ms with x = 250 = 0xfa)
377 * [251..255] reserved
378 */
379 aud_synch = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_VIDEO_DELAY, 0);
380 if ((aud_synch & ATI_DELAY_VIDEO_LATENCY) && (aud_synch & ATI_DELAY_AUDIO_LATENCY)) {
381 int video_latency_hdmi = (aud_synch & ATI_DELAY_VIDEO_LATENCY);
382 int audio_latency_hdmi = (aud_synch & ATI_DELAY_AUDIO_LATENCY) >> 8;
383
384 if (video_latency_hdmi <= 0xfb && audio_latency_hdmi <= 0xfb &&
385 video_latency_hdmi > audio_latency_hdmi)
386 buf[6] = video_latency_hdmi - audio_latency_hdmi;
387 /* else unknown/invalid or 0ms or video ahead of audio, so use zero */
388 }
389
390 /* SAD count */
391 buf[5] |= ((pos - ELD_FIXED_BYTES - sink_desc_len) / 3) << 4;
392
393 /* Baseline ELD block length is 4-byte aligned */
394 pos = round_up(pos, 4);
395
396 /* Baseline ELD length (4-byte header is not counted in) */
397 buf[2] = (pos - 4) / 4;
398
399 *eld_size = pos;
400
401 return 0;
402 }
403