1 /*
2 * Copyright 2015 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: AMD
23 *
24 */
25
26 #include "dm_services.h"
27 #include "core_types.h"
28 #include "timing_generator.h"
29 #include "hw_sequencer.h"
30
31 #define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0]))
32
33 /* used as index in array of black_color_format */
34 enum black_color_format {
35 BLACK_COLOR_FORMAT_RGB_FULLRANGE = 0,
36 BLACK_COLOR_FORMAT_RGB_LIMITED,
37 BLACK_COLOR_FORMAT_YUV_TV,
38 BLACK_COLOR_FORMAT_YUV_CV,
39 BLACK_COLOR_FORMAT_YUV_SUPER_AA,
40 BLACK_COLOR_FORMAT_DEBUG,
41 };
42
43 enum dc_color_space_type {
44 COLOR_SPACE_RGB_TYPE,
45 COLOR_SPACE_RGB_LIMITED_TYPE,
46 COLOR_SPACE_YCBCR601_TYPE,
47 COLOR_SPACE_YCBCR709_TYPE,
48 COLOR_SPACE_YCBCR2020_TYPE,
49 COLOR_SPACE_YCBCR601_LIMITED_TYPE,
50 COLOR_SPACE_YCBCR709_LIMITED_TYPE,
51 COLOR_SPACE_YCBCR709_BLACK_TYPE,
52 };
53
54 static const struct tg_color black_color_format[] = {
55 /* BlackColorFormat_RGB_FullRange */
56 {0, 0, 0},
57 /* BlackColorFormat_RGB_Limited */
58 {0x40, 0x40, 0x40},
59 /* BlackColorFormat_YUV_TV */
60 {0x200, 0x40, 0x200},
61 /* BlackColorFormat_YUV_CV */
62 {0x1f4, 0x40, 0x1f4},
63 /* BlackColorFormat_YUV_SuperAA */
64 {0x1a2, 0x20, 0x1a2},
65 /* visual confirm debug */
66 {0xff, 0xff, 0},
67 };
68
69 struct out_csc_color_matrix_type {
70 enum dc_color_space_type color_space_type;
71 uint16_t regval[12];
72 };
73
74 static const struct out_csc_color_matrix_type output_csc_matrix[] = {
75 { COLOR_SPACE_RGB_TYPE,
76 { 0x2000, 0, 0, 0, 0, 0x2000, 0, 0, 0, 0, 0x2000, 0} },
77 { COLOR_SPACE_RGB_LIMITED_TYPE,
78 { 0x1B67, 0, 0, 0x201, 0, 0x1B67, 0, 0x201, 0, 0, 0x1B67, 0x201} },
79 { COLOR_SPACE_YCBCR601_TYPE,
80 { 0xE04, 0xF444, 0xFDB9, 0x1004, 0x831, 0x1016, 0x320, 0x201, 0xFB45,
81 0xF6B7, 0xE04, 0x1004} },
82 { COLOR_SPACE_YCBCR709_TYPE,
83 { 0xE04, 0xF345, 0xFEB7, 0x1004, 0x5D3, 0x1399, 0x1FA,
84 0x201, 0xFCCA, 0xF533, 0xE04, 0x1004} },
85 /* TODO: correct values below */
86 { COLOR_SPACE_YCBCR601_LIMITED_TYPE,
87 { 0xE00, 0xF447, 0xFDB9, 0x1000, 0x991,
88 0x12C9, 0x3A6, 0x200, 0xFB47, 0xF6B9, 0xE00, 0x1000} },
89 { COLOR_SPACE_YCBCR709_LIMITED_TYPE,
90 { 0xE00, 0xF349, 0xFEB7, 0x1000, 0x6CE, 0x16E3,
91 0x24F, 0x200, 0xFCCB, 0xF535, 0xE00, 0x1000} },
92 { COLOR_SPACE_YCBCR2020_TYPE,
93 { 0x1000, 0xF149, 0xFEB7, 0x1004, 0x0868, 0x15B2,
94 0x01E6, 0x201, 0xFB88, 0xF478, 0x1000, 0x1004} },
95 { COLOR_SPACE_YCBCR709_BLACK_TYPE,
96 { 0x0000, 0x0000, 0x0000, 0x1000, 0x0000, 0x0000,
97 0x0000, 0x0200, 0x0000, 0x0000, 0x0000, 0x1000} },
98 };
99
is_rgb_type(enum dc_color_space color_space)100 static bool is_rgb_type(
101 enum dc_color_space color_space)
102 {
103 bool ret = false;
104
105 if (color_space == COLOR_SPACE_SRGB ||
106 color_space == COLOR_SPACE_XR_RGB ||
107 color_space == COLOR_SPACE_MSREF_SCRGB ||
108 color_space == COLOR_SPACE_2020_RGB_FULLRANGE ||
109 color_space == COLOR_SPACE_ADOBERGB ||
110 color_space == COLOR_SPACE_DCIP3 ||
111 color_space == COLOR_SPACE_DOLBYVISION)
112 ret = true;
113 return ret;
114 }
115
is_rgb_limited_type(enum dc_color_space color_space)116 static bool is_rgb_limited_type(
117 enum dc_color_space color_space)
118 {
119 bool ret = false;
120
121 if (color_space == COLOR_SPACE_SRGB_LIMITED ||
122 color_space == COLOR_SPACE_2020_RGB_LIMITEDRANGE)
123 ret = true;
124 return ret;
125 }
126
is_ycbcr601_type(enum dc_color_space color_space)127 static bool is_ycbcr601_type(
128 enum dc_color_space color_space)
129 {
130 bool ret = false;
131
132 if (color_space == COLOR_SPACE_YCBCR601 ||
133 color_space == COLOR_SPACE_XV_YCC_601)
134 ret = true;
135 return ret;
136 }
137
is_ycbcr601_limited_type(enum dc_color_space color_space)138 static bool is_ycbcr601_limited_type(
139 enum dc_color_space color_space)
140 {
141 bool ret = false;
142
143 if (color_space == COLOR_SPACE_YCBCR601_LIMITED)
144 ret = true;
145 return ret;
146 }
147
is_ycbcr709_type(enum dc_color_space color_space)148 static bool is_ycbcr709_type(
149 enum dc_color_space color_space)
150 {
151 bool ret = false;
152
153 if (color_space == COLOR_SPACE_YCBCR709 ||
154 color_space == COLOR_SPACE_XV_YCC_709)
155 ret = true;
156 return ret;
157 }
158
is_ycbcr2020_type(enum dc_color_space color_space)159 static bool is_ycbcr2020_type(
160 enum dc_color_space color_space)
161 {
162 bool ret = false;
163
164 if (color_space == COLOR_SPACE_2020_YCBCR)
165 ret = true;
166 return ret;
167 }
168
is_ycbcr709_limited_type(enum dc_color_space color_space)169 static bool is_ycbcr709_limited_type(
170 enum dc_color_space color_space)
171 {
172 bool ret = false;
173
174 if (color_space == COLOR_SPACE_YCBCR709_LIMITED)
175 ret = true;
176 return ret;
177 }
get_color_space_type(enum dc_color_space color_space)178 static enum dc_color_space_type get_color_space_type(enum dc_color_space color_space)
179 {
180 enum dc_color_space_type type = COLOR_SPACE_RGB_TYPE;
181
182 if (is_rgb_type(color_space))
183 type = COLOR_SPACE_RGB_TYPE;
184 else if (is_rgb_limited_type(color_space))
185 type = COLOR_SPACE_RGB_LIMITED_TYPE;
186 else if (is_ycbcr601_type(color_space))
187 type = COLOR_SPACE_YCBCR601_TYPE;
188 else if (is_ycbcr709_type(color_space))
189 type = COLOR_SPACE_YCBCR709_TYPE;
190 else if (is_ycbcr601_limited_type(color_space))
191 type = COLOR_SPACE_YCBCR601_LIMITED_TYPE;
192 else if (is_ycbcr709_limited_type(color_space))
193 type = COLOR_SPACE_YCBCR709_LIMITED_TYPE;
194 else if (is_ycbcr2020_type(color_space))
195 type = COLOR_SPACE_YCBCR2020_TYPE;
196 else if (color_space == COLOR_SPACE_YCBCR709)
197 type = COLOR_SPACE_YCBCR709_BLACK_TYPE;
198 else if (color_space == COLOR_SPACE_YCBCR709_BLACK)
199 type = COLOR_SPACE_YCBCR709_BLACK_TYPE;
200 return type;
201 }
202
find_color_matrix(enum dc_color_space color_space,uint32_t * array_size)203 const uint16_t *find_color_matrix(enum dc_color_space color_space,
204 uint32_t *array_size)
205 {
206 int i;
207 enum dc_color_space_type type;
208 const uint16_t *val = NULL;
209 int arr_size = NUM_ELEMENTS(output_csc_matrix);
210
211 type = get_color_space_type(color_space);
212 for (i = 0; i < arr_size; i++)
213 if (output_csc_matrix[i].color_space_type == type) {
214 val = output_csc_matrix[i].regval;
215 *array_size = 12;
216 break;
217 }
218
219 return val;
220 }
221
222
color_space_to_black_color(const struct dc * dc,enum dc_color_space colorspace,struct tg_color * black_color)223 void color_space_to_black_color(
224 const struct dc *dc,
225 enum dc_color_space colorspace,
226 struct tg_color *black_color)
227 {
228 switch (colorspace) {
229 case COLOR_SPACE_YCBCR601:
230 case COLOR_SPACE_YCBCR709:
231 case COLOR_SPACE_YCBCR709_BLACK:
232 case COLOR_SPACE_YCBCR601_LIMITED:
233 case COLOR_SPACE_YCBCR709_LIMITED:
234 case COLOR_SPACE_2020_YCBCR:
235 *black_color = black_color_format[BLACK_COLOR_FORMAT_YUV_CV];
236 break;
237
238 case COLOR_SPACE_SRGB_LIMITED:
239 *black_color =
240 black_color_format[BLACK_COLOR_FORMAT_RGB_LIMITED];
241 break;
242
243 /**
244 * Remove default and add case for all color space
245 * so when we forget to add new color space
246 * compiler will give a warning
247 */
248 case COLOR_SPACE_UNKNOWN:
249 case COLOR_SPACE_SRGB:
250 case COLOR_SPACE_XR_RGB:
251 case COLOR_SPACE_MSREF_SCRGB:
252 case COLOR_SPACE_XV_YCC_709:
253 case COLOR_SPACE_XV_YCC_601:
254 case COLOR_SPACE_2020_RGB_FULLRANGE:
255 case COLOR_SPACE_2020_RGB_LIMITEDRANGE:
256 case COLOR_SPACE_ADOBERGB:
257 case COLOR_SPACE_DCIP3:
258 case COLOR_SPACE_DISPLAYNATIVE:
259 case COLOR_SPACE_DOLBYVISION:
260 case COLOR_SPACE_APPCTRL:
261 case COLOR_SPACE_CUSTOMPOINTS:
262 /* fefault is sRGB black (full range). */
263 *black_color =
264 black_color_format[BLACK_COLOR_FORMAT_RGB_FULLRANGE];
265 /* default is sRGB black 0. */
266 break;
267 }
268 }
269
hwss_wait_for_blank_complete(struct timing_generator * tg)270 bool hwss_wait_for_blank_complete(
271 struct timing_generator *tg)
272 {
273 int counter;
274
275 /* Not applicable if the pipe is not primary, save 300ms of boot time */
276 if (!tg->funcs->is_blanked)
277 return true;
278 for (counter = 0; counter < 100; counter++) {
279 if (tg->funcs->is_blanked(tg))
280 break;
281
282 msleep(1);
283 }
284
285 if (counter == 100) {
286 dm_error("DC: failed to blank crtc!\n");
287 return false;
288 }
289
290 return true;
291 }
292
get_mpctree_visual_confirm_color(struct pipe_ctx * pipe_ctx,struct tg_color * color)293 void get_mpctree_visual_confirm_color(
294 struct pipe_ctx *pipe_ctx,
295 struct tg_color *color)
296 {
297 const struct tg_color pipe_colors[6] = {
298 {MAX_TG_COLOR_VALUE, 0, 0}, /* red */
299 {MAX_TG_COLOR_VALUE, MAX_TG_COLOR_VALUE / 4, 0}, /* orange */
300 {MAX_TG_COLOR_VALUE, MAX_TG_COLOR_VALUE, 0}, /* yellow */
301 {0, MAX_TG_COLOR_VALUE, 0}, /* green */
302 {0, 0, MAX_TG_COLOR_VALUE}, /* blue */
303 {MAX_TG_COLOR_VALUE / 2, 0, MAX_TG_COLOR_VALUE / 2}, /* purple */
304 };
305
306 struct pipe_ctx *top_pipe = pipe_ctx;
307
308 while (top_pipe->top_pipe)
309 top_pipe = top_pipe->top_pipe;
310
311 *color = pipe_colors[top_pipe->pipe_idx];
312 }
313
get_surface_visual_confirm_color(const struct pipe_ctx * pipe_ctx,struct tg_color * color)314 void get_surface_visual_confirm_color(
315 const struct pipe_ctx *pipe_ctx,
316 struct tg_color *color)
317 {
318 uint32_t color_value = MAX_TG_COLOR_VALUE;
319
320 switch (pipe_ctx->plane_res.scl_data.format) {
321 case PIXEL_FORMAT_ARGB8888:
322 /* set border color to red */
323 color->color_r_cr = color_value;
324 if (pipe_ctx->plane_state->layer_index > 0) {
325 /* set border color to pink */
326 color->color_b_cb = color_value;
327 color->color_g_y = color_value * 0.5;
328 }
329 break;
330
331 case PIXEL_FORMAT_ARGB2101010:
332 /* set border color to blue */
333 color->color_b_cb = color_value;
334 if (pipe_ctx->plane_state->layer_index > 0) {
335 /* set border color to cyan */
336 color->color_g_y = color_value;
337 }
338 break;
339 case PIXEL_FORMAT_420BPP8:
340 /* set border color to green */
341 color->color_g_y = color_value;
342 break;
343 case PIXEL_FORMAT_420BPP10:
344 /* set border color to yellow */
345 color->color_g_y = color_value;
346 color->color_r_cr = color_value;
347 break;
348 case PIXEL_FORMAT_FP16:
349 /* set border color to white */
350 color->color_r_cr = color_value;
351 color->color_b_cb = color_value;
352 color->color_g_y = color_value;
353 if (pipe_ctx->plane_state->layer_index > 0) {
354 /* set border color to orange */
355 color->color_g_y = 0.22 * color_value;
356 color->color_b_cb = 0;
357 }
358 break;
359 default:
360 break;
361 }
362 }
363
get_hdr_visual_confirm_color(struct pipe_ctx * pipe_ctx,struct tg_color * color)364 void get_hdr_visual_confirm_color(
365 struct pipe_ctx *pipe_ctx,
366 struct tg_color *color)
367 {
368 uint32_t color_value = MAX_TG_COLOR_VALUE;
369 bool is_sdr = false;
370
371 /* Determine the overscan color based on the top-most (desktop) plane's context */
372 struct pipe_ctx *top_pipe_ctx = pipe_ctx;
373
374 while (top_pipe_ctx->top_pipe != NULL)
375 top_pipe_ctx = top_pipe_ctx->top_pipe;
376
377 switch (top_pipe_ctx->plane_res.scl_data.format) {
378 case PIXEL_FORMAT_ARGB2101010:
379 if (top_pipe_ctx->stream->out_transfer_func->tf == TRANSFER_FUNCTION_PQ) {
380 /* HDR10, ARGB2101010 - set border color to red */
381 color->color_r_cr = color_value;
382 } else if (top_pipe_ctx->stream->out_transfer_func->tf == TRANSFER_FUNCTION_GAMMA22) {
383 /* FreeSync 2 ARGB2101010 - set border color to pink */
384 color->color_r_cr = color_value;
385 color->color_b_cb = color_value;
386 } else
387 is_sdr = true;
388 break;
389 case PIXEL_FORMAT_FP16:
390 if (top_pipe_ctx->stream->out_transfer_func->tf == TRANSFER_FUNCTION_PQ) {
391 /* HDR10, FP16 - set border color to blue */
392 color->color_b_cb = color_value;
393 } else if (top_pipe_ctx->stream->out_transfer_func->tf == TRANSFER_FUNCTION_GAMMA22) {
394 /* FreeSync 2 HDR - set border color to green */
395 color->color_g_y = color_value;
396 } else
397 is_sdr = true;
398 break;
399 default:
400 is_sdr = true;
401 break;
402 }
403
404 if (is_sdr) {
405 /* SDR - set border color to Gray */
406 color->color_r_cr = color_value/2;
407 color->color_b_cb = color_value/2;
408 color->color_g_y = color_value/2;
409 }
410 }
411
get_subvp_visual_confirm_color(struct dc * dc,struct pipe_ctx * pipe_ctx,struct tg_color * color)412 void get_subvp_visual_confirm_color(
413 struct dc *dc,
414 struct pipe_ctx *pipe_ctx,
415 struct tg_color *color)
416 {
417 uint32_t color_value = MAX_TG_COLOR_VALUE;
418 bool enable_subvp = false;
419 int i;
420
421 if (!dc->ctx || !dc->ctx->dmub_srv || !pipe_ctx)
422 return;
423
424 for (i = 0; i < dc->res_pool->pipe_count; i++) {
425 struct pipe_ctx *pipe = &dc->current_state->res_ctx.pipe_ctx[i];
426
427 if (pipe->stream && pipe->stream->mall_stream_config.paired_stream &&
428 pipe->stream->mall_stream_config.type == SUBVP_MAIN) {
429 /* SubVP enable - red */
430 color->color_r_cr = color_value;
431 enable_subvp = true;
432
433 if (pipe_ctx->stream == pipe->stream)
434 return;
435 break;
436 }
437 }
438
439 if (enable_subvp && pipe_ctx->stream->mall_stream_config.type == SUBVP_NONE) {
440 color->color_r_cr = 0;
441 if (pipe_ctx->stream->ignore_msa_timing_param == 1)
442 /* SubVP enable and DRR on - green */
443 color->color_g_y = color_value;
444 else
445 /* SubVP enable and No DRR - blue */
446 color->color_b_cb = color_value;
447 }
448 }
449
get_surface_tile_visual_confirm_color(struct pipe_ctx * pipe_ctx,struct tg_color * color)450 void get_surface_tile_visual_confirm_color(
451 struct pipe_ctx *pipe_ctx,
452 struct tg_color *color)
453 {
454 uint32_t color_value = MAX_TG_COLOR_VALUE;
455 /* Determine the overscan color based on the bottom-most plane's context */
456 struct pipe_ctx *bottom_pipe_ctx = pipe_ctx;
457
458 while (bottom_pipe_ctx->bottom_pipe != NULL)
459 bottom_pipe_ctx = bottom_pipe_ctx->bottom_pipe;
460
461 switch (bottom_pipe_ctx->plane_state->tiling_info.gfx9.swizzle) {
462 case DC_SW_LINEAR:
463 /* LINEAR Surface - set border color to red */
464 color->color_r_cr = color_value;
465 break;
466 default:
467 break;
468 }
469 }
470