Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: MIT
2
3#include <linux/export.h>
4#include <linux/module.h>
5
6#include <drm/display/drm_hdmi_helper.h>
7#include <drm/drm_connector.h>
8#include <drm/drm_edid.h>
9#include <drm/drm_modes.h>
10#include <drm/drm_print.h>
11#include <drm/drm_property.h>
12
13static inline bool is_eotf_supported(u8 output_eotf, u8 sink_eotf)
14{
15 return sink_eotf & BIT(output_eotf);
16}
17
18/**
19 * drm_hdmi_infoframe_set_hdr_metadata() - fill an HDMI DRM infoframe with
20 * HDR metadata from userspace
21 * @frame: HDMI DRM infoframe
22 * @conn_state: Connector state containing HDR metadata
23 *
24 * Return: 0 on success or a negative error code on failure.
25 */
26int drm_hdmi_infoframe_set_hdr_metadata(struct hdmi_drm_infoframe *frame,
27 const struct drm_connector_state *conn_state)
28{
29 struct drm_connector *connector;
30 struct hdr_output_metadata *hdr_metadata;
31 int err;
32
33 if (!frame || !conn_state)
34 return -EINVAL;
35
36 connector = conn_state->connector;
37
38 if (!conn_state->hdr_output_metadata)
39 return -EINVAL;
40
41 hdr_metadata = conn_state->hdr_output_metadata->data;
42
43 if (!hdr_metadata || !connector)
44 return -EINVAL;
45
46 /* Sink EOTF is Bit map while infoframe is absolute values */
47 if (!is_eotf_supported(hdr_metadata->hdmi_metadata_type1.eotf,
48 connector->display_info.hdr_sink_metadata.hdmi_type1.eotf))
49 DRM_DEBUG_KMS("Unknown EOTF %d\n", hdr_metadata->hdmi_metadata_type1.eotf);
50
51 err = hdmi_drm_infoframe_init(frame);
52 if (err < 0)
53 return err;
54
55 frame->eotf = hdr_metadata->hdmi_metadata_type1.eotf;
56 frame->metadata_type = hdr_metadata->hdmi_metadata_type1.metadata_type;
57
58 BUILD_BUG_ON(sizeof(frame->display_primaries) !=
59 sizeof(hdr_metadata->hdmi_metadata_type1.display_primaries));
60 BUILD_BUG_ON(sizeof(frame->white_point) !=
61 sizeof(hdr_metadata->hdmi_metadata_type1.white_point));
62
63 memcpy(&frame->display_primaries,
64 &hdr_metadata->hdmi_metadata_type1.display_primaries,
65 sizeof(frame->display_primaries));
66
67 memcpy(&frame->white_point,
68 &hdr_metadata->hdmi_metadata_type1.white_point,
69 sizeof(frame->white_point));
70
71 frame->max_display_mastering_luminance =
72 hdr_metadata->hdmi_metadata_type1.max_display_mastering_luminance;
73 frame->min_display_mastering_luminance =
74 hdr_metadata->hdmi_metadata_type1.min_display_mastering_luminance;
75 frame->max_fall = hdr_metadata->hdmi_metadata_type1.max_fall;
76 frame->max_cll = hdr_metadata->hdmi_metadata_type1.max_cll;
77
78 return 0;
79}
80EXPORT_SYMBOL(drm_hdmi_infoframe_set_hdr_metadata);
81
82/* HDMI Colorspace Spec Definitions */
83#define FULL_COLORIMETRY_MASK 0x1FF
84#define NORMAL_COLORIMETRY_MASK 0x3
85#define EXTENDED_COLORIMETRY_MASK 0x7
86#define EXTENDED_ACE_COLORIMETRY_MASK 0xF
87
88#define C(x) ((x) << 0)
89#define EC(x) ((x) << 2)
90#define ACE(x) ((x) << 5)
91
92#define HDMI_COLORIMETRY_NO_DATA 0x0
93#define HDMI_COLORIMETRY_SMPTE_170M_YCC (C(1) | EC(0) | ACE(0))
94#define HDMI_COLORIMETRY_BT709_YCC (C(2) | EC(0) | ACE(0))
95#define HDMI_COLORIMETRY_XVYCC_601 (C(3) | EC(0) | ACE(0))
96#define HDMI_COLORIMETRY_XVYCC_709 (C(3) | EC(1) | ACE(0))
97#define HDMI_COLORIMETRY_SYCC_601 (C(3) | EC(2) | ACE(0))
98#define HDMI_COLORIMETRY_OPYCC_601 (C(3) | EC(3) | ACE(0))
99#define HDMI_COLORIMETRY_OPRGB (C(3) | EC(4) | ACE(0))
100#define HDMI_COLORIMETRY_BT2020_CYCC (C(3) | EC(5) | ACE(0))
101#define HDMI_COLORIMETRY_BT2020_RGB (C(3) | EC(6) | ACE(0))
102#define HDMI_COLORIMETRY_BT2020_YCC (C(3) | EC(6) | ACE(0))
103#define HDMI_COLORIMETRY_DCI_P3_RGB_D65 (C(3) | EC(7) | ACE(0))
104#define HDMI_COLORIMETRY_DCI_P3_RGB_THEATER (C(3) | EC(7) | ACE(1))
105
106static const u32 hdmi_colorimetry_val[] = {
107 [DRM_MODE_COLORIMETRY_NO_DATA] = HDMI_COLORIMETRY_NO_DATA,
108 [DRM_MODE_COLORIMETRY_SMPTE_170M_YCC] = HDMI_COLORIMETRY_SMPTE_170M_YCC,
109 [DRM_MODE_COLORIMETRY_BT709_YCC] = HDMI_COLORIMETRY_BT709_YCC,
110 [DRM_MODE_COLORIMETRY_XVYCC_601] = HDMI_COLORIMETRY_XVYCC_601,
111 [DRM_MODE_COLORIMETRY_XVYCC_709] = HDMI_COLORIMETRY_XVYCC_709,
112 [DRM_MODE_COLORIMETRY_SYCC_601] = HDMI_COLORIMETRY_SYCC_601,
113 [DRM_MODE_COLORIMETRY_OPYCC_601] = HDMI_COLORIMETRY_OPYCC_601,
114 [DRM_MODE_COLORIMETRY_OPRGB] = HDMI_COLORIMETRY_OPRGB,
115 [DRM_MODE_COLORIMETRY_BT2020_CYCC] = HDMI_COLORIMETRY_BT2020_CYCC,
116 [DRM_MODE_COLORIMETRY_BT2020_RGB] = HDMI_COLORIMETRY_BT2020_RGB,
117 [DRM_MODE_COLORIMETRY_BT2020_YCC] = HDMI_COLORIMETRY_BT2020_YCC,
118};
119
120#undef C
121#undef EC
122#undef ACE
123
124/**
125 * drm_hdmi_avi_infoframe_colorimetry() - fill the HDMI AVI infoframe
126 * colorimetry information
127 * @frame: HDMI AVI infoframe
128 * @conn_state: connector state
129 */
130void drm_hdmi_avi_infoframe_colorimetry(struct hdmi_avi_infoframe *frame,
131 const struct drm_connector_state *conn_state)
132{
133 u32 colorimetry_val;
134 u32 colorimetry_index = conn_state->colorspace & FULL_COLORIMETRY_MASK;
135
136 if (colorimetry_index >= ARRAY_SIZE(hdmi_colorimetry_val))
137 colorimetry_val = HDMI_COLORIMETRY_NO_DATA;
138 else
139 colorimetry_val = hdmi_colorimetry_val[colorimetry_index];
140
141 frame->colorimetry = colorimetry_val & NORMAL_COLORIMETRY_MASK;
142 /*
143 * ToDo: Extend it for ACE formats as well. Modify the infoframe
144 * structure and extend it in drivers/video/hdmi
145 */
146 frame->extended_colorimetry = (colorimetry_val >> 2) &
147 EXTENDED_COLORIMETRY_MASK;
148}
149EXPORT_SYMBOL(drm_hdmi_avi_infoframe_colorimetry);
150
151/**
152 * drm_hdmi_avi_infoframe_bars() - fill the HDMI AVI infoframe
153 * bar information
154 * @frame: HDMI AVI infoframe
155 * @conn_state: connector state
156 */
157void drm_hdmi_avi_infoframe_bars(struct hdmi_avi_infoframe *frame,
158 const struct drm_connector_state *conn_state)
159{
160 frame->right_bar = conn_state->tv.margins.right;
161 frame->left_bar = conn_state->tv.margins.left;
162 frame->top_bar = conn_state->tv.margins.top;
163 frame->bottom_bar = conn_state->tv.margins.bottom;
164}
165EXPORT_SYMBOL(drm_hdmi_avi_infoframe_bars);
166
167/**
168 * drm_hdmi_avi_infoframe_content_type() - fill the HDMI AVI infoframe
169 * content type information, based
170 * on correspondent DRM property.
171 * @frame: HDMI AVI infoframe
172 * @conn_state: DRM display connector state
173 *
174 */
175void drm_hdmi_avi_infoframe_content_type(struct hdmi_avi_infoframe *frame,
176 const struct drm_connector_state *conn_state)
177{
178 switch (conn_state->content_type) {
179 case DRM_MODE_CONTENT_TYPE_GRAPHICS:
180 frame->content_type = HDMI_CONTENT_TYPE_GRAPHICS;
181 break;
182 case DRM_MODE_CONTENT_TYPE_CINEMA:
183 frame->content_type = HDMI_CONTENT_TYPE_CINEMA;
184 break;
185 case DRM_MODE_CONTENT_TYPE_GAME:
186 frame->content_type = HDMI_CONTENT_TYPE_GAME;
187 break;
188 case DRM_MODE_CONTENT_TYPE_PHOTO:
189 frame->content_type = HDMI_CONTENT_TYPE_PHOTO;
190 break;
191 default:
192 /* Graphics is the default(0) */
193 frame->content_type = HDMI_CONTENT_TYPE_GRAPHICS;
194 }
195
196 frame->itc = conn_state->content_type != DRM_MODE_CONTENT_TYPE_NO_DATA;
197}
198EXPORT_SYMBOL(drm_hdmi_avi_infoframe_content_type);
199
200/**
201 * drm_hdmi_compute_mode_clock() - Computes the TMDS Character Rate
202 * @mode: Display mode to compute the clock for
203 * @bpc: Bits per character
204 * @fmt: Output Pixel Format used
205 *
206 * Returns the TMDS Character Rate for a given mode, bpc count and output format.
207 *
208 * RETURNS:
209 * The TMDS Character Rate, in Hertz, or 0 on error.
210 */
211unsigned long long
212drm_hdmi_compute_mode_clock(const struct drm_display_mode *mode,
213 unsigned int bpc,
214 enum drm_output_color_format fmt)
215{
216 unsigned long long clock = mode->clock * 1000ULL;
217 unsigned int vic = drm_match_cea_mode(mode);
218
219 /*
220 * CTA-861-G Spec, section 5.4 - Color Coding and Quantization
221 * mandates that VIC 1 always uses 8 bpc.
222 */
223 if (vic == 1 && bpc != 8)
224 return 0;
225
226 if (fmt == DRM_OUTPUT_COLOR_FORMAT_YCBCR422) {
227 /*
228 * HDMI 1.0 Spec, section 6.5 - Pixel Encoding states that
229 * YUV422 sends 24 bits over three channels, with Cb and Cr
230 * components being sent on odd and even pixels, respectively.
231 *
232 * If fewer than 12 bpc are sent, data are left justified.
233 */
234 if (bpc > 12)
235 return 0;
236
237 /*
238 * HDMI 1.0 Spec, section 6.5 - Pixel Encoding
239 * specifies that YUV422 sends two 12-bits components over
240 * three TMDS channels per pixel clock, which is equivalent to
241 * three 8-bits components over three channels used by RGB as
242 * far as the clock rate goes.
243 */
244 bpc = 8;
245 }
246
247 /*
248 * HDMI 2.0 Spec, Section 7.1 - YCbCr 4:2:0 Pixel Encoding
249 * specifies that YUV420 encoding is carried at a TMDS Character Rate
250 * equal to half the pixel clock rate.
251 */
252 if (fmt == DRM_OUTPUT_COLOR_FORMAT_YCBCR420)
253 clock = clock / 2;
254
255 if (mode->flags & DRM_MODE_FLAG_DBLCLK)
256 clock = clock * 2;
257
258 return DIV_ROUND_CLOSEST_ULL(clock * bpc, 8);
259}
260EXPORT_SYMBOL(drm_hdmi_compute_mode_clock);
261
262struct drm_hdmi_acr_n_cts_entry {
263 unsigned int n;
264 unsigned int cts;
265};
266
267struct drm_hdmi_acr_data {
268 unsigned long tmds_clock_khz;
269 struct drm_hdmi_acr_n_cts_entry n_cts_32k,
270 n_cts_44k1,
271 n_cts_48k;
272};
273
274static const struct drm_hdmi_acr_data hdmi_acr_n_cts[] = {
275 {
276 /* "Other" entry */
277 .n_cts_32k = { .n = 4096, },
278 .n_cts_44k1 = { .n = 6272, },
279 .n_cts_48k = { .n = 6144, },
280 }, {
281 .tmds_clock_khz = 25175,
282 .n_cts_32k = { .n = 4576, .cts = 28125, },
283 .n_cts_44k1 = { .n = 7007, .cts = 31250, },
284 .n_cts_48k = { .n = 6864, .cts = 28125, },
285 }, {
286 .tmds_clock_khz = 25200,
287 .n_cts_32k = { .n = 4096, .cts = 25200, },
288 .n_cts_44k1 = { .n = 6272, .cts = 28000, },
289 .n_cts_48k = { .n = 6144, .cts = 25200, },
290 }, {
291 .tmds_clock_khz = 27000,
292 .n_cts_32k = { .n = 4096, .cts = 27000, },
293 .n_cts_44k1 = { .n = 6272, .cts = 30000, },
294 .n_cts_48k = { .n = 6144, .cts = 27000, },
295 }, {
296 .tmds_clock_khz = 27027,
297 .n_cts_32k = { .n = 4096, .cts = 27027, },
298 .n_cts_44k1 = { .n = 6272, .cts = 30030, },
299 .n_cts_48k = { .n = 6144, .cts = 27027, },
300 }, {
301 .tmds_clock_khz = 54000,
302 .n_cts_32k = { .n = 4096, .cts = 54000, },
303 .n_cts_44k1 = { .n = 6272, .cts = 60000, },
304 .n_cts_48k = { .n = 6144, .cts = 54000, },
305 }, {
306 .tmds_clock_khz = 54054,
307 .n_cts_32k = { .n = 4096, .cts = 54054, },
308 .n_cts_44k1 = { .n = 6272, .cts = 60060, },
309 .n_cts_48k = { .n = 6144, .cts = 54054, },
310 }, {
311 .tmds_clock_khz = 74176,
312 .n_cts_32k = { .n = 11648, .cts = 210937, }, /* and 210938 */
313 .n_cts_44k1 = { .n = 17836, .cts = 234375, },
314 .n_cts_48k = { .n = 11648, .cts = 140625, },
315 }, {
316 .tmds_clock_khz = 74250,
317 .n_cts_32k = { .n = 4096, .cts = 74250, },
318 .n_cts_44k1 = { .n = 6272, .cts = 82500, },
319 .n_cts_48k = { .n = 6144, .cts = 74250, },
320 }, {
321 .tmds_clock_khz = 148352,
322 .n_cts_32k = { .n = 11648, .cts = 421875, },
323 .n_cts_44k1 = { .n = 8918, .cts = 234375, },
324 .n_cts_48k = { .n = 5824, .cts = 140625, },
325 }, {
326 .tmds_clock_khz = 148500,
327 .n_cts_32k = { .n = 4096, .cts = 148500, },
328 .n_cts_44k1 = { .n = 6272, .cts = 165000, },
329 .n_cts_48k = { .n = 6144, .cts = 148500, },
330 }, {
331 .tmds_clock_khz = 296703,
332 .n_cts_32k = { .n = 5824, .cts = 421875, },
333 .n_cts_44k1 = { .n = 4459, .cts = 234375, },
334 .n_cts_48k = { .n = 5824, .cts = 281250, },
335 }, {
336 .tmds_clock_khz = 297000,
337 .n_cts_32k = { .n = 3072, .cts = 222750, },
338 .n_cts_44k1 = { .n = 4704, .cts = 247500, },
339 .n_cts_48k = { .n = 5120, .cts = 247500, },
340 }, {
341 .tmds_clock_khz = 593407,
342 .n_cts_32k = { .n = 5824, .cts = 843750, },
343 .n_cts_44k1 = { .n = 8918, .cts = 937500, },
344 .n_cts_48k = { .n = 5824, .cts = 562500, },
345 }, {
346 .tmds_clock_khz = 594000,
347 .n_cts_32k = { .n = 3072, .cts = 445500, },
348 .n_cts_44k1 = { .n = 9408, .cts = 990000, },
349 .n_cts_48k = { .n = 6144, .cts = 594000, },
350 },
351};
352
353static int drm_hdmi_acr_find_tmds_entry(unsigned long tmds_clock_khz)
354{
355 int i;
356
357 /* skip the "other" entry */
358 for (i = 1; i < ARRAY_SIZE(hdmi_acr_n_cts); i++) {
359 if (hdmi_acr_n_cts[i].tmds_clock_khz == tmds_clock_khz)
360 return i;
361 }
362
363 return 0;
364}
365
366/**
367 * drm_hdmi_acr_get_n_cts() - get N and CTS values for Audio Clock Regeneration
368 *
369 * @tmds_char_rate: TMDS clock (char rate) as used by the HDMI connector
370 * @sample_rate: audio sample rate
371 * @out_n: a pointer to write the N value
372 * @out_cts: a pointer to write the CTS value
373 *
374 * Get the N and CTS values (either by calculating them or by returning data
375 * from the tables. This follows the HDMI 1.4b Section 7.2 "Audio Sample Clock
376 * Capture and Regeneration".
377 *
378 * Note, @sample_rate corresponds to the Fs value, see sections 7.2.4 - 7.2.6
379 * on how to select Fs for non-L-PCM formats.
380 */
381void
382drm_hdmi_acr_get_n_cts(unsigned long long tmds_char_rate,
383 unsigned int sample_rate,
384 unsigned int *out_n,
385 unsigned int *out_cts)
386{
387 /* be a bit more tolerant, especially for the 1.001 entries */
388 unsigned long tmds_clock_khz = DIV_ROUND_CLOSEST_ULL(tmds_char_rate, 1000);
389 const struct drm_hdmi_acr_n_cts_entry *entry;
390 unsigned int n, cts, mult;
391 int tmds_idx;
392
393 tmds_idx = drm_hdmi_acr_find_tmds_entry(tmds_clock_khz);
394
395 /*
396 * Don't change the order, 192 kHz is divisible by 48k and 32k, but it
397 * should use 48k entry.
398 */
399 if (sample_rate % 48000 == 0) {
400 entry = &hdmi_acr_n_cts[tmds_idx].n_cts_48k;
401 mult = sample_rate / 48000;
402 } else if (sample_rate % 44100 == 0) {
403 entry = &hdmi_acr_n_cts[tmds_idx].n_cts_44k1;
404 mult = sample_rate / 44100;
405 } else if (sample_rate % 32000 == 0) {
406 entry = &hdmi_acr_n_cts[tmds_idx].n_cts_32k;
407 mult = sample_rate / 32000;
408 } else {
409 entry = NULL;
410 }
411
412 if (entry) {
413 n = entry->n * mult;
414 cts = entry->cts;
415 } else {
416 /* Recommended optimal value, HDMI 1.4b, Section 7.2.1 */
417 n = 128 * sample_rate / 1000;
418 cts = 0;
419 }
420
421 if (!cts)
422 cts = DIV_ROUND_CLOSEST_ULL(tmds_char_rate * n,
423 128 * sample_rate);
424
425 *out_n = n;
426 *out_cts = cts;
427}
428EXPORT_SYMBOL(drm_hdmi_acr_get_n_cts);