xref: /netbsd-src/sys/external/bsd/drm2/dist/drm/amd/display/dc/dsc/amdgpu_dc_dsc.c (revision e4a580baf2598beeaae98d953ac7635b8700b80c)
1 /*	$NetBSD: amdgpu_dc_dsc.c,v 1.3 2021/12/19 10:59:02 riastradh Exp $	*/
2 
3 /*
4  * Copyright 2019 Advanced Micro Devices, Inc.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22  * OTHER DEALINGS IN THE SOFTWARE.
23  *
24  * Author: AMD
25  */
26 
27 #include <sys/cdefs.h>
28 __KERNEL_RCSID(0, "$NetBSD: amdgpu_dc_dsc.c,v 1.3 2021/12/19 10:59:02 riastradh Exp $");
29 
30 #include "dc_hw_types.h"
31 #include "dsc.h"
32 #include <drm/drm_dp_helper.h>
33 #include "dc.h"
34 
35 /* This module's internal functions */
36 
37 /* default DSC policy target bitrate limit is 16bpp */
38 static uint32_t dsc_policy_max_target_bpp_limit = 16;
39 
dc_dsc_bandwidth_in_kbps_from_timing(const struct dc_crtc_timing * timing)40 static uint32_t dc_dsc_bandwidth_in_kbps_from_timing(
41 	const struct dc_crtc_timing *timing)
42 {
43 	uint32_t bits_per_channel = 0;
44 	uint32_t kbps;
45 
46 	if (timing->flags.DSC) {
47 		kbps = (timing->pix_clk_100hz * timing->dsc_cfg.bits_per_pixel);
48 		kbps = kbps / 160 + ((kbps % 160) ? 1 : 0);
49 		return kbps;
50 	}
51 
52 	switch (timing->display_color_depth) {
53 	case COLOR_DEPTH_666:
54 		bits_per_channel = 6;
55 		break;
56 	case COLOR_DEPTH_888:
57 		bits_per_channel = 8;
58 		break;
59 	case COLOR_DEPTH_101010:
60 		bits_per_channel = 10;
61 		break;
62 	case COLOR_DEPTH_121212:
63 		bits_per_channel = 12;
64 		break;
65 	case COLOR_DEPTH_141414:
66 		bits_per_channel = 14;
67 		break;
68 	case COLOR_DEPTH_161616:
69 		bits_per_channel = 16;
70 		break;
71 	default:
72 		break;
73 	}
74 
75 	ASSERT(bits_per_channel != 0);
76 
77 	kbps = timing->pix_clk_100hz / 10;
78 	kbps *= bits_per_channel;
79 
80 	if (timing->flags.Y_ONLY != 1) {
81 		/*Only YOnly make reduce bandwidth by 1/3 compares to RGB*/
82 		kbps *= 3;
83 		if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
84 			kbps /= 2;
85 		else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422)
86 			kbps = kbps * 2 / 3;
87 	}
88 
89 	return kbps;
90 
91 }
92 
dsc_buff_block_size_from_dpcd(int dpcd_buff_block_size,int * buff_block_size)93 static bool dsc_buff_block_size_from_dpcd(int dpcd_buff_block_size, int *buff_block_size)
94 {
95 
96 	switch (dpcd_buff_block_size) {
97 	case DP_DSC_RC_BUF_BLK_SIZE_1:
98 		*buff_block_size = 1024;
99 		break;
100 	case DP_DSC_RC_BUF_BLK_SIZE_4:
101 		*buff_block_size = 4 * 1024;
102 		break;
103 	case DP_DSC_RC_BUF_BLK_SIZE_16:
104 		*buff_block_size = 16 * 1024;
105 		break;
106 	case DP_DSC_RC_BUF_BLK_SIZE_64:
107 		*buff_block_size = 64 * 1024;
108 		break;
109 	default: {
110 			dm_error("%s: DPCD DSC buffer size not recognized.\n", __func__);
111 			return false;
112 		}
113 	}
114 
115 	return true;
116 }
117 
118 
dsc_line_buff_depth_from_dpcd(int dpcd_line_buff_bit_depth,int * line_buff_bit_depth)119 static bool dsc_line_buff_depth_from_dpcd(int dpcd_line_buff_bit_depth, int *line_buff_bit_depth)
120 {
121 	if (0 <= dpcd_line_buff_bit_depth && dpcd_line_buff_bit_depth <= 7)
122 		*line_buff_bit_depth = dpcd_line_buff_bit_depth + 9;
123 	else if (dpcd_line_buff_bit_depth == 8)
124 		*line_buff_bit_depth = 8;
125 	else {
126 		dm_error("%s: DPCD DSC buffer depth not recognized.\n", __func__);
127 		return false;
128 	}
129 
130 	return true;
131 }
132 
133 
dsc_throughput_from_dpcd(int dpcd_throughput,int * throughput)134 static bool dsc_throughput_from_dpcd(int dpcd_throughput, int *throughput)
135 {
136 	switch (dpcd_throughput) {
137 	case DP_DSC_THROUGHPUT_MODE_0_UPSUPPORTED:
138 		*throughput = 0;
139 		break;
140 	case DP_DSC_THROUGHPUT_MODE_0_170:
141 		*throughput = 170;
142 		break;
143 	case DP_DSC_THROUGHPUT_MODE_0_340:
144 		*throughput = 340;
145 		break;
146 	case DP_DSC_THROUGHPUT_MODE_0_400:
147 		*throughput = 400;
148 		break;
149 	case DP_DSC_THROUGHPUT_MODE_0_450:
150 		*throughput = 450;
151 		break;
152 	case DP_DSC_THROUGHPUT_MODE_0_500:
153 		*throughput = 500;
154 		break;
155 	case DP_DSC_THROUGHPUT_MODE_0_550:
156 		*throughput = 550;
157 		break;
158 	case DP_DSC_THROUGHPUT_MODE_0_600:
159 		*throughput = 600;
160 		break;
161 	case DP_DSC_THROUGHPUT_MODE_0_650:
162 		*throughput = 650;
163 		break;
164 	case DP_DSC_THROUGHPUT_MODE_0_700:
165 		*throughput = 700;
166 		break;
167 	case DP_DSC_THROUGHPUT_MODE_0_750:
168 		*throughput = 750;
169 		break;
170 	case DP_DSC_THROUGHPUT_MODE_0_800:
171 		*throughput = 800;
172 		break;
173 	case DP_DSC_THROUGHPUT_MODE_0_850:
174 		*throughput = 850;
175 		break;
176 	case DP_DSC_THROUGHPUT_MODE_0_900:
177 		*throughput = 900;
178 		break;
179 	case DP_DSC_THROUGHPUT_MODE_0_950:
180 		*throughput = 950;
181 		break;
182 	case DP_DSC_THROUGHPUT_MODE_0_1000:
183 		*throughput = 1000;
184 		break;
185 	default: {
186 			dm_error("%s: DPCD DSC throughput mode not recognized.\n", __func__);
187 			return false;
188 		}
189 	}
190 
191 	return true;
192 }
193 
194 
dsc_bpp_increment_div_from_dpcd(int bpp_increment_dpcd,uint32_t * bpp_increment_div)195 static bool dsc_bpp_increment_div_from_dpcd(int bpp_increment_dpcd, uint32_t *bpp_increment_div)
196 {
197 
198 	switch (bpp_increment_dpcd) {
199 	case 0:
200 		*bpp_increment_div = 16;
201 		break;
202 	case 1:
203 		*bpp_increment_div = 8;
204 		break;
205 	case 2:
206 		*bpp_increment_div = 4;
207 		break;
208 	case 3:
209 		*bpp_increment_div = 2;
210 		break;
211 	case 4:
212 		*bpp_increment_div = 1;
213 		break;
214 	default: {
215 		dm_error("%s: DPCD DSC bits-per-pixel increment not recognized.\n", __func__);
216 		return false;
217 	}
218 	}
219 
220 	return true;
221 }
222 
get_dsc_enc_caps(const struct display_stream_compressor * dsc,struct dsc_enc_caps * dsc_enc_caps,int pixel_clock_100Hz)223 static void get_dsc_enc_caps(
224 	const struct display_stream_compressor *dsc,
225 	struct dsc_enc_caps *dsc_enc_caps,
226 	int pixel_clock_100Hz)
227 {
228 	// This is a static HW query, so we can use any DSC
229 
230 	memset(dsc_enc_caps, 0, sizeof(struct dsc_enc_caps));
231 	if (dsc) {
232 		if (!dsc->ctx->dc->debug.disable_dsc)
233 			dsc->funcs->dsc_get_enc_caps(dsc_enc_caps, pixel_clock_100Hz);
234 		if (dsc->ctx->dc->debug.native422_support)
235 			dsc_enc_caps->color_formats.bits.YCBCR_NATIVE_422 = 1;
236 	}
237 }
238 
239 /* Returns 'false' if no intersection was found for at least one capablity.
240  * It also implicitly validates some sink caps against invalid value of zero.
241  */
intersect_dsc_caps(const struct dsc_dec_dpcd_caps * dsc_sink_caps,const struct dsc_enc_caps * dsc_enc_caps,enum dc_pixel_encoding pixel_encoding,struct dsc_enc_caps * dsc_common_caps)242 static bool intersect_dsc_caps(
243 	const struct dsc_dec_dpcd_caps *dsc_sink_caps,
244 	const struct dsc_enc_caps *dsc_enc_caps,
245 	enum dc_pixel_encoding pixel_encoding,
246 	struct dsc_enc_caps *dsc_common_caps)
247 {
248 	int32_t max_slices;
249 	int32_t total_sink_throughput;
250 
251 	memset(dsc_common_caps, 0, sizeof(struct dsc_enc_caps));
252 
253 	dsc_common_caps->dsc_version = min(dsc_sink_caps->dsc_version, dsc_enc_caps->dsc_version);
254 	if (!dsc_common_caps->dsc_version)
255 		return false;
256 
257 	dsc_common_caps->slice_caps.bits.NUM_SLICES_1 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_1;
258 	dsc_common_caps->slice_caps.bits.NUM_SLICES_2 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_2;
259 	dsc_common_caps->slice_caps.bits.NUM_SLICES_4 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_4;
260 	dsc_common_caps->slice_caps.bits.NUM_SLICES_8 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_8;
261 	if (!dsc_common_caps->slice_caps.raw)
262 		return false;
263 
264 	dsc_common_caps->lb_bit_depth = min(dsc_sink_caps->lb_bit_depth, dsc_enc_caps->lb_bit_depth);
265 	if (!dsc_common_caps->lb_bit_depth)
266 		return false;
267 
268 	dsc_common_caps->is_block_pred_supported = dsc_sink_caps->is_block_pred_supported && dsc_enc_caps->is_block_pred_supported;
269 
270 	dsc_common_caps->color_formats.raw = dsc_sink_caps->color_formats.raw & dsc_enc_caps->color_formats.raw;
271 	if (!dsc_common_caps->color_formats.raw)
272 		return false;
273 
274 	dsc_common_caps->color_depth.raw = dsc_sink_caps->color_depth.raw & dsc_enc_caps->color_depth.raw;
275 	if (!dsc_common_caps->color_depth.raw)
276 		return false;
277 
278 	max_slices = 0;
279 	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_1)
280 		max_slices = 1;
281 
282 	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_2)
283 		max_slices = 2;
284 
285 	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_4)
286 		max_slices = 4;
287 
288 	total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_0_mps;
289 	if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
290 		total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_1_mps;
291 
292 	dsc_common_caps->max_total_throughput_mps = min(total_sink_throughput, dsc_enc_caps->max_total_throughput_mps);
293 
294 	dsc_common_caps->max_slice_width = min(dsc_sink_caps->max_slice_width, dsc_enc_caps->max_slice_width);
295 	if (!dsc_common_caps->max_slice_width)
296 		return false;
297 
298 	dsc_common_caps->bpp_increment_div = min(dsc_sink_caps->bpp_increment_div, dsc_enc_caps->bpp_increment_div);
299 
300 	// TODO DSC: Remove this workaround for N422 and 420 once it's fixed, or move it to get_dsc_encoder_caps()
301 	if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
302 		dsc_common_caps->bpp_increment_div = min(dsc_common_caps->bpp_increment_div, (uint32_t)8);
303 
304 	return true;
305 }
306 
dsc_div_by_10_round_up(uint32_t value)307 static inline uint32_t dsc_div_by_10_round_up(uint32_t value)
308 {
309 	return (value + 9) / 10;
310 }
311 
calc_dsc_bpp_x16(uint32_t stream_bandwidth_kbps,uint32_t pix_clk_100hz,uint32_t bpp_increment_div)312 static inline uint32_t calc_dsc_bpp_x16(uint32_t stream_bandwidth_kbps, uint32_t pix_clk_100hz, uint32_t bpp_increment_div)
313 {
314 #ifdef __NetBSD__
315 	panic("what is your float doing in my kernel");
316 #else
317 	uint32_t dsc_target_bpp_x16;
318 	float f_dsc_target_bpp;
319 	float f_stream_bandwidth_100bps = stream_bandwidth_kbps * 10.0f;
320 	uint32_t precision = bpp_increment_div; // bpp_increment_div is actually precision
321 
322 	f_dsc_target_bpp = f_stream_bandwidth_100bps / pix_clk_100hz;
323 
324 	// Round down to the nearest precision stop to bring it into DSC spec range
325 	dsc_target_bpp_x16 = (uint32_t)(f_dsc_target_bpp * precision);
326 	dsc_target_bpp_x16 = (dsc_target_bpp_x16 * 16) / precision;
327 
328 	return dsc_target_bpp_x16;
329 #endif
330 }
331 
332 /* Get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range, and timing's pixel clock
333  * and uncompressed bandwidth.
334  */
get_dsc_bandwidth_range(const uint32_t min_bpp,const uint32_t max_bpp,const struct dsc_enc_caps * dsc_caps,const struct dc_crtc_timing * timing,struct dc_dsc_bw_range * range)335 static void get_dsc_bandwidth_range(
336 		const uint32_t min_bpp,
337 		const uint32_t max_bpp,
338 		const struct dsc_enc_caps *dsc_caps,
339 		const struct dc_crtc_timing *timing,
340 		struct dc_dsc_bw_range *range)
341 {
342 	/* native stream bandwidth */
343 	range->stream_kbps = dc_dsc_bandwidth_in_kbps_from_timing(timing);
344 
345 	/* max dsc target bpp */
346 	range->max_kbps = dsc_div_by_10_round_up(max_bpp * timing->pix_clk_100hz);
347 	range->max_target_bpp_x16 = max_bpp * 16;
348 	if (range->max_kbps > range->stream_kbps) {
349 		/* max dsc target bpp is capped to native bandwidth */
350 		range->max_kbps = range->stream_kbps;
351 		range->max_target_bpp_x16 = calc_dsc_bpp_x16(range->stream_kbps, timing->pix_clk_100hz, dsc_caps->bpp_increment_div);
352 	}
353 
354 	/* min dsc target bpp */
355 	range->min_kbps = dsc_div_by_10_round_up(min_bpp * timing->pix_clk_100hz);
356 	range->min_target_bpp_x16 = min_bpp * 16;
357 	if (range->min_kbps > range->max_kbps) {
358 		/* min dsc target bpp is capped to max dsc bandwidth*/
359 		range->min_kbps = range->max_kbps;
360 		range->min_target_bpp_x16 = range->max_target_bpp_x16;
361 	}
362 }
363 
364 
365 /* Decides if DSC should be used and calculates target bpp if it should, applying DSC policy.
366  *
367  * Returns:
368  *     - 'true' if DSC was required by policy and was successfully applied
369  *     - 'false' if DSC was not necessary (e.g. if uncompressed stream fits 'target_bandwidth_kbps'),
370  *        or if it couldn't be applied based on DSC policy.
371  */
decide_dsc_target_bpp_x16(const struct dc_dsc_policy * policy,const struct dsc_enc_caps * dsc_common_caps,const int target_bandwidth_kbps,const struct dc_crtc_timing * timing,int * target_bpp_x16)372 static bool decide_dsc_target_bpp_x16(
373 		const struct dc_dsc_policy *policy,
374 		const struct dsc_enc_caps *dsc_common_caps,
375 		const int target_bandwidth_kbps,
376 		const struct dc_crtc_timing *timing,
377 		int *target_bpp_x16)
378 {
379 	bool should_use_dsc = false;
380 	struct dc_dsc_bw_range range;
381 
382 	memset(&range, 0, sizeof(range));
383 
384 	get_dsc_bandwidth_range(policy->min_target_bpp, policy->max_target_bpp,
385 			dsc_common_caps, timing, &range);
386 	if (target_bandwidth_kbps >= range.stream_kbps) {
387 		/* enough bandwidth without dsc */
388 		*target_bpp_x16 = 0;
389 		should_use_dsc = false;
390 	} else if (target_bandwidth_kbps >= range.max_kbps) {
391 		/* use max target bpp allowed */
392 		*target_bpp_x16 = range.max_target_bpp_x16;
393 		should_use_dsc = true;
394 	} else if (target_bandwidth_kbps >= range.min_kbps) {
395 		/* use target bpp that can take entire target bandwidth */
396 		*target_bpp_x16 = calc_dsc_bpp_x16(target_bandwidth_kbps, timing->pix_clk_100hz, dsc_common_caps->bpp_increment_div);
397 		should_use_dsc = true;
398 	} else {
399 		/* not enough bandwidth to fulfill minimum requirement */
400 		*target_bpp_x16 = 0;
401 		should_use_dsc = false;
402 	}
403 
404 	return should_use_dsc;
405 }
406 
407 #define MIN_AVAILABLE_SLICES_SIZE  4
408 
get_available_dsc_slices(union dsc_enc_slice_caps slice_caps,int * available_slices)409 static int get_available_dsc_slices(union dsc_enc_slice_caps slice_caps, int *available_slices)
410 {
411 	int idx = 0;
412 
413 	memset(available_slices, -1, MIN_AVAILABLE_SLICES_SIZE);
414 
415 	if (slice_caps.bits.NUM_SLICES_1)
416 		available_slices[idx++] = 1;
417 
418 	if (slice_caps.bits.NUM_SLICES_2)
419 		available_slices[idx++] = 2;
420 
421 	if (slice_caps.bits.NUM_SLICES_4)
422 		available_slices[idx++] = 4;
423 
424 	if (slice_caps.bits.NUM_SLICES_8)
425 		available_slices[idx++] = 8;
426 
427 	return idx;
428 }
429 
430 
get_max_dsc_slices(union dsc_enc_slice_caps slice_caps)431 static int get_max_dsc_slices(union dsc_enc_slice_caps slice_caps)
432 {
433 	int max_slices = 0;
434 	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
435 	int end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
436 
437 	if (end_idx > 0)
438 		max_slices = available_slices[end_idx - 1];
439 
440 	return max_slices;
441 }
442 
443 
444 // Increment sice number in available sice numbers stops if possible, or just increment if not
inc_num_slices(union dsc_enc_slice_caps slice_caps,int num_slices)445 static int inc_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
446 {
447 	// Get next bigger num slices available in common caps
448 	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
449 	int end_idx;
450 	int i;
451 	int new_num_slices = num_slices;
452 
453 	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
454 	if (end_idx == 0) {
455 		// No available slices found
456 		new_num_slices++;
457 		return new_num_slices;
458 	}
459 
460 	// Numbers of slices found - get the next bigger number
461 	for (i = 0; i < end_idx; i++) {
462 		if (new_num_slices < available_slices[i]) {
463 			new_num_slices = available_slices[i];
464 			break;
465 		}
466 	}
467 
468 	if (new_num_slices == num_slices) // No biger number of slices found
469 		new_num_slices++;
470 
471 	return new_num_slices;
472 }
473 
474 
475 // Decrement sice number in available sice numbers stops if possible, or just decrement if not. Stop at zero.
dec_num_slices(union dsc_enc_slice_caps slice_caps,int num_slices)476 static int dec_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
477 {
478 	// Get next bigger num slices available in common caps
479 	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
480 	int end_idx;
481 	int i;
482 	int new_num_slices = num_slices;
483 
484 	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
485 	if (end_idx == 0 && new_num_slices > 0) {
486 		// No numbers of slices found
487 		new_num_slices++;
488 		return new_num_slices;
489 	}
490 
491 	// Numbers of slices found - get the next smaller number
492 	for (i = end_idx - 1; i >= 0; i--) {
493 		if (new_num_slices > available_slices[i]) {
494 			new_num_slices = available_slices[i];
495 			break;
496 		}
497 	}
498 
499 	if (new_num_slices == num_slices) {
500 		// No smaller number of slices found
501 		new_num_slices--;
502 		if (new_num_slices < 0)
503 			new_num_slices = 0;
504 	}
505 
506 	return new_num_slices;
507 }
508 
509 
510 // Choose next bigger number of slices if the requested number of slices is not available
fit_num_slices_up(union dsc_enc_slice_caps slice_caps,int num_slices)511 static int fit_num_slices_up(union dsc_enc_slice_caps slice_caps, int num_slices)
512 {
513 	// Get next bigger num slices available in common caps
514 	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
515 	int end_idx;
516 	int i;
517 	int new_num_slices = num_slices;
518 
519 	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
520 	if (end_idx == 0) {
521 		// No available slices found
522 		new_num_slices++;
523 		return new_num_slices;
524 	}
525 
526 	// Numbers of slices found - get the equal or next bigger number
527 	for (i = 0; i < end_idx; i++) {
528 		if (new_num_slices <= available_slices[i]) {
529 			new_num_slices = available_slices[i];
530 			break;
531 		}
532 	}
533 
534 	return new_num_slices;
535 }
536 
537 
538 /* Attempts to set DSC configuration for the stream, applying DSC policy.
539  * Returns 'true' if successful or 'false' if not.
540  *
541  * Parameters:
542  *
543  * dsc_sink_caps       - DSC sink decoder capabilities (from DPCD)
544  *
545  * dsc_enc_caps        - DSC encoder capabilities
546  *
547  * target_bandwidth_kbps  - Target bandwidth to fit the stream into.
548  *                          If 0, do not calculate target bpp.
549  *
550  * timing              - The stream timing to fit into 'target_bandwidth_kbps' or apply
551  *                       maximum compression to, if 'target_badwidth == 0'
552  *
553  * dsc_cfg             - DSC configuration to use if it was possible to come up with
554  *                       one for the given inputs.
555  *                       The target bitrate after DSC can be calculated by multiplying
556  *                       dsc_cfg.bits_per_pixel (in U6.4 format) by pixel rate, e.g.
557  *
558  *                       dsc_stream_bitrate_kbps = (int)ceil(timing->pix_clk_khz * dsc_cfg.bits_per_pixel / 16.0);
559  */
setup_dsc_config(const struct dsc_dec_dpcd_caps * dsc_sink_caps,const struct dsc_enc_caps * dsc_enc_caps,int target_bandwidth_kbps,const struct dc_crtc_timing * timing,int min_slice_height_override,struct dc_dsc_config * dsc_cfg)560 static bool setup_dsc_config(
561 		const struct dsc_dec_dpcd_caps *dsc_sink_caps,
562 		const struct dsc_enc_caps *dsc_enc_caps,
563 		int target_bandwidth_kbps,
564 		const struct dc_crtc_timing *timing,
565 		int min_slice_height_override,
566 		struct dc_dsc_config *dsc_cfg)
567 {
568 	struct dsc_enc_caps dsc_common_caps;
569 	int max_slices_h;
570 	int min_slices_h;
571 	int num_slices_h;
572 	int pic_width;
573 	int slice_width;
574 	int target_bpp;
575 	int sink_per_slice_throughput_mps;
576 	int branch_max_throughput_mps = 0;
577 	bool is_dsc_possible = false;
578 	int pic_height;
579 	int slice_height;
580 	struct dc_dsc_policy policy;
581 
582 	memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));
583 
584 	dc_dsc_get_policy_for_timing(timing, &policy);
585 	pic_width = timing->h_addressable + timing->h_border_left + timing->h_border_right;
586 	pic_height = timing->v_addressable + timing->v_border_top + timing->v_border_bottom;
587 
588 	if (!dsc_sink_caps->is_dsc_supported)
589 		goto done;
590 
591 	if (dsc_sink_caps->branch_max_line_width && dsc_sink_caps->branch_max_line_width < pic_width)
592 		goto done;
593 
594 	// Intersect decoder with encoder DSC caps and validate DSC settings
595 	is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, dsc_enc_caps, timing->pixel_encoding, &dsc_common_caps);
596 	if (!is_dsc_possible)
597 		goto done;
598 
599 	if (target_bandwidth_kbps > 0) {
600 		is_dsc_possible = decide_dsc_target_bpp_x16(
601 				&policy,
602 				&dsc_common_caps,
603 				target_bandwidth_kbps,
604 				timing,
605 				&target_bpp);
606 		dsc_cfg->bits_per_pixel = target_bpp;
607 	}
608 	if (!is_dsc_possible)
609 		goto done;
610 
611 	sink_per_slice_throughput_mps = 0;
612 
613 	// Validate available DSC settings against the mode timing
614 
615 	// Validate color format (and pick up the throughput values)
616 	dsc_cfg->ycbcr422_simple = false;
617 	switch (timing->pixel_encoding)	{
618 	case PIXEL_ENCODING_RGB:
619 		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.RGB;
620 		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
621 		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
622 		break;
623 	case PIXEL_ENCODING_YCBCR444:
624 		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_444;
625 		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
626 		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
627 		break;
628 	case PIXEL_ENCODING_YCBCR422:
629 		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_422;
630 		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
631 		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
632 		if (!is_dsc_possible) {
633 			is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_SIMPLE_422;
634 			dsc_cfg->ycbcr422_simple = is_dsc_possible;
635 			sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
636 		}
637 		break;
638 	case PIXEL_ENCODING_YCBCR420:
639 		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_420;
640 		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
641 		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
642 		break;
643 	default:
644 		is_dsc_possible = false;
645 	}
646 
647 	// Validate branch's maximum throughput
648 	if (branch_max_throughput_mps && dsc_div_by_10_round_up(timing->pix_clk_100hz) > branch_max_throughput_mps * 1000)
649 		is_dsc_possible = false;
650 
651 	if (!is_dsc_possible)
652 		goto done;
653 
654 	// Color depth
655 	switch (timing->display_color_depth) {
656 	case COLOR_DEPTH_888:
657 		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_8_BPC;
658 		break;
659 	case COLOR_DEPTH_101010:
660 		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_10_BPC;
661 		break;
662 	case COLOR_DEPTH_121212:
663 		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_12_BPC;
664 		break;
665 	default:
666 		is_dsc_possible = false;
667 	}
668 
669 	if (!is_dsc_possible)
670 		goto done;
671 
672 	// Slice width (i.e. number of slices per line)
673 	max_slices_h = get_max_dsc_slices(dsc_common_caps.slice_caps);
674 
675 	while (max_slices_h > 0) {
676 		if (pic_width % max_slices_h == 0)
677 			break;
678 
679 		max_slices_h = dec_num_slices(dsc_common_caps.slice_caps, max_slices_h);
680 	}
681 
682 	is_dsc_possible = (dsc_common_caps.max_slice_width > 0);
683 	if (!is_dsc_possible)
684 		goto done;
685 
686 	min_slices_h = pic_width / dsc_common_caps.max_slice_width;
687 	if (pic_width % dsc_common_caps.max_slice_width)
688 		min_slices_h++;
689 
690 	min_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, min_slices_h);
691 
692 	while (min_slices_h <= max_slices_h) {
693 		int pix_clk_per_slice_khz = dsc_div_by_10_round_up(timing->pix_clk_100hz) / min_slices_h;
694 		if (pix_clk_per_slice_khz <= sink_per_slice_throughput_mps * 1000)
695 			break;
696 
697 		min_slices_h = inc_num_slices(dsc_common_caps.slice_caps, min_slices_h);
698 	}
699 
700 	if (pic_width % min_slices_h != 0)
701 		min_slices_h = 0; // DSC TODO: Maybe try increasing the number of slices first?
702 
703 	is_dsc_possible = (min_slices_h <= max_slices_h);
704 	if (!is_dsc_possible)
705 		goto done;
706 
707 	if (policy.use_min_slices_h) {
708 		if (min_slices_h > 0)
709 			num_slices_h = min_slices_h;
710 		else if (max_slices_h > 0) { // Fall back to max slices if min slices is not working out
711 			if (policy.max_slices_h)
712 				num_slices_h = min(policy.max_slices_h, max_slices_h);
713 			else
714 				num_slices_h = max_slices_h;
715 		} else
716 			is_dsc_possible = false;
717 	} else {
718 		if (max_slices_h > 0) {
719 			if (policy.max_slices_h)
720 				num_slices_h = min(policy.max_slices_h, max_slices_h);
721 			else
722 				num_slices_h = max_slices_h;
723 		} else if (min_slices_h > 0) // Fall back to min slices if max slices is not possible
724 			num_slices_h = min_slices_h;
725 		else
726 			is_dsc_possible = false;
727 	}
728 
729 	if (!is_dsc_possible)
730 		goto done;
731 
732 	dsc_cfg->num_slices_h = num_slices_h;
733 	slice_width = pic_width / num_slices_h;
734 
735 	is_dsc_possible = slice_width <= dsc_common_caps.max_slice_width;
736 	if (!is_dsc_possible)
737 		goto done;
738 
739 	// Slice height (i.e. number of slices per column): start with policy and pick the first one that height is divisible by.
740 	// For 4:2:0 make sure the slice height is divisible by 2 as well.
741 	if (min_slice_height_override == 0)
742 		slice_height = min(policy.min_slice_height, pic_height);
743 	else
744 		slice_height = min(min_slice_height_override, pic_height);
745 
746 	while (slice_height < pic_height && (pic_height % slice_height != 0 ||
747 		(timing->pixel_encoding == PIXEL_ENCODING_YCBCR420 && slice_height % 2 != 0)))
748 		slice_height++;
749 
750 	if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420) // For the case when pic_height < dsc_policy.min_sice_height
751 		is_dsc_possible = (slice_height % 2 == 0);
752 
753 	if (!is_dsc_possible)
754 		goto done;
755 
756 	dsc_cfg->num_slices_v = pic_height/slice_height;
757 
758 	// Final decission: can we do DSC or not?
759 	if (is_dsc_possible) {
760 		// Fill out the rest of DSC settings
761 		dsc_cfg->block_pred_enable = dsc_common_caps.is_block_pred_supported;
762 		dsc_cfg->linebuf_depth = dsc_common_caps.lb_bit_depth;
763 		dsc_cfg->version_minor = (dsc_common_caps.dsc_version & 0xf0) >> 4;
764 	}
765 
766 done:
767 	if (!is_dsc_possible)
768 		memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));
769 
770 	return is_dsc_possible;
771 }
772 
dc_dsc_parse_dsc_dpcd(const struct dc * dc,const uint8_t * dpcd_dsc_basic_data,const uint8_t * dpcd_dsc_ext_data,struct dsc_dec_dpcd_caps * dsc_sink_caps)773 bool dc_dsc_parse_dsc_dpcd(const struct dc *dc, const uint8_t *dpcd_dsc_basic_data, const uint8_t *dpcd_dsc_ext_data, struct dsc_dec_dpcd_caps *dsc_sink_caps)
774 {
775 	if (!dpcd_dsc_basic_data)
776 		return false;
777 
778 	dsc_sink_caps->is_dsc_supported = (dpcd_dsc_basic_data[DP_DSC_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_DECOMPRESSION_IS_SUPPORTED) != 0;
779 	if (!dsc_sink_caps->is_dsc_supported)
780 		return false;
781 
782 	dsc_sink_caps->dsc_version = dpcd_dsc_basic_data[DP_DSC_REV - DP_DSC_SUPPORT];
783 
784 	{
785 		int buff_block_size;
786 		int buff_size;
787 
788 		if (!dsc_buff_block_size_from_dpcd(dpcd_dsc_basic_data[DP_DSC_RC_BUF_BLK_SIZE - DP_DSC_SUPPORT], &buff_block_size))
789 			return false;
790 
791 		buff_size = dpcd_dsc_basic_data[DP_DSC_RC_BUF_SIZE - DP_DSC_SUPPORT] + 1;
792 		dsc_sink_caps->rc_buffer_size = buff_size * buff_block_size;
793 	}
794 
795 	dsc_sink_caps->slice_caps1.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_1 - DP_DSC_SUPPORT];
796 	if (!dsc_line_buff_depth_from_dpcd(dpcd_dsc_basic_data[DP_DSC_LINE_BUF_BIT_DEPTH - DP_DSC_SUPPORT], &dsc_sink_caps->lb_bit_depth))
797 		return false;
798 
799 	dsc_sink_caps->is_block_pred_supported =
800 		(dpcd_dsc_basic_data[DP_DSC_BLK_PREDICTION_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_BLK_PREDICTION_IS_SUPPORTED) != 0;
801 
802 	dsc_sink_caps->edp_max_bits_per_pixel =
803 		dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_LOW - DP_DSC_SUPPORT] |
804 		dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_HI - DP_DSC_SUPPORT] << 8;
805 
806 	dsc_sink_caps->color_formats.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_FORMAT_CAP - DP_DSC_SUPPORT];
807 	dsc_sink_caps->color_depth.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_DEPTH_CAP - DP_DSC_SUPPORT];
808 
809 	{
810 		int dpcd_throughput = dpcd_dsc_basic_data[DP_DSC_PEAK_THROUGHPUT - DP_DSC_SUPPORT];
811 
812 		if (!dsc_throughput_from_dpcd(dpcd_throughput & DP_DSC_THROUGHPUT_MODE_0_MASK, &dsc_sink_caps->throughput_mode_0_mps))
813 			return false;
814 
815 		dpcd_throughput = (dpcd_throughput & DP_DSC_THROUGHPUT_MODE_1_MASK) >> DP_DSC_THROUGHPUT_MODE_1_SHIFT;
816 		if (!dsc_throughput_from_dpcd(dpcd_throughput, &dsc_sink_caps->throughput_mode_1_mps))
817 			return false;
818 	}
819 
820 	dsc_sink_caps->max_slice_width = dpcd_dsc_basic_data[DP_DSC_MAX_SLICE_WIDTH - DP_DSC_SUPPORT] * 320;
821 	dsc_sink_caps->slice_caps2.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_2 - DP_DSC_SUPPORT];
822 
823 	if (!dsc_bpp_increment_div_from_dpcd(dpcd_dsc_basic_data[DP_DSC_BITS_PER_PIXEL_INC - DP_DSC_SUPPORT], &dsc_sink_caps->bpp_increment_div))
824 		return false;
825 
826 	if (dc->debug.dsc_bpp_increment_div) {
827 		/* dsc_bpp_increment_div should onl be 1, 2, 4, 8 or 16, but rather than rejecting invalid values,
828 		 * we'll accept all and get it into range. This also makes the above check against 0 redundant,
829 		 * but that one stresses out the override will be only used if it's not 0.
830 		 */
831 		if (dc->debug.dsc_bpp_increment_div >= 1)
832 			dsc_sink_caps->bpp_increment_div = 1;
833 		if (dc->debug.dsc_bpp_increment_div >= 2)
834 			dsc_sink_caps->bpp_increment_div = 2;
835 		if (dc->debug.dsc_bpp_increment_div >= 4)
836 			dsc_sink_caps->bpp_increment_div = 4;
837 		if (dc->debug.dsc_bpp_increment_div >= 8)
838 			dsc_sink_caps->bpp_increment_div = 8;
839 		if (dc->debug.dsc_bpp_increment_div >= 16)
840 			dsc_sink_caps->bpp_increment_div = 16;
841 	}
842 
843 	/* Extended caps */
844 	if (dpcd_dsc_ext_data == NULL) { // Extended DPCD DSC data can be null, e.g. because it doesn't apply to SST
845 		dsc_sink_caps->branch_overall_throughput_0_mps = 0;
846 		dsc_sink_caps->branch_overall_throughput_1_mps = 0;
847 		dsc_sink_caps->branch_max_line_width = 0;
848 		return true;
849 	}
850 
851 	dsc_sink_caps->branch_overall_throughput_0_mps = dpcd_dsc_ext_data[DP_DSC_BRANCH_OVERALL_THROUGHPUT_0 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
852 	if (dsc_sink_caps->branch_overall_throughput_0_mps == 0)
853 		dsc_sink_caps->branch_overall_throughput_0_mps = 0;
854 	else if (dsc_sink_caps->branch_overall_throughput_0_mps == 1)
855 		dsc_sink_caps->branch_overall_throughput_0_mps = 680;
856 	else {
857 		dsc_sink_caps->branch_overall_throughput_0_mps *= 50;
858 		dsc_sink_caps->branch_overall_throughput_0_mps += 600;
859 	}
860 
861 	dsc_sink_caps->branch_overall_throughput_1_mps = dpcd_dsc_ext_data[DP_DSC_BRANCH_OVERALL_THROUGHPUT_1 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
862 	if (dsc_sink_caps->branch_overall_throughput_1_mps == 0)
863 		dsc_sink_caps->branch_overall_throughput_1_mps = 0;
864 	else if (dsc_sink_caps->branch_overall_throughput_1_mps == 1)
865 		dsc_sink_caps->branch_overall_throughput_1_mps = 680;
866 	else {
867 		dsc_sink_caps->branch_overall_throughput_1_mps *= 50;
868 		dsc_sink_caps->branch_overall_throughput_1_mps += 600;
869 	}
870 
871 	dsc_sink_caps->branch_max_line_width = dpcd_dsc_ext_data[DP_DSC_BRANCH_MAX_LINE_WIDTH - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0] * 320;
872 	ASSERT(dsc_sink_caps->branch_max_line_width == 0 || dsc_sink_caps->branch_max_line_width >= 5120);
873 
874 	return true;
875 }
876 
877 
878 /* If DSC is possbile, get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range and
879  * timing's pixel clock and uncompressed bandwidth.
880  * If DSC is not possible, leave '*range' untouched.
881  */
dc_dsc_compute_bandwidth_range(const struct display_stream_compressor * dsc,const uint32_t dsc_min_slice_height_override,const uint32_t min_bpp,const uint32_t max_bpp,const struct dsc_dec_dpcd_caps * dsc_sink_caps,const struct dc_crtc_timing * timing,struct dc_dsc_bw_range * range)882 bool dc_dsc_compute_bandwidth_range(
883 		const struct display_stream_compressor *dsc,
884 		const uint32_t dsc_min_slice_height_override,
885 		const uint32_t min_bpp,
886 		const uint32_t max_bpp,
887 		const struct dsc_dec_dpcd_caps *dsc_sink_caps,
888 		const struct dc_crtc_timing *timing,
889 		struct dc_dsc_bw_range *range)
890 {
891 	bool is_dsc_possible = false;
892 	struct dsc_enc_caps dsc_enc_caps;
893 	struct dsc_enc_caps dsc_common_caps;
894 	struct dc_dsc_config config;
895 
896 	get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);
897 
898 	is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, &dsc_enc_caps,
899 			timing->pixel_encoding, &dsc_common_caps);
900 
901 	if (is_dsc_possible)
902 		is_dsc_possible = setup_dsc_config(dsc_sink_caps, &dsc_enc_caps, 0, timing,
903 				dsc_min_slice_height_override, &config);
904 
905 	if (is_dsc_possible)
906 		get_dsc_bandwidth_range(min_bpp, max_bpp, &dsc_common_caps, timing, range);
907 
908 	return is_dsc_possible;
909 }
910 
dc_dsc_compute_config(const struct display_stream_compressor * dsc,const struct dsc_dec_dpcd_caps * dsc_sink_caps,const uint32_t dsc_min_slice_height_override,uint32_t target_bandwidth_kbps,const struct dc_crtc_timing * timing,struct dc_dsc_config * dsc_cfg)911 bool dc_dsc_compute_config(
912 		const struct display_stream_compressor *dsc,
913 		const struct dsc_dec_dpcd_caps *dsc_sink_caps,
914 		const uint32_t dsc_min_slice_height_override,
915 		uint32_t target_bandwidth_kbps,
916 		const struct dc_crtc_timing *timing,
917 		struct dc_dsc_config *dsc_cfg)
918 {
919 	bool is_dsc_possible = false;
920 	struct dsc_enc_caps dsc_enc_caps;
921 
922 	get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);
923 	is_dsc_possible = setup_dsc_config(dsc_sink_caps,
924 			&dsc_enc_caps,
925 			target_bandwidth_kbps,
926 			timing, dsc_min_slice_height_override, dsc_cfg);
927 	return is_dsc_possible;
928 }
929 
dc_dsc_get_policy_for_timing(const struct dc_crtc_timing * timing,struct dc_dsc_policy * policy)930 void dc_dsc_get_policy_for_timing(const struct dc_crtc_timing *timing, struct dc_dsc_policy *policy)
931 {
932 	uint32_t bpc = 0;
933 
934 	policy->min_target_bpp = 0;
935 	policy->max_target_bpp = 0;
936 
937 	/* DSC Policy: Use minimum number of slices that fits the pixel clock */
938 	policy->use_min_slices_h = true;
939 
940 	/* DSC Policy: Use max available slices
941 	 * (in our case 4 for or 8, depending on the mode)
942 	 */
943 	policy->max_slices_h = 0;
944 
945 	/* DSC Policy: Use slice height recommended
946 	 * by VESA DSC Spreadsheet user guide
947 	 */
948 	policy->min_slice_height = 108;
949 
950 	/* DSC Policy: follow DP specs with an internal upper limit to 16 bpp
951 	 * for better interoperability
952 	 */
953 	switch (timing->display_color_depth) {
954 	case COLOR_DEPTH_888:
955 		bpc = 8;
956 		break;
957 	case COLOR_DEPTH_101010:
958 		bpc = 10;
959 		break;
960 	case COLOR_DEPTH_121212:
961 		bpc = 12;
962 		break;
963 	default:
964 		return;
965 	}
966 	switch (timing->pixel_encoding) {
967 	case PIXEL_ENCODING_RGB:
968 	case PIXEL_ENCODING_YCBCR444:
969 	case PIXEL_ENCODING_YCBCR422: /* assume no YCbCr422 native support */
970 		/* DP specs limits to 8 */
971 		policy->min_target_bpp = 8;
972 		/* DP specs limits to 3 x bpc */
973 		policy->max_target_bpp = 3 * bpc;
974 		break;
975 	case PIXEL_ENCODING_YCBCR420:
976 		/* DP specs limits to 6 */
977 		policy->min_target_bpp = 6;
978 		/* DP specs limits to 1.5 x bpc assume bpc is an even number */
979 		policy->max_target_bpp = bpc * 3 / 2;
980 		break;
981 	default:
982 		return;
983 	}
984 	/* internal upper limit, default 16 bpp */
985 	if (policy->max_target_bpp > dsc_policy_max_target_bpp_limit)
986 		policy->max_target_bpp = dsc_policy_max_target_bpp_limit;
987 }
988 
dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit)989 void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit)
990 {
991 	dsc_policy_max_target_bpp_limit = limit;
992 }
993