Contributors: 44
Author Tokens Token Proportion Commits Commit Proportion
Harry Wentland 6859 67.61% 8 8.89%
Wenjing Liu 853 8.41% 15 16.67%
Mark Morra 820 8.08% 1 1.11%
Dillon Varone 437 4.31% 4 4.44%
Jerry (Fangzhi) Zuo 211 2.08% 2 2.22%
Nikola Cornij 202 1.99% 9 10.00%
George Shen 178 1.75% 2 2.22%
Aurabindo Pillai 93 0.92% 4 4.44%
Mike Hsieh 78 0.77% 2 2.22%
Relja Vojvodic 35 0.34% 2 2.22%
Nasir Osman 31 0.31% 1 1.11%
Mikita Lipski 31 0.31% 1 1.11%
Bayan Zabihiyan 29 0.29% 1 1.11%
Joshua Aberback 29 0.29% 3 3.33%
Leo (Hanghong) Ma 27 0.27% 2 2.22%
Eryk Brol 24 0.24% 1 1.11%
Gaghik Khachatrian 23 0.23% 1 1.11%
Jose Fernandez 18 0.18% 1 1.11%
Ian Chen 18 0.18% 1 1.11%
Alex Deucher 16 0.16% 1 1.11%
Jimmy Kizito 16 0.16% 1 1.11%
Ryan Seto 13 0.13% 1 1.11%
Alvin lee 12 0.12% 2 2.22%
Shirish S 10 0.10% 1 1.11%
Dmytro Laktyushkin 10 0.10% 1 1.11%
Chris Park 8 0.08% 1 1.11%
Roman Li 7 0.07% 2 2.22%
Vitaly Prosyak 6 0.06% 1 1.11%
Ilya Bakoulin 6 0.06% 2 2.22%
Josip Pavic 6 0.06% 1 1.11%
Eric Yang 6 0.06% 2 2.22%
Aric Cyr 5 0.05% 1 1.11%
David Francis 5 0.05% 1 1.11%
Nicholas Kazlauskas 4 0.04% 1 1.11%
Thomas Zimmermann 4 0.04% 1 1.11%
Ken Chalmers 3 0.03% 1 1.11%
Dominik Kaszewski 3 0.03% 1 1.11%
pengfuyuan 2 0.02% 1 1.11%
rodrigosiqueira 2 0.02% 1 1.11%
Jun Lei 1 0.01% 1 1.11%
Jaehyun Chung 1 0.01% 1 1.11%
Clay King 1 0.01% 1 1.11%
Runrun Liu 1 0.01% 1 1.11%
Bhavin Sharma 1 0.01% 1 1.11%
Total 10145 90 


/*
 * Copyright 2019 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Author: AMD
 */

#include <drm/display/drm_dp_helper.h>
#include <drm/display/drm_dsc_helper.h>
#include "dc_hw_types.h"
#include "dsc.h"
#include "dc.h"
#include "rc_calc.h"
#include "fixed31_32.h"

#include "clk_mgr.h"
#include "resource.h"

#define DC_LOGGER \
	dsc->ctx->logger

/* This module's internal functions */

/* default DSC policy target bitrate limit is 16bpp */
static uint32_t dsc_policy_max_target_bpp_limit = 16;

/* default DSC policy enables DSC only when needed */
static bool dsc_policy_enable_dsc_when_not_needed;

static bool dsc_policy_disable_dsc_stream_overhead;

static bool disable_128b_132b_stream_overhead;

#ifndef MAX
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
#endif
#ifndef MIN
#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
#endif

/* Need to account for padding due to pixel-to-symbol packing
 * for uncompressed 128b/132b streams.
 */
static uint32_t apply_128b_132b_stream_overhead(
	const struct dc_crtc_timing *timing, const uint32_t kbps)
{
	uint32_t total_kbps = kbps;

	if (disable_128b_132b_stream_overhead)
		return kbps;

	if (!timing->flags.DSC) {
		struct fixed31_32 bpp;
		struct fixed31_32 overhead_factor;

		bpp = dc_fixpt_from_int(kbps);
		bpp = dc_fixpt_div_int(bpp, timing->pix_clk_100hz / 10);

		/* Symbols_per_HActive = HActive * bpp / (4 lanes * 32-bit symbol size)
		 * Overhead_factor = ceil(Symbols_per_HActive) / Symbols_per_HActive
		 */
		overhead_factor = dc_fixpt_from_int(timing->h_addressable);
		overhead_factor = dc_fixpt_mul(overhead_factor, bpp);
		overhead_factor = dc_fixpt_div_int(overhead_factor, 128);
		overhead_factor = dc_fixpt_div(
			dc_fixpt_from_int(dc_fixpt_ceil(overhead_factor)),
			overhead_factor);

		total_kbps = dc_fixpt_ceil(
			dc_fixpt_mul_int(overhead_factor, total_kbps));
	}

	return total_kbps;
}

uint32_t dc_bandwidth_in_kbps_from_timing(
	const struct dc_crtc_timing *timing,
	const enum dc_link_encoding_format link_encoding)
{
	uint32_t bits_per_channel = 0;
	uint32_t kbps;

	if (timing->flags.DSC)
		return dc_dsc_stream_bandwidth_in_kbps(timing,
				timing->dsc_cfg.bits_per_pixel,
				timing->dsc_cfg.num_slices_h,
				timing->dsc_cfg.is_dp);

	switch (timing->display_color_depth) {
	case COLOR_DEPTH_666:
		bits_per_channel = 6;
		break;
	case COLOR_DEPTH_888:
		bits_per_channel = 8;
		break;
	case COLOR_DEPTH_101010:
		bits_per_channel = 10;
		break;
	case COLOR_DEPTH_121212:
		bits_per_channel = 12;
		break;
	case COLOR_DEPTH_141414:
		bits_per_channel = 14;
		break;
	case COLOR_DEPTH_161616:
		bits_per_channel = 16;
		break;
	default:
		ASSERT(bits_per_channel != 0);
		bits_per_channel = 8;
		break;
	}

	kbps = timing->pix_clk_100hz / 10;
	kbps *= bits_per_channel;

	if (timing->flags.Y_ONLY != 1) {
		/*Only YOnly make reduce bandwidth by 1/3 compares to RGB*/
		kbps *= 3;
		if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
			kbps /= 2;
		else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422)
			kbps = kbps * 2 / 3;
	}

	if (link_encoding == DC_LINK_ENCODING_DP_128b_132b)
		kbps = apply_128b_132b_stream_overhead(timing, kbps);

	if (link_encoding == DC_LINK_ENCODING_HDMI_FRL &&
			timing->vic == 0 && timing->hdmi_vic == 0 &&
			timing->frl_uncompressed_video_bandwidth_in_kbps != 0)
		kbps = timing->frl_uncompressed_video_bandwidth_in_kbps;

	return kbps;
}

const struct dc_dsc_primary_bpp prim_bpp_444[] = {
	/* VIC/BPP */
	{64,  192}, /* 1920x1080 @ 100 */
	{77,  192}, /* 1920x1080 @ 100 */
	{63,  192}, /* 1920x1080 @ 120 */
	{78,  192}, /* 1920x1080 @ 120 */
	{93,  192}, /* 3840x2160 @ 24 */
	{103, 192}, /* 3840x2160 @ 24 */
	{94,  192}, /* 3840x2160 @ 25 */
	{104, 192}, /* 3840x2160 @ 25 */
	{95,  192}, /* 3840x2160 @ 30 */
	{105, 192}, /* 3840x2160 @ 30 */
	{114, 192}, /* 3840x2160 @ 48 */
	{116, 192}, /* 3840x2160 @ 48 */
	{96,  192}, /* 3840x2160 @ 50 */
	{106, 192}, /* 3840x2160 @ 50 */
	{97,  192}, /* 3840x2160 @ 60 */
	{107, 192}, /* 3840x2160 @ 60 */
	{117, 192}, /* 3840x2160 @ 100 */
	{119, 192}, /* 3840x2160 @ 100 */
	{118, 192}, /* 3840x2160 @ 120 */
	{120, 192}, /* 3840x2160 @ 120 */
	{98,  192}, /* 4096x2160 @ 24 */
	{99,  192}, /* 4096x2160 @ 25 */
	{100, 192}, /* 4096x2160 @ 30 */
	{115, 192}, /* 4096x2160 @ 48 */
	{101, 192}, /* 4096x2160 @ 50 */
	{102, 192}, /* 4096x2160 @ 60 */
	{218, 192}, /* 4096x2160 @ 100 */
	{219, 192}, /* 4096x2160 @ 120 */
	{121, 192}, /* 5120x2160 @ 24 */
	{122, 192}, /* 5120x2160 @ 25 */
	{123, 192}, /* 5120x2160 @ 30 */
	{124, 192}, /* 5120x2160 @ 48 */
	{125, 192}, /* 5120x2160 @ 50 */
	{126, 173}, /* 5120x2160 @ 60 */
	{127, 192}, /* 5120x2160 @ 100 */
	{193, 175}, /* 5120x2160 @ 120 */
	{194, 192}, /* 7680x2160 @ 24 */
	{202, 192}, /* 7680x2160 @ 24 */
	{195, 192}, /* 7680x2160 @ 25 */
	{203, 192}, /* 7680x2160 @ 25 */
	{196, 192}, /* 7680x2160 @ 30 */
	{204, 192}, /* 7680x2160 @ 30 */
	{197, 157}, /* 7680x2160 @ 48 */
	{205, 157}, /* 7680x2160 @ 48 */
	{198, 157}, /* 7680x2160 @ 50 */
	{206, 157}, /* 7680x2160 @ 50 */
	{199, 159}, /* 7680x2160 @ 60 */
	{207, 159}, /* 7680x2160 @ 60 */
	{200, 134}, /* 7680x2160 @ 100 */
	{208, 134}, /* 7680x2160 @ 100 */
	{201, 130}, /* 7680x2160 @ 120 */
	{209, 130}, /* 7680x2160 @ 120 */
	{210, 182}, /* 10240x4320 @ 24 */
	{211, 181}, /* 10240x4320 @ 25 */
	{212, 177}, /* 10240x4320 @ 30 */
	{213, 163}, /* 10240x4320 @ 48 */
	{214, 162}, /* 10240x4320 @ 50 */
	{215, 157}, /* 10240x4320 @ 60 */
};
const struct dc_dsc_primary_bpp prim_bpp_422[] = {
	/* VIC/BPP */
	{114, 192}, /* 3840x2160 @ 48 */
	{116, 192}, /* 3840x2160 @ 48 */
	{96,  192}, /* 3840x2160 @ 50 */
	{106, 192}, /* 3840x2160 @ 50 */
	{97,  192}, /* 3840x2160 @ 60 */
	{107, 192}, /* 3840x2160 @ 60 */
	{117, 137}, /* 3840x2160 @ 100 */
	{119, 137}, /* 3840x2160 @ 100 */
	{118, 113}, /* 3840x2160 @ 120 */
	{120, 113}, /* 3840x2160 @ 120 */
	{115, 192}, /* 4096x2160 @ 48 */
	{101, 192}, /* 4096x2160 @ 50 */
	{102, 192}, /* 4096x2160 @ 60 */
	{218, 192}, /* 4096x2160 @ 100 */
	{219, 192}, /* 4096x2160 @ 120 */
	{121, 192}, /* 5120x2160 @ 24 */
	{122, 192}, /* 5120x2160 @ 25 */
	{123, 192}, /* 5120x2160 @ 30 */
	{124, 192}, /* 5120x2160 @ 48 */
	{125, 192}, /* 5120x2160 @ 50 */
	{126, 173}, /* 5120x2160 @ 60 */
	{127, 192}, /* 5120x2160 @ 100 */
	{193, 175}, /* 5120x2160 @ 120 */
	{194, 123}, /* 7680x2160 @ 24 */
	{202, 123}, /* 7680x2160 @ 24 */
	{195, 123}, /* 7680x2160 @ 25 */
	{203, 123}, /* 7680x2160 @ 25 */
	{196, 118}, /* 7680x2160 @ 30 */
	{204, 118}, /* 7680x2160 @ 30 */
	{197, 123}, /* 7680x2160 @ 48 */
	{205, 123}, /* 7680x2160 @ 48 */
	{198, 123}, /* 7680x2160 @ 50 */
	{206, 123}, /* 7680x2160 @ 50 */
	{199, 119}, /* 7680x2160 @ 60 */
	{207, 119}, /* 7680x2160 @ 60 */
	{200, 134}, /* 7680x2160 @ 100 */
	{208, 134}, /* 7680x2160 @ 100 */
	{201, 130}, /* 7680x2160 @ 120 */
	{209, 130}, /* 7680x2160 @ 120 */
	{210, 182}, /* 10240x4320 @ 24 */
	{211, 181}, /* 10240x4320 @ 25 */
	{212, 177}, /* 10240x4320 @ 30 */
	{213, 126}, /* 10240x4320 @ 48 */
	{214, 125}, /* 10240x4320 @ 50 */
	{215, 117}, /* 10240x4320 @ 60 */
	{216, 125}, /* 10240x4320 @ 100 */
	{217, 117}, /* 10240x4320 @ 120 */
};

const struct dc_dsc_primary_bpp prim_bpp_420[] = {
	/* VIC/BPP */
	{114, 192}, /* 3840x2160 @ 48 */
	{116, 192}, /* 3840x2160 @ 48 */
	{96,  192}, /* 3840x2160 @ 50 */
	{106, 192}, /* 3840x2160 @ 50 */
	{97,  192}, /* 3840x2160 @ 60 */
	{107, 192}, /* 3840x2160 @ 60 */
	{117, 137}, /* 3840x2160 @ 100 */
	{119, 137}, /* 3840x2160 @ 100 */
	{118, 113}, /* 3840x2160 @ 120 */
	{120, 113}, /* 3840x2160 @ 120 */
	{115, 192}, /* 4096x2160 @ 48 */
	{101, 192}, /* 4096x2160 @ 50 */
	{102, 192}, /* 4096x2160 @ 60 */
	{218, 129}, /* 4096x2160 @ 100 */
	{219, 106}, /* 4096x2160 @ 120 */
	{124, 192}, /* 5120x2160 @ 48 */
	{125, 192}, /* 5120x2160 @ 50 */
	{126, 173}, /* 5120x2160 @ 60 */
	{127, 192}, /* 5120x2160 @ 100 */
	{193, 175}, /* 5120x2160 @ 120 */
	{194, 123}, /* 7680x4320 @ 24 */
	{202, 123}, /* 7680x4320 @ 24 */
	{195, 123}, /* 7680x4320 @ 25 */
	{203, 123}, /* 7680x4320 @ 25 */
	{196, 118}, /* 7680x4320 @ 30 */
	{204, 118}, /* 7680x4320 @ 30 */
	{197, 123}, /* 7680x4320 @ 48 */
	{205, 123}, /* 7680x4320 @ 48 */
	{198, 123}, /* 7680x4320 @ 50 */
	{206, 123}, /* 7680x4320 @ 50 */
	{199, 119}, /* 7680x4320 @ 60 */
	{207, 119}, /* 7680x4320 @ 60 */
	{200, 112}, /* 7680x4320 @ 100 */
	{208, 112}, /* 7680x4320 @ 100 */
	{201, 103}, /* 7680x4320 @ 120 */
	{209, 103}, /* 7680x4320 @ 120 */
	{210,  98}, /* 10240x4320 @ 24 */
	{211,  98}, /* 10240x4320 @ 25 */
	{212, 177}, /* 10240x4320 @ 30 */
	{213,  98}, /* 10240x4320 @ 48 */
	{214, 125}, /* 10240x4320 @ 50 */
	{215, 117}, /* 10240x4320 @ 60 */
	{216, 107}, /* 10240x4320 @ 100 */
	{217,  97}, /* 10240x4320 @ 120 */
};

/* Forward Declerations */
static unsigned int get_min_dsc_slice_count_for_odm(
		const struct display_stream_compressor *dsc,
		const struct dsc_enc_caps *dsc_enc_caps,
		const struct dc_crtc_timing *timing);

static bool decide_dsc_bandwidth_range(
		const uint32_t min_bpp_x16,
		const uint32_t max_bpp_x16,
		const uint32_t num_slices_h,
		const struct dsc_enc_caps *dsc_caps,
		const struct dc_crtc_timing *timing,
		const enum dc_link_encoding_format link_encoding,
		struct dc_dsc_bw_range *range);

static uint32_t compute_bpp_x16_from_target_bandwidth(
		const uint32_t bandwidth_in_kbps,
		const struct dc_crtc_timing *timing,
		const uint32_t num_slices_h,
		const uint32_t bpp_increment_div,
		const bool is_dp);

static void get_dsc_enc_caps(
		const struct display_stream_compressor *dsc,
		struct dsc_enc_caps *dsc_enc_caps,
		int pixel_clock_100Hz);

static bool 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);

static bool 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,
		const struct dc_dsc_config_options *options,
		const enum dc_link_encoding_format link_encoding,
		int min_slice_count,
		struct dc_dsc_config *dsc_cfg);

static bool convert_bandwidth_to_frl_params(
	int bandwidth_kbps,
	int *num_lanes,
	int *frl_rate);

static uint32_t compute_bpp_x16_from_frl_params(
		const struct dc_crtc_timing *timing,
		const uint32_t num_slices_h,
		const struct dsc_enc_caps *dsc_caps);
static bool dsc_buff_block_size_from_dpcd(int dpcd_buff_block_size, int *buff_block_size)
{

	switch (dpcd_buff_block_size) {
	case DP_DSC_RC_BUF_BLK_SIZE_1:
		*buff_block_size = 1024;
		break;
	case DP_DSC_RC_BUF_BLK_SIZE_4:
		*buff_block_size = 4 * 1024;
		break;
	case DP_DSC_RC_BUF_BLK_SIZE_16:
		*buff_block_size = 16 * 1024;
		break;
	case DP_DSC_RC_BUF_BLK_SIZE_64:
		*buff_block_size = 64 * 1024;
		break;
	default: {
			dm_error("%s: DPCD DSC buffer size not recognized.\n", __func__);
			return false;
		}
	}

	return true;
}


static bool dsc_line_buff_depth_from_dpcd(int dpcd_line_buff_bit_depth, int *line_buff_bit_depth)
{
	if (0 <= dpcd_line_buff_bit_depth && dpcd_line_buff_bit_depth <= 7)
		*line_buff_bit_depth = dpcd_line_buff_bit_depth + 9;
	else if (dpcd_line_buff_bit_depth == 8)
		*line_buff_bit_depth = 8;
	else {
		dm_error("%s: DPCD DSC buffer depth not recognized.\n", __func__);
		return false;
	}

	return true;
}


static bool dsc_throughput_from_dpcd(int dpcd_throughput, int *throughput)
{
	switch (dpcd_throughput) {
	case DP_DSC_THROUGHPUT_MODE_0_UNSUPPORTED:
		*throughput = 0;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_170:
		*throughput = 170;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_340:
		*throughput = 340;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_400:
		*throughput = 400;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_450:
		*throughput = 450;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_500:
		*throughput = 500;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_550:
		*throughput = 550;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_600:
		*throughput = 600;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_650:
		*throughput = 650;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_700:
		*throughput = 700;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_750:
		*throughput = 750;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_800:
		*throughput = 800;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_850:
		*throughput = 850;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_900:
		*throughput = 900;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_950:
		*throughput = 950;
		break;
	case DP_DSC_THROUGHPUT_MODE_0_1000:
		*throughput = 1000;
		break;
	default: {
			dm_error("%s: DPCD DSC throughput mode not recognized.\n", __func__);
			return false;
		}
	}

	return true;
}


static bool dsc_bpp_increment_div_from_dpcd(uint8_t bpp_increment_dpcd, uint32_t *bpp_increment_div)
{
	// Mask bpp increment dpcd field to avoid reading other fields
	bpp_increment_dpcd &= 0x7;

	switch (bpp_increment_dpcd) {
	case 0:
		*bpp_increment_div = 16;
		break;
	case 1:
		*bpp_increment_div = 8;
		break;
	case 2:
		*bpp_increment_div = 4;
		break;
	case 3:
		*bpp_increment_div = 2;
		break;
	case 4:
		*bpp_increment_div = 1;
		break;
	default: {
		dm_error("%s: DPCD DSC bits-per-pixel increment not recognized.\n", __func__);
		return false;
	}
	}

	return true;
}



static bool get_vic_preset_bpp(
		const struct dc_crtc_timing *timing,
		int *preset_bpp)
{
	bool preset_found = false;
	uint32_t table_size_444 = ARRAY_SIZE(prim_bpp_444);
	uint32_t table_size_422 = ARRAY_SIZE(prim_bpp_422);
	uint32_t table_size_420 = ARRAY_SIZE(prim_bpp_420);
	uint32_t i;
	uint32_t vid_id;

	if (timing->vic == 0 && timing->hdmi_vic == 0)
		return false;

	vid_id = timing->vic;
	switch (timing->hdmi_vic) {
	case 1:
		vid_id = 95;
		break;
	case 2:
		vid_id = 94;
		break;
	case 3:
		vid_id = 93;
		break;
	case 4:
		vid_id = 98;
		break;
	default:
		break;
	}

	if (timing->pixel_encoding == PIXEL_ENCODING_RGB ||
			timing->pixel_encoding == PIXEL_ENCODING_YCBCR444) {
		for (i = 0; i < table_size_444 ; i++) {
			if (prim_bpp_444[i].vic == vid_id) {
				preset_found = true;
				*preset_bpp = prim_bpp_444[i].target_bpp;
				break;
			}
		}
	} else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422) {
		for (i = 0; i < table_size_422 ; i++) {
			if (prim_bpp_422[i].vic == vid_id) {
				preset_found = true;
				*preset_bpp = prim_bpp_422[i].target_bpp;
				break;
			}
		}
	} else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420) {
		for (i = 0; i < table_size_420 ; i++) {
			if (prim_bpp_420[i].vic == vid_id) {
				preset_found = true;
				*preset_bpp = prim_bpp_420[i].target_bpp;
				break;
			}
		}
	} else {
		return false;
	}

	return preset_found;
}

static int hdmi_dsc_get_num_slices(const struct dc_crtc_timing *timing)
{
	int k_slice_adjust = 1;
	int adj_pix_clk_mhz;
	int min_slices;
	int slice_target;
	int slice_width = timing->h_addressable;
	int h_ratio_adj_pix_clk_mhz;

	if (timing->pixel_encoding == PIXEL_ENCODING_RGB ||
			timing->pixel_encoding == PIXEL_ENCODING_YCBCR444)
		k_slice_adjust = 2;

	adj_pix_clk_mhz = k_slice_adjust * timing->pix_clk_100hz / 10000 / 2;
	h_ratio_adj_pix_clk_mhz = adj_pix_clk_mhz * timing->h_addressable / timing->h_total;
	if (adj_pix_clk_mhz <= 2720) {
		min_slices = adj_pix_clk_mhz / 340;
		if (adj_pix_clk_mhz % 340 != 0)
			min_slices++;
	} else if (adj_pix_clk_mhz <= 4800) {
		min_slices = adj_pix_clk_mhz / 400;
		if (adj_pix_clk_mhz % 400 != 0)
			min_slices++;
	} else if (h_ratio_adj_pix_clk_mhz <= 4800) {
		min_slices = h_ratio_adj_pix_clk_mhz / 600;
		if (h_ratio_adj_pix_clk_mhz % 600 != 0)
			min_slices++;
	} else {
		min_slices = h_ratio_adj_pix_clk_mhz / 900;
		if (h_ratio_adj_pix_clk_mhz % 900 != 0)
			min_slices++;
	}

	do {
		if (min_slices <= 1)
			slice_target = 1;
		else if (min_slices <= 2)
			slice_target = 2;
		else if (min_slices <= 4)
			slice_target = 4;
		else if (min_slices <= 8)
			slice_target = 8;
		else if (min_slices <= 12)
			slice_target = 12;
		else if (min_slices <= 16)
			slice_target = 16;
		else
			return 0;

		slice_width = timing->h_addressable / slice_target;
		min_slices++;
	} while (slice_width > 2720);

	return slice_target;
}

static int hdmi_dsc_get_bpp(const struct dc_crtc_timing *timing,
		const struct dsc_enc_caps *dsc_common_caps)
{
	int max_dsc_bpp, min_dsc_bpp;
	int target_bytes;
	bool bpp_found = false;
	int bpp_decrement_x16;
	int src_fractional_bpp = dsc_common_caps->bpp_increment_div;
	int bpp_target;
	int bpp_target_x16;
	int bpc_factor = 8;
	int slice_width;
	int num_slices;
	bool hdmi_all_bpp = dsc_common_caps->is_vic_all_bpp;
	int hdmi_max_chunk_bytes = dsc_common_caps->total_chunk_kbytes;

	int preset_bpp;
	bool preset_found = false;

	if (timing->display_color_depth == COLOR_DEPTH_101010)
		bpc_factor = 10;
	if (timing->display_color_depth == COLOR_DEPTH_121212)
		bpc_factor = 12;

	/* Assuming: bpc as 8*/
	if (timing->pixel_encoding == PIXEL_ENCODING_RGB ||
			timing->pixel_encoding == PIXEL_ENCODING_YCBCR444) {
		min_dsc_bpp = 8;
		max_dsc_bpp = 3 * bpc_factor;
	} else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422) {
		min_dsc_bpp = 7;
		max_dsc_bpp = 2 * bpc_factor;
	} else {
		min_dsc_bpp = 6;
		max_dsc_bpp = 3 * bpc_factor / 2;
	}

	if (!hdmi_all_bpp)
		max_dsc_bpp = min(max_dsc_bpp, 12);


	num_slices = hdmi_dsc_get_num_slices(timing);
	if (num_slices == 0)
		return 0;

	slice_width = timing->h_addressable / num_slices;

	bpp_target = max_dsc_bpp;
	bpp_decrement_x16 = 16 / src_fractional_bpp;
	bpp_target_x16 = (bpp_target * 16) - bpp_decrement_x16;
	if (!hdmi_all_bpp)
			bpp_target_x16 = (bpp_target * 16);

	/* check if byte target is below allowed Kbytes */
	while (bpp_target_x16 > (min_dsc_bpp * 16)) {
		target_bytes = num_slices * slice_width * bpp_target_x16 / 16 / 8;
		if (target_bytes <= hdmi_max_chunk_bytes) {
			bpp_found = true;
			break;
		}
		bpp_target_x16 -= bpp_decrement_x16;
	}

	if (bpp_found) {
		if (!hdmi_all_bpp) {
			/* Get preset bpp for CTA modes */
			preset_found = get_vic_preset_bpp(timing, &preset_bpp);
			if (preset_found) {
				bpp_target_x16 = preset_bpp;
				target_bytes =
						num_slices * slice_width * bpp_target_x16 / 16 / 8;
				if (target_bytes > hdmi_max_chunk_bytes)
					return 0;
			}
		}
		return bpp_target_x16;
	}

	return 0;
}

bool dc_dsc_parse_dsc_dpcd(const struct dc *dc,
		const uint8_t *dpcd_dsc_basic_data,
		const uint8_t *dpcd_dsc_branch_decoder_caps,
		struct dsc_dec_dpcd_caps *dsc_sink_caps)
{
	if (!dpcd_dsc_basic_data)
		return false;

	dsc_sink_caps->is_dsc_supported =
		(dpcd_dsc_basic_data[DP_DSC_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_DECOMPRESSION_IS_SUPPORTED) != 0;
	if (!dsc_sink_caps->is_dsc_supported)
		return false;

	dsc_sink_caps->dsc_version = dpcd_dsc_basic_data[DP_DSC_REV - DP_DSC_SUPPORT];

	{
		int buff_block_size;
		int buff_size;

		if (!dsc_buff_block_size_from_dpcd(
				dpcd_dsc_basic_data[DP_DSC_RC_BUF_BLK_SIZE - DP_DSC_SUPPORT] & 0x03,
				&buff_block_size))
			return false;

		buff_size = dpcd_dsc_basic_data[DP_DSC_RC_BUF_SIZE - DP_DSC_SUPPORT] + 1;
		dsc_sink_caps->rc_buffer_size = buff_size * buff_block_size;
	}

	dsc_sink_caps->slice_caps1.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_1 - DP_DSC_SUPPORT];
	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))
		return false;

	dsc_sink_caps->is_block_pred_supported =
		(dpcd_dsc_basic_data[DP_DSC_BLK_PREDICTION_SUPPORT - DP_DSC_SUPPORT] &
		 DP_DSC_BLK_PREDICTION_IS_SUPPORTED) != 0;

	dsc_sink_caps->edp_max_bits_per_pixel =
		dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_LOW - DP_DSC_SUPPORT] |
		dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_HI - DP_DSC_SUPPORT] << 8;

	dsc_sink_caps->color_formats.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_FORMAT_CAP - DP_DSC_SUPPORT];
	dsc_sink_caps->color_depth.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_DEPTH_CAP - DP_DSC_SUPPORT];

	{
		int dpcd_throughput = dpcd_dsc_basic_data[DP_DSC_PEAK_THROUGHPUT - DP_DSC_SUPPORT];
		int dsc_throughput_granular_delta;

		dsc_throughput_granular_delta = dpcd_dsc_basic_data[DP_DSC_RC_BUF_BLK_SIZE - DP_DSC_SUPPORT] >> 3;
		dsc_throughput_granular_delta *= 2;

		if (!dsc_throughput_from_dpcd(dpcd_throughput & DP_DSC_THROUGHPUT_MODE_0_MASK,
									  &dsc_sink_caps->throughput_mode_0_mps))
			return false;
		dsc_sink_caps->throughput_mode_0_mps += dsc_throughput_granular_delta;

		dpcd_throughput = (dpcd_throughput & DP_DSC_THROUGHPUT_MODE_1_MASK) >> DP_DSC_THROUGHPUT_MODE_1_SHIFT;
		if (!dsc_throughput_from_dpcd(dpcd_throughput, &dsc_sink_caps->throughput_mode_1_mps))
			return false;
	}

	dsc_sink_caps->max_slice_width = dpcd_dsc_basic_data[DP_DSC_MAX_SLICE_WIDTH - DP_DSC_SUPPORT] * 320;
	dsc_sink_caps->slice_caps2.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_2 - DP_DSC_SUPPORT];

	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))
		return false;

	if (dc->debug.dsc_bpp_increment_div) {
		/* dsc_bpp_increment_div should onl be 1, 2, 4, 8 or 16, but rather than rejecting invalid values,
		 * we'll accept all and get it into range. This also makes the above check against 0 redundant,
		 * but that one stresses out the override will be only used if it's not 0.
		 */
		if (dc->debug.dsc_bpp_increment_div >= 1)
			dsc_sink_caps->bpp_increment_div = 1;
		if (dc->debug.dsc_bpp_increment_div >= 2)
			dsc_sink_caps->bpp_increment_div = 2;
		if (dc->debug.dsc_bpp_increment_div >= 4)
			dsc_sink_caps->bpp_increment_div = 4;
		if (dc->debug.dsc_bpp_increment_div >= 8)
			dsc_sink_caps->bpp_increment_div = 8;
		if (dc->debug.dsc_bpp_increment_div >= 16)
			dsc_sink_caps->bpp_increment_div = 16;
	}

	/* Extended caps */
	if (dpcd_dsc_branch_decoder_caps == NULL) { // branch decoder DPCD DSC data can be null for non branch device
		dsc_sink_caps->branch_overall_throughput_0_mps = 0;
		dsc_sink_caps->branch_overall_throughput_1_mps = 0;
		dsc_sink_caps->branch_max_line_width = 0;
		return true;
	}

	dsc_sink_caps->branch_overall_throughput_0_mps =
		dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_0 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
	if (dsc_sink_caps->branch_overall_throughput_0_mps == 0)
		dsc_sink_caps->branch_overall_throughput_0_mps = 0;
	else if (dsc_sink_caps->branch_overall_throughput_0_mps == 1)
		dsc_sink_caps->branch_overall_throughput_0_mps = 680;
	else {
		dsc_sink_caps->branch_overall_throughput_0_mps *= 50;
		dsc_sink_caps->branch_overall_throughput_0_mps += 600;
	}

	dsc_sink_caps->branch_overall_throughput_1_mps =
		dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_1 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
	if (dsc_sink_caps->branch_overall_throughput_1_mps == 0)
		dsc_sink_caps->branch_overall_throughput_1_mps = 0;
	else if (dsc_sink_caps->branch_overall_throughput_1_mps == 1)
		dsc_sink_caps->branch_overall_throughput_1_mps = 680;
	else {
		dsc_sink_caps->branch_overall_throughput_1_mps *= 50;
		dsc_sink_caps->branch_overall_throughput_1_mps += 600;
	}

	dsc_sink_caps->branch_max_line_width =
		dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_MAX_LINE_WIDTH - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0] * 320;
	ASSERT(dsc_sink_caps->branch_max_line_width == 0 || dsc_sink_caps->branch_max_line_width >= 5120);

	dsc_sink_caps->is_dp = true;
	return true;
}
bool dc_dsc_parse_dsc_edid(const struct dc *dc, const struct dc_edid_caps *edid_caps,
		struct dsc_dec_dpcd_caps *dsc_sink_caps)
{
	(void)dc;
	dsc_sink_caps->is_dsc_supported = edid_caps->frl_dsc_support;
	if (!edid_caps->frl_dsc_support)
		return false;

	dsc_sink_caps->dsc_version = 0x21;
	dsc_sink_caps->is_frl = true;
	dsc_sink_caps->is_dp = false;

	switch (edid_caps->frl_dsc_max_slices) {
	case 0:
		break;
	case 1:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 340;
		dsc_sink_caps->throughput_mode_1_mps = 680;
		break;
	case 2:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 340;
		dsc_sink_caps->throughput_mode_1_mps = 680;
		break;
	case 3:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 340;
		dsc_sink_caps->throughput_mode_1_mps = 680;
		break;
	case 4:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 340;
		dsc_sink_caps->throughput_mode_1_mps = 680;
		break;
	case 5:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 400;
		dsc_sink_caps->throughput_mode_1_mps = 800;
		break;
	case 6:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_12 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 400;
		dsc_sink_caps->throughput_mode_1_mps = 800;
		break;
	case 7:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_12 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 600;
		dsc_sink_caps->throughput_mode_1_mps = 1200;
		break;
	case 8:
	default:
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 = 1;
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_12 = 1;
		dsc_sink_caps->throughput_mode_0_mps = 900;
		dsc_sink_caps->throughput_mode_1_mps = 1800;
		break;
	}
	dsc_sink_caps->lb_bit_depth = 13; //Table 7-25
	dsc_sink_caps->is_block_pred_supported = true; //Table 7-25
	dsc_sink_caps->color_formats.bits.RGB = 1;
	dsc_sink_caps->color_formats.bits.YCBCR_444 = 1;
	dsc_sink_caps->color_formats.bits.YCBCR_NATIVE_422 = 1;
	dsc_sink_caps->color_formats.bits.YCBCR_NATIVE_420 =
			(edid_caps->frl_dsc_native_420 == true) ? 1 : 0;
	dsc_sink_caps->color_depth.bits.COLOR_DEPTH_8_BPC = 1;
	dsc_sink_caps->color_depth.bits.COLOR_DEPTH_10_BPC =
			(edid_caps->frl_dsc_10bpc == true) ? 1 : 0;
	dsc_sink_caps->color_depth.bits.COLOR_DEPTH_12_BPC =
			(edid_caps->frl_dsc_12bpc == true) ? 1 : 0;
	dsc_sink_caps->max_slice_width = 2560;
	dsc_sink_caps->bpp_increment_div = 16; /* bpp increment divisor, e.g. if 16, it's 1/16th of a bit */
	dsc_sink_caps->is_vic_all_bpp = edid_caps->frl_dsc_all_bpp;
	dsc_sink_caps->total_chunk_kbytes =
			1024 * (1 + edid_caps->frl_dsc_total_chunk_kbytes);

	return true;
}

/* If DSC is possbile, get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range and
 * timing's pixel clock and uncompressed bandwidth.
 * If DSC is not possible, leave '*range' untouched.
 */
bool dc_dsc_compute_bandwidth_range(
		const struct display_stream_compressor *dsc,
		uint32_t dsc_min_slice_height_override,
		uint32_t min_bpp_x16,
		uint32_t max_bpp_x16,
		const struct dsc_dec_dpcd_caps *dsc_sink_caps,
		const struct dc_crtc_timing *timing,
		const enum dc_link_encoding_format link_encoding,
		struct dc_dsc_bw_range *range)
{
	bool is_dsc_possible = false;
	unsigned int min_dsc_slice_count;
	struct dsc_enc_caps dsc_enc_caps;
	struct dsc_enc_caps dsc_common_caps;
	struct dc_dsc_config config = {0};
	struct dc_dsc_config_options options = {0};

	options.dsc_min_slice_height_override = dsc_min_slice_height_override;
	options.max_target_bpp_limit_override_x16 = max_bpp_x16;
	options.slice_height_granularity = 1;

	get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);

	min_dsc_slice_count = get_min_dsc_slice_count_for_odm(dsc, &dsc_enc_caps, timing);

	is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, &dsc_enc_caps,
			timing->pixel_encoding, &dsc_common_caps);

	if (is_dsc_possible)
		is_dsc_possible = setup_dsc_config(dsc_sink_caps, &dsc_enc_caps, 0, timing,
				&options, link_encoding, min_dsc_slice_count, &config);

	if (is_dsc_possible)
		is_dsc_possible = decide_dsc_bandwidth_range(min_bpp_x16, max_bpp_x16,
				config.num_slices_h, &dsc_common_caps, timing, link_encoding, range);

	return is_dsc_possible;
}

void dc_dsc_dump_encoder_caps(const struct display_stream_compressor *dsc,
			      const struct dc_crtc_timing *timing)
{
	struct dsc_enc_caps dsc_enc_caps;

	get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);

	DC_LOG_DSC("dsc encoder caps:");
	DC_LOG_DSC("\tdsc_version 0x%x", dsc_enc_caps.dsc_version);
	DC_LOG_DSC("\tslice_caps 0x%x", dsc_enc_caps.slice_caps.raw);
	DC_LOG_DSC("\tlb_bit_depth %d", dsc_enc_caps.lb_bit_depth);
	DC_LOG_DSC("\tis_block_pred_supported %d", dsc_enc_caps.is_block_pred_supported);
	DC_LOG_DSC("\tcolor_formats 0x%x", dsc_enc_caps.color_formats.raw);
	DC_LOG_DSC("\tcolor_depth 0x%x", dsc_enc_caps.color_depth.raw);
	DC_LOG_DSC("\tmax_total_throughput_mps %d", dsc_enc_caps.max_total_throughput_mps);
	DC_LOG_DSC("\tmax_slice_width %d", dsc_enc_caps.max_slice_width);
	DC_LOG_DSC("\tbpp_increment_div %d", dsc_enc_caps.bpp_increment_div);
}

void dc_dsc_dump_decoder_caps(const struct display_stream_compressor *dsc,
			      const struct dsc_dec_dpcd_caps *dsc_sink_caps)
{
	DC_LOG_DSC("dsc decoder caps:");
	DC_LOG_DSC("\tis_dsc_supported %d", dsc_sink_caps->is_dsc_supported);
	DC_LOG_DSC("\tdsc_version 0x%x", dsc_sink_caps->dsc_version);
	DC_LOG_DSC("\trc_buffer_size %d", dsc_sink_caps->rc_buffer_size);
	DC_LOG_DSC("\tslice_caps1 0x%x", dsc_sink_caps->slice_caps1.raw);
	DC_LOG_DSC("\tslice_caps2 0x%x", dsc_sink_caps->slice_caps2.raw);
	DC_LOG_DSC("\tlb_bit_depth %d", dsc_sink_caps->lb_bit_depth);
	DC_LOG_DSC("\tis_block_pred_supported %d", dsc_sink_caps->is_block_pred_supported);
	DC_LOG_DSC("\tedp_max_bits_per_pixel %d", dsc_sink_caps->edp_max_bits_per_pixel);
	DC_LOG_DSC("\tcolor_formats 0x%x", dsc_sink_caps->color_formats.raw);
	DC_LOG_DSC("\tthroughput_mode_0_mps %d", dsc_sink_caps->throughput_mode_0_mps);
	DC_LOG_DSC("\tthroughput_mode_1_mps %d", dsc_sink_caps->throughput_mode_1_mps);
	DC_LOG_DSC("\tmax_slice_width %d", dsc_sink_caps->max_slice_width);
	DC_LOG_DSC("\tbpp_increment_div %d", dsc_sink_caps->bpp_increment_div);
	DC_LOG_DSC("\tbranch_overall_throughput_0_mps %d", dsc_sink_caps->branch_overall_throughput_0_mps);
	DC_LOG_DSC("\tbranch_overall_throughput_1_mps %d", dsc_sink_caps->branch_overall_throughput_1_mps);
	DC_LOG_DSC("\tbranch_max_line_width %d", dsc_sink_caps->branch_max_line_width);
	DC_LOG_DSC("\tis_dp %d", dsc_sink_caps->is_dp);
}


static void build_dsc_enc_combined_slice_caps(
		const struct dsc_enc_caps *single_dsc_enc_caps,
		struct dsc_enc_caps *dsc_enc_caps,
		unsigned int max_odm_combine_factor)
{
	/* 1-16 slice configurations, single DSC */
	dsc_enc_caps->slice_caps.raw |= single_dsc_enc_caps->slice_caps.raw;

	/* 2x DSC's */
	if (max_odm_combine_factor >= 2) {
		/* 1 + 1 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_2 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_1;

		/* 2 + 2 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_4 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_2;

		/* 4 + 4 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_8 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_4;

		/* 8 + 8 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_16 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_8;
	}

	/* 3x DSC's */
	if (max_odm_combine_factor >= 3) {
		/* 4 + 4 + 4 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_12 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_4;
	}

	/* 4x DSC's */
	if (max_odm_combine_factor >= 4) {
		/* 1 + 1 + 1 + 1 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_4 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_1;

		/* 2 + 2 + 2 + 2 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_8 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_2;

		/* 3 + 3 + 3 + 3 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_12 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_3;

		/* 4 + 4 + 4 + 4 */
		dsc_enc_caps->slice_caps.bits.NUM_SLICES_16 |= single_dsc_enc_caps->slice_caps.bits.NUM_SLICES_4;
	}
}

static void build_dsc_enc_caps(
		const struct display_stream_compressor *dsc,
		struct dsc_enc_caps *dsc_enc_caps)
{
	unsigned int max_dscclk_khz;
	unsigned int num_dsc;
	unsigned int max_odm_combine_factor;
	struct dsc_enc_caps single_dsc_enc_caps;

	struct dc *dc;

	if (!dsc || !dsc->ctx || !dsc->ctx->dc || !dsc->funcs->dsc_get_single_enc_caps)
		return;

	dc = dsc->ctx->dc;

	if (!dc->clk_mgr || !dc->clk_mgr->funcs->get_max_clock_khz || !dc->res_pool || dc->debug.disable_dsc)
		return;

	/* get max DSCCLK from clk_mgr */
	max_dscclk_khz = dc->clk_mgr->funcs->get_max_clock_khz(dc->clk_mgr, CLK_TYPE_DSCCLK);

	dsc->funcs->dsc_get_single_enc_caps(&single_dsc_enc_caps, max_dscclk_khz);

	/* global capabilities */
	dsc_enc_caps->dsc_version = single_dsc_enc_caps.dsc_version;
	dsc_enc_caps->lb_bit_depth = single_dsc_enc_caps.lb_bit_depth;
	dsc_enc_caps->is_block_pred_supported = single_dsc_enc_caps.is_block_pred_supported;
	dsc_enc_caps->max_slice_width = single_dsc_enc_caps.max_slice_width;
	dsc_enc_caps->bpp_increment_div = single_dsc_enc_caps.bpp_increment_div;
	dsc_enc_caps->color_formats.raw = single_dsc_enc_caps.color_formats.raw;
	dsc_enc_caps->color_depth.raw = single_dsc_enc_caps.color_depth.raw;

	/* expand per DSC capabilities to global */
	max_odm_combine_factor = dc->caps.max_odm_combine_factor;
	num_dsc = dc->res_pool->res_cap->num_dsc;
	max_odm_combine_factor = min(max_odm_combine_factor, num_dsc);
	dsc_enc_caps->max_total_throughput_mps =
			single_dsc_enc_caps.max_total_throughput_mps *
			max_odm_combine_factor;

	/* check slice counts possible for with ODM combine */
	build_dsc_enc_combined_slice_caps(&single_dsc_enc_caps, dsc_enc_caps, max_odm_combine_factor);
}

static inline uint32_t dsc_div_by_10_round_up(uint32_t value)
{
	return (value + 9) / 10;
}

static unsigned int get_min_dsc_slice_count_for_odm(
		const struct display_stream_compressor *dsc,
		const struct dsc_enc_caps *dsc_enc_caps,
		const struct dc_crtc_timing *timing)
{
	unsigned int max_dispclk_khz;

	/* get max pixel rate and combine caps */
	max_dispclk_khz = dsc_enc_caps->max_total_throughput_mps * 1000;
	if (dsc && dsc->ctx->dc) {
		if (dsc->ctx->dc->clk_mgr &&
			dsc->ctx->dc->clk_mgr->funcs->get_max_clock_khz) {
			/* dispclk is available */
			max_dispclk_khz = dsc->ctx->dc->clk_mgr->funcs->get_max_clock_khz(dsc->ctx->dc->clk_mgr, CLK_TYPE_DISPCLK);
		}
	}

	/* validate parameters */
	if (max_dispclk_khz == 0 || dsc_enc_caps->max_slice_width == 0)
		return 1;

	/* consider minimum odm slices required due to
	 * 1) display pipe throughput (dispclk)
	 * 2) max image width per slice
	 */
	return dc_fixpt_ceil(dc_fixpt_max(
			dc_fixpt_div_int(dc_fixpt_from_int(dsc_div_by_10_round_up(timing->pix_clk_100hz)),
			max_dispclk_khz), // throughput
			dc_fixpt_div_int(dc_fixpt_from_int(timing->h_addressable + timing->h_border_left + timing->h_border_right),
			dsc_enc_caps->max_slice_width))); // slice width
}

static void get_dsc_enc_caps(
		const struct display_stream_compressor *dsc,
		struct dsc_enc_caps *dsc_enc_caps,
		int pixel_clock_100Hz)
{
	memset(dsc_enc_caps, 0, sizeof(struct dsc_enc_caps));

	if (!dsc || !dsc->ctx || !dsc->ctx->dc || dsc->ctx->dc->debug.disable_dsc)
		return;

	/* check if reported cap global or only for a single DCN DSC enc */
	if (dsc->funcs->dsc_get_enc_caps) {
		dsc->funcs->dsc_get_enc_caps(dsc_enc_caps, pixel_clock_100Hz);
	} else {
		build_dsc_enc_caps(dsc, dsc_enc_caps);
	}
}

/* Returns 'false' if no intersection was found for at least one capability.
 * It also implicitly validates some sink caps against invalid value of zero.
 */
static bool 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)
{
	int32_t max_slices;
	int32_t total_sink_throughput;

	memset(dsc_common_caps, 0, sizeof(struct dsc_enc_caps));

	dsc_common_caps->dsc_version = min(dsc_sink_caps->dsc_version, dsc_enc_caps->dsc_version);
	if (!dsc_common_caps->dsc_version)
		return false;

	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;
	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;
	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;
	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;
	dsc_common_caps->slice_caps.bits.NUM_SLICES_12 =
		dsc_sink_caps->slice_caps1.bits.NUM_SLICES_12 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_12;
	dsc_common_caps->slice_caps.bits.NUM_SLICES_16 =
		dsc_sink_caps->slice_caps2.bits.NUM_SLICES_16 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_16;

	if (!dsc_common_caps->slice_caps.raw)
		return false;

	dsc_common_caps->lb_bit_depth = min(dsc_sink_caps->lb_bit_depth, dsc_enc_caps->lb_bit_depth);
	if (!dsc_common_caps->lb_bit_depth)
		return false;

	dsc_common_caps->is_block_pred_supported =
		dsc_sink_caps->is_block_pred_supported && dsc_enc_caps->is_block_pred_supported;

	dsc_common_caps->color_formats.raw = dsc_sink_caps->color_formats.raw & dsc_enc_caps->color_formats.raw;
	if (!dsc_common_caps->color_formats.raw)
		return false;

	dsc_common_caps->color_depth.raw = dsc_sink_caps->color_depth.raw & dsc_enc_caps->color_depth.raw;
	if (!dsc_common_caps->color_depth.raw)
		return false;

	max_slices = 0;
	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_1)
		max_slices = 1;

	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_2)
		max_slices = 2;

	if (dsc_common_caps->slice_caps.bits.NUM_SLICES_4)
		max_slices = 4;

	total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_0_mps;
	if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
		total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_1_mps;

	dsc_common_caps->max_total_throughput_mps = min(total_sink_throughput, dsc_enc_caps->max_total_throughput_mps);

	dsc_common_caps->max_slice_width = min(dsc_sink_caps->max_slice_width, dsc_enc_caps->max_slice_width);
	if (!dsc_common_caps->max_slice_width)
		return false;

	dsc_common_caps->bpp_increment_div = min(dsc_sink_caps->bpp_increment_div, dsc_enc_caps->bpp_increment_div);

	// TODO DSC: Remove this workaround for N422 and 420 once it's fixed, or move it to get_dsc_encoder_caps()
	if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
		dsc_common_caps->bpp_increment_div = min(dsc_common_caps->bpp_increment_div, (uint32_t)8);

	dsc_common_caps->is_frl = dsc_sink_caps->is_frl;
	dsc_common_caps->is_vic_all_bpp = dsc_sink_caps->is_vic_all_bpp;
	dsc_common_caps->total_chunk_kbytes = dsc_sink_caps->total_chunk_kbytes;
	dsc_common_caps->edp_sink_max_bits_per_pixel = dsc_sink_caps->edp_max_bits_per_pixel;
	dsc_common_caps->is_dp = dsc_sink_caps->is_dp;
	return true;
}

static uint32_t compute_bpp_x16_from_target_bandwidth(
	const uint32_t bandwidth_in_kbps,
	const struct dc_crtc_timing *timing,
	const uint32_t num_slices_h,
	const uint32_t bpp_increment_div,
	const bool is_dp)
{
	uint32_t overhead_in_kbps;
	struct fixed31_32 effective_bandwidth_in_kbps;
	struct fixed31_32 bpp_x16;

	overhead_in_kbps = dc_dsc_stream_bandwidth_overhead_in_kbps(
				timing, num_slices_h, is_dp);
	effective_bandwidth_in_kbps = dc_fixpt_from_int(bandwidth_in_kbps);
	effective_bandwidth_in_kbps = dc_fixpt_sub_int(effective_bandwidth_in_kbps,
			overhead_in_kbps);
	bpp_x16 = dc_fixpt_mul_int(effective_bandwidth_in_kbps, 10);
	bpp_x16 = dc_fixpt_div_int(bpp_x16, timing->pix_clk_100hz);
	bpp_x16 = dc_fixpt_from_int(dc_fixpt_floor(dc_fixpt_mul_int(bpp_x16, bpp_increment_div)));
	bpp_x16 = dc_fixpt_div_int(bpp_x16, bpp_increment_div);
	bpp_x16 = dc_fixpt_mul_int(bpp_x16, 16);
	return dc_fixpt_floor(bpp_x16);
}

static bool convert_bandwidth_to_frl_params(
	int bandwidth_kbps,
	int *num_lanes,
	int *frl_rate)
{
	if (bandwidth_kbps == 0)
		return false;

	switch (bandwidth_kbps) {
	case 9000000:
		*num_lanes = 3;
		*frl_rate = 3000;
		break;
	case 18000000:
		*num_lanes = 3;
		*frl_rate = 6000;
		break;
	case 24000000:
		*num_lanes = 4;
		*frl_rate = 6000;
		break;
	case 32000000:
		*num_lanes = 4;
		*frl_rate = 8000;
		break;
	case 40000000:
		*num_lanes = 4;
		*frl_rate = 10000;
		break;
	case 48000000:
		*num_lanes = 4;
		*frl_rate = 12000;
		break;
	default:
		return false;
	}
	return true;
}

static uint32_t compute_bpp_x16_from_frl_params(
		const struct dc_crtc_timing *timing,
		const uint32_t num_slices_h,
		const struct dsc_enc_caps *dsc_caps)
{
	struct fixed31_32 pixel_clock;
	uint32_t num_lanes = dsc_caps->num_lanes;
	uint32_t frl_rate = dsc_caps->frl_rate;
	uint32_t h_active = timing->h_addressable;
	uint32_t h_blank = timing->h_total - timing->h_addressable;
	uint32_t bpp_target_x16;
	struct fixed31_32 r_bit;
	uint32_t f_audio = 48000;
	struct fixed31_32 pixel_rate_tolerance;
	uint32_t audio_tolerance = 1000;
	uint32_t frl_bit_tolerance = 300;
	uint32_t acr_rate_max = 1500;
	uint32_t c_frl_cb = 510;
	uint32_t c_frl_sb;
	struct fixed31_32 overhead_sb;
	struct fixed31_32 overhead_rs;
	struct fixed31_32 overhead_map;
	struct fixed31_32 overhead_min;
	struct fixed31_32 overhead_m;
	struct fixed31_32 overhead_max;
	struct fixed31_32 pixel_clock_max;
	struct fixed31_32 t_line;
	struct fixed31_32 r_bit_min;
	struct fixed31_32 r_frl_char_min;
	struct fixed31_32 c_frl_line;
	uint32_t c_frl_line_int;
	struct fixed31_32 c_frl_available;
	uint32_t c_frl_av_int;
	struct fixed31_32 c_frl_active_av;
	struct fixed31_32 c_frl_blank_av;
	uint32_t acat_ap = 4;
	struct fixed31_32 r_ap;
	struct fixed31_32 max_audio_tol_rate;
	struct fixed31_32 avg_audio_packets_line;
	uint32_t avg_audio_packets_line_int;
	int hc_blank_audio_min;
	uint32_t bytes_target;
	uint32_t hc_active_target;
	uint32_t hc_blank_target_est1;
	uint32_t hc_blank_target_est2;
	struct fixed31_32 hc_blank_target_bandwidth;
	int hc_blank_target;
	uint32_t bpc_factor = 8;
	uint32_t min_dsc_bpp_x16;
	uint32_t max_dsc_bpp_x16;
	bool hdmi_all_bpp = dsc_caps->is_vic_all_bpp;
	uint32_t slice_width;

	if (timing->display_color_depth == COLOR_DEPTH_101010)
		bpc_factor = 10;
	if (timing->display_color_depth == COLOR_DEPTH_121212)
		bpc_factor = 12;

	/* Assuming: bpc as 8*/
	if (timing->pixel_encoding == PIXEL_ENCODING_RGB ||
			timing->pixel_encoding == PIXEL_ENCODING_YCBCR444) {
		min_dsc_bpp_x16 = 8 * 16;
		max_dsc_bpp_x16 = 3 * 16 * bpc_factor;
	} else if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422) {
		min_dsc_bpp_x16 = 7 * 16;
		max_dsc_bpp_x16 = 2 * 16 * bpc_factor;
	} else {
		min_dsc_bpp_x16 = 6 * 16;
		max_dsc_bpp_x16 = 3 * 16 * bpc_factor / 2;
	}

	max_dsc_bpp_x16 = MIN(max_dsc_bpp_x16, 256);
	if (!hdmi_all_bpp)
		max_dsc_bpp_x16 = MIN(max_dsc_bpp_x16, 192);

	c_frl_sb = 4 * c_frl_cb + num_lanes;
	pixel_clock = dc_fixpt_div_int(dc_fixpt_from_int(timing->pix_clk_100hz), 10000);
	r_bit = dc_fixpt_from_int(frl_rate);
	pixel_rate_tolerance = dc_fixpt_div_int(dc_fixpt_from_int(5), 1000);
	overhead_sb = dc_fixpt_div_int(dc_fixpt_from_int(num_lanes), c_frl_sb);
	overhead_rs = dc_fixpt_div_int(dc_fixpt_from_int(32), c_frl_sb);
	overhead_map = dc_fixpt_div_int(dc_fixpt_from_int(25), (c_frl_sb * 10));
	overhead_min = dc_fixpt_add(overhead_sb, overhead_rs);
	overhead_min = dc_fixpt_add(overhead_min, overhead_map);
	overhead_m = dc_fixpt_div_int(dc_fixpt_from_int(3), 1000);
	overhead_max = dc_fixpt_add(overhead_min, overhead_m);
	pixel_rate_tolerance = dc_fixpt_add_int(pixel_rate_tolerance, 1);
	pixel_clock_max = dc_fixpt_mul(pixel_clock, pixel_rate_tolerance);
	t_line = dc_fixpt_div(dc_fixpt_from_int(h_active + h_blank), pixel_clock_max);
	r_bit_min = dc_fixpt_div_int(dc_fixpt_from_int(frl_bit_tolerance), 1000000);
	r_bit_min = dc_fixpt_sub(dc_fixpt_from_int(1), r_bit_min);
	r_bit_min = dc_fixpt_mul(r_bit, r_bit_min);
	r_frl_char_min = dc_fixpt_div_int(r_bit_min, 18);
	c_frl_line = dc_fixpt_mul(t_line, r_frl_char_min);
	c_frl_line = dc_fixpt_mul_int(c_frl_line, num_lanes);
	c_frl_line_int = dc_fixpt_floor(c_frl_line);
	c_frl_available = dc_fixpt_sub(dc_fixpt_from_int(1), overhead_max);
	c_frl_available = dc_fixpt_mul_int(c_frl_available, c_frl_line_int);
	c_frl_av_int = dc_fixpt_floor(c_frl_available);
	c_frl_active_av = dc_fixpt_mul_int(dc_fixpt_from_int(c_frl_av_int), h_active);
	c_frl_active_av = dc_fixpt_div_int(c_frl_active_av, (h_active + h_blank));
	c_frl_blank_av = dc_fixpt_mul_int(dc_fixpt_from_int(c_frl_av_int), h_blank);
	c_frl_blank_av =  dc_fixpt_div_int(c_frl_blank_av, (h_active + h_blank));
	r_ap = dc_fixpt_max(dc_fixpt_from_int(192000),
			dc_fixpt_from_int(f_audio * acat_ap));
	r_ap = dc_fixpt_add(r_ap, dc_fixpt_from_int(2 * acr_rate_max));
	max_audio_tol_rate =  dc_fixpt_div_int(dc_fixpt_from_int(audio_tolerance), 1000000);
	max_audio_tol_rate =  dc_fixpt_add(dc_fixpt_from_int(1), max_audio_tol_rate);
	r_ap = dc_fixpt_mul(r_ap, max_audio_tol_rate);
	avg_audio_packets_line = dc_fixpt_mul(r_ap, t_line);
	avg_audio_packets_line = dc_fixpt_div_int(avg_audio_packets_line, 1000000);
	avg_audio_packets_line_int = dc_fixpt_ceil(avg_audio_packets_line);
	hc_blank_audio_min = 32 + 32 * avg_audio_packets_line_int;
	slice_width = dc_fixpt_ceil(dc_fixpt_div_int(
			dc_fixpt_from_int(h_active), num_slices_h));

	/* Slice width for 420 must be even */
	if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420 && slice_width % 2 != 0) {
		slice_width++;
	}

	for (uint32_t i = max_dsc_bpp_x16; i >= min_dsc_bpp_x16; i--) {
		bpp_target_x16 = i;
		bytes_target = num_slices_h * dc_fixpt_ceil(dc_fixpt_div_int(
				dc_fixpt_from_int(bpp_target_x16 * slice_width), 8 * 16));
		hc_active_target = dc_fixpt_ceil(dc_fixpt_div_int(
				dc_fixpt_from_int(bytes_target), 3));
		hc_blank_target_est1 = dc_fixpt_ceil(dc_fixpt_div_int(
				dc_fixpt_from_int(hc_active_target * h_blank), h_active));
		hc_blank_target_est2 = dc_fixpt_floor(dc_fixpt_max(
				dc_fixpt_from_int(hc_blank_target_est1),
				dc_fixpt_from_int(hc_blank_audio_min)));
		hc_blank_target_bandwidth = dc_fixpt_div_int(dc_fixpt_from_int(3), 2);
		hc_blank_target_bandwidth = dc_fixpt_mul(hc_blank_target_bandwidth,
				dc_fixpt_from_int(hc_active_target));
		hc_blank_target_bandwidth = dc_fixpt_sub(dc_fixpt_from_int(c_frl_av_int),
				hc_blank_target_bandwidth);
		hc_blank_target_bandwidth = dc_fixpt_min(hc_blank_target_bandwidth,
				dc_fixpt_from_int(hc_blank_target_est2));
		hc_blank_target_bandwidth = dc_fixpt_div_int(hc_blank_target_bandwidth, 4);
		hc_blank_target = dc_fixpt_floor(hc_blank_target_bandwidth) * 4;
		if (hc_blank_target >= hc_blank_audio_min)
			return bpp_target_x16;
	}
	return 0;
}
/* Decide DSC bandwidth range based on signal, timing, specs specific and input min and max
 * requirements.
 * The range output includes decided min/max target bpp, the respective bandwidth requirements
 * and native timing bandwidth requirement when DSC is not used.
 */
static bool decide_dsc_bandwidth_range(
		const uint32_t min_bpp_x16,
		const uint32_t max_bpp_x16,
		const uint32_t num_slices_h,
		const struct dsc_enc_caps *dsc_caps,
		const struct dc_crtc_timing *timing,
		const enum dc_link_encoding_format link_encoding,
		struct dc_dsc_bw_range *range)
{
	uint32_t preferred_bpp_x16 = timing->dsc_fixed_bits_per_pixel_x16;

	memset(range, 0, sizeof(*range));

	/* apply signal, timing, specs and explicitly specified DSC range requirements */
	if (preferred_bpp_x16) {
		if (preferred_bpp_x16 <= max_bpp_x16 &&
				preferred_bpp_x16 >= min_bpp_x16) {
			range->max_target_bpp_x16 = preferred_bpp_x16;
			range->min_target_bpp_x16 = preferred_bpp_x16;
		}
	}
	else if (dsc_caps->is_frl) {
		uint32_t specs_preferred_bpp_x16 = hdmi_dsc_get_bpp(timing, dsc_caps);
		uint32_t specs_calculated_bpp_x16 = 0;

		if (timing->vic) {
			/* For CTA timing, we should strictly follow HDMI spec. */
			range->max_target_bpp_x16 = specs_preferred_bpp_x16;
			if (dsc_caps->is_vic_all_bpp || dsc_caps->is_dp)
				range->min_target_bpp_x16 = min_bpp_x16;
			else
				range->min_target_bpp_x16 = specs_preferred_bpp_x16;
		} else {
			if (timing->vic == 0 && timing->hdmi_vic == 0)
				specs_calculated_bpp_x16 = compute_bpp_x16_from_frl_params(
						timing, num_slices_h, dsc_caps);

			if (specs_calculated_bpp_x16 != 0)
				specs_preferred_bpp_x16 = MIN(specs_calculated_bpp_x16,
						specs_preferred_bpp_x16);

			range->max_target_bpp_x16 = MIN(max_bpp_x16, specs_preferred_bpp_x16);
			range->min_target_bpp_x16 = min_bpp_x16;
		}
	}
	/* TODO - make this value generic to all signal types */
	else if (dsc_caps->edp_sink_max_bits_per_pixel) {
		/* apply max bpp limitation from edp sink */
		range->max_target_bpp_x16 = MIN(dsc_caps->edp_sink_max_bits_per_pixel,
				max_bpp_x16);
		range->min_target_bpp_x16 = min_bpp_x16;
	}
	else {
		range->max_target_bpp_x16 = max_bpp_x16;
		range->min_target_bpp_x16 = min_bpp_x16;
	}

	/* populate output structure */
	if (range->max_target_bpp_x16 >= range->min_target_bpp_x16 && range->min_target_bpp_x16 > 0) {
		/* native stream bandwidth */
		range->stream_kbps = dc_bandwidth_in_kbps_from_timing(timing, link_encoding);

		/* max dsc target bpp */
		range->max_kbps = dc_dsc_stream_bandwidth_in_kbps(timing,
				range->max_target_bpp_x16, num_slices_h, dsc_caps->is_dp);

		/* min dsc target bpp */
		range->min_kbps = dc_dsc_stream_bandwidth_in_kbps(timing,
				range->min_target_bpp_x16, num_slices_h, dsc_caps->is_dp);
	}

	return range->max_kbps >= range->min_kbps && range->min_kbps > 0;
}

/* Decides if DSC should be used and calculates target bpp if it should, applying DSC policy.
 *
 * Returns:
 *     - 'true' if target bpp is decided
 *     - 'false' if target bpp cannot be decided (e.g. cannot fit even with min DSC bpp),
 */
static bool decide_dsc_target_bpp_x16(
		const struct dc_dsc_policy *policy,
		const struct dc_dsc_config_options *options,
		const struct dsc_enc_caps *dsc_common_caps,
		const int target_bandwidth_kbps,
		const struct dc_crtc_timing *timing,
		const int num_slices_h,
		const enum dc_link_encoding_format link_encoding,
		int *target_bpp_x16)
{
	struct dc_dsc_bw_range range;
	uint32_t target_bandwidth_kbps_u = (uint32_t)target_bandwidth_kbps;

	*target_bpp_x16 = 0;

	if (decide_dsc_bandwidth_range(policy->min_target_bpp * 16, policy->max_target_bpp * 16,
			num_slices_h, dsc_common_caps, timing, link_encoding, &range)) {
		if (target_bandwidth_kbps_u >= range.stream_kbps) {
			if (policy->enable_dsc_when_not_needed || options->force_dsc_when_not_needed)
				/* enable max bpp even dsc is not needed */
				*target_bpp_x16 = range.max_target_bpp_x16;
		} else if (target_bandwidth_kbps_u >= range.max_kbps) {
			/* use max target bpp allowed */
			*target_bpp_x16 = range.max_target_bpp_x16;
		} else if (target_bandwidth_kbps_u >= range.min_kbps) {
			/* use target bpp that can take entire target bandwidth */
			*target_bpp_x16 = compute_bpp_x16_from_target_bandwidth(
					target_bandwidth_kbps, timing, num_slices_h,
					dsc_common_caps->bpp_increment_div,
					dsc_common_caps->is_dp);
		}
		/* Assign minimum bpp and validate TB borrow scenario later */
		if (target_bandwidth_kbps < range.min_kbps)
			if (dsc_common_caps->is_frl)
				*target_bpp_x16 = range.min_target_bpp_x16;
	}

	return *target_bpp_x16 != 0;
}

#define MIN_AVAILABLE_SLICES_SIZE  6

static int get_available_dsc_slices(union dsc_enc_slice_caps slice_caps, int *available_slices)
{
	int idx = 0;

	if (slice_caps.bits.NUM_SLICES_1)
		available_slices[idx++] = 1;

	if (slice_caps.bits.NUM_SLICES_2)
		available_slices[idx++] = 2;

	if (slice_caps.bits.NUM_SLICES_4)
		available_slices[idx++] = 4;

	if (slice_caps.bits.NUM_SLICES_8)
		available_slices[idx++] = 8;

	if (slice_caps.bits.NUM_SLICES_12)
		available_slices[idx++] = 12;

	if (slice_caps.bits.NUM_SLICES_16)
		available_slices[idx++] = 16;

	return idx;
}


static int get_max_dsc_slices(union dsc_enc_slice_caps slice_caps)
{
	int max_slices = 0;
	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
	int end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);

	if (end_idx > 0)
		max_slices = available_slices[end_idx - 1];

	return max_slices;
}


// Increment slice number in available slice numbers stops if possible, or just increment if not
static int inc_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
{
	// Get next bigger num slices available in common caps
	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
	int end_idx;
	int i;
	int new_num_slices = num_slices;

	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
	if (end_idx == 0) {
		// No available slices found
		new_num_slices++;
		return new_num_slices;
	}

	// Numbers of slices found - get the next bigger number
	for (i = 0; i < end_idx; i++) {
		if (new_num_slices < available_slices[i]) {
			new_num_slices = available_slices[i];
			break;
		}
	}

	if (new_num_slices == num_slices) // No bigger number of slices found
		new_num_slices++;

	return new_num_slices;
}


// Decrement slice number in available slice numbers stops if possible, or just decrement if not. Stop at zero.
static int dec_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
{
	// Get next bigger num slices available in common caps
	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
	int end_idx;
	int i;
	int new_num_slices = num_slices;

	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
	if (end_idx == 0 && new_num_slices > 0) {
		// No numbers of slices found
		new_num_slices++;
		return new_num_slices;
	}

	// Numbers of slices found - get the next smaller number
	for (i = end_idx - 1; i >= 0; i--) {
		if (new_num_slices > available_slices[i]) {
			new_num_slices = available_slices[i];
			break;
		}
	}

	if (new_num_slices == num_slices) {
		// No smaller number of slices found
		new_num_slices--;
		if (new_num_slices < 0)
			new_num_slices = 0;
	}

	return new_num_slices;
}


// Choose next bigger number of slices if the requested number of slices is not available
static int fit_num_slices_up(union dsc_enc_slice_caps slice_caps, int num_slices)
{
	// Get next bigger num slices available in common caps
	int available_slices[MIN_AVAILABLE_SLICES_SIZE];
	int end_idx;
	int i;
	int new_num_slices = num_slices;

	end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
	if (end_idx == 0) {
		// No available slices found
		new_num_slices++;
		return new_num_slices;
	}

	// Numbers of slices found - get the equal or next bigger number
	for (i = 0; i < end_idx; i++) {
		if (new_num_slices <= available_slices[i]) {
			new_num_slices = available_slices[i];
			break;
		}
	}

	return new_num_slices;
}


/* Attempts to set DSC configuration for the stream, applying DSC policy.
 * Returns 'true' if successful or 'false' if not.
 *
 * Parameters:
 *
 * dsc_sink_caps       - DSC sink decoder capabilities (from DPCD)
 *
 * dsc_enc_caps        - DSC encoder capabilities
 *
 * target_bandwidth_kbps  - Target bandwidth to fit the stream into.
 *                          If 0, do not calculate target bpp.
 *
 * timing              - The stream timing to fit into 'target_bandwidth_kbps' or apply
 *                       maximum compression to, if 'target_badwidth == 0'
 *
 * dsc_cfg             - DSC configuration to use if it was possible to come up with
 *                       one for the given inputs.
 *                       The target bitrate after DSC can be calculated by multiplying
 *                       dsc_cfg.bits_per_pixel (in U6.4 format) by pixel rate, e.g.
 *
 *                       dsc_stream_bitrate_kbps = (int)ceil(timing->pix_clk_khz * dsc_cfg.bits_per_pixel / 16.0);
 */
static bool 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,
		const struct dc_dsc_config_options *options,
		const enum dc_link_encoding_format link_encoding,
		int min_slices_h,
		struct dc_dsc_config *dsc_cfg)
{
	struct dsc_enc_caps dsc_common_caps;
	int max_slices_h = 0;
	int num_slices_h = 0;
	int pic_width;
	uint32_t pic_width_u;
	int slice_width;
	int target_bpp;
	int sink_per_slice_throughput_mps;
	uint32_t branch_max_throughput_mps = 0;
	bool is_dsc_possible = false;
	int pic_height;
	int slice_height;
	struct dc_dsc_policy policy;
	int num_lanes;
	int frl_rate;

	memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));

	dc_dsc_get_policy_for_timing(timing, options->max_target_bpp_limit_override_x16, &policy, link_encoding);
	pic_width = timing->h_addressable + timing->h_border_left + timing->h_border_right;
	pic_width_u = (uint32_t)pic_width;
	pic_height = timing->v_addressable + timing->v_border_top + timing->v_border_bottom;

	if (!dsc_sink_caps->is_dsc_supported)
		goto done;

	if (dsc_sink_caps->branch_max_line_width && dsc_sink_caps->branch_max_line_width < pic_width_u)
		goto done;

	// Intersect decoder with encoder DSC caps and validate DSC settings
	is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, dsc_enc_caps, timing->pixel_encoding, &dsc_common_caps);
	if (!is_dsc_possible)
		goto done;
	if (convert_bandwidth_to_frl_params(
					target_bandwidth_kbps, &num_lanes, &frl_rate)) {
		dsc_common_caps.num_lanes = num_lanes;
		dsc_common_caps.frl_rate = frl_rate;
	}

	sink_per_slice_throughput_mps = 0;

	// Validate available DSC settings against the mode timing

	// Validate color format (and pick up the throughput values)
	dsc_cfg->ycbcr422_simple = false;
	switch (timing->pixel_encoding)	{
	case PIXEL_ENCODING_RGB:
		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.RGB;
		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
		break;
	case PIXEL_ENCODING_YCBCR444:
		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_444;
		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
		break;
	case PIXEL_ENCODING_YCBCR422:
		if (policy.ycbcr422_simple) {
			is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_SIMPLE_422;
			dsc_cfg->ycbcr422_simple = is_dsc_possible;
			sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
		} else {
			is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_422;
			sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
			branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
		}
		break;
	case PIXEL_ENCODING_YCBCR420:
		is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_420;
		sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
		branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
		break;
	default:
		is_dsc_possible = false;
	}

	// Validate branch's maximum throughput
	if (branch_max_throughput_mps && dsc_div_by_10_round_up(timing->pix_clk_100hz) > branch_max_throughput_mps * 1000)
		is_dsc_possible = false;

	if (!is_dsc_possible)
		goto done;

	// Color depth
	switch (timing->display_color_depth) {
	case COLOR_DEPTH_888:
		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_8_BPC;
		break;
	case COLOR_DEPTH_101010:
		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_10_BPC;
		break;
	case COLOR_DEPTH_121212:
		is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_12_BPC;
		break;
	default:
		is_dsc_possible = false;
	}

	if (!is_dsc_possible)
		goto done;

	// Slice width (i.e. number of slices per line)
	max_slices_h = get_max_dsc_slices(dsc_common_caps.slice_caps);

	while (max_slices_h > 0) {
		if (pic_width % max_slices_h == 0)
			break;

		max_slices_h = dec_num_slices(dsc_common_caps.slice_caps, max_slices_h);
	}

	is_dsc_possible = (dsc_common_caps.max_slice_width > 0);
	if (!is_dsc_possible)
		goto done;

	/* increase minimum slice count to meet sink slice width limitations */
	min_slices_h = dc_fixpt_ceil(dc_fixpt_max(
			dc_fixpt_div_int(dc_fixpt_from_int(pic_width), dsc_common_caps.max_slice_width), // sink min
			dc_fixpt_from_int(min_slices_h))); // source min

	min_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, min_slices_h);

	/* increase minimum slice count to meet sink throughput limitations */
	while (min_slices_h <= max_slices_h) {
		int pix_clk_per_slice_khz = dsc_div_by_10_round_up(timing->pix_clk_100hz) / min_slices_h;
		if (pix_clk_per_slice_khz <= sink_per_slice_throughput_mps * 1000)
			break;

		min_slices_h = inc_num_slices(dsc_common_caps.slice_caps, min_slices_h);
	}

	/* increase minimum slice count to meet divisibility requirements */
	while (pic_width % min_slices_h != 0 && min_slices_h <= max_slices_h) {
		min_slices_h = inc_num_slices(dsc_common_caps.slice_caps, min_slices_h);
	}

	is_dsc_possible = (min_slices_h <= max_slices_h) && max_slices_h != 0;
	if (!is_dsc_possible)
		goto done;

	if (policy.use_min_slices_h) {
		if (min_slices_h > 0)
			num_slices_h = min_slices_h;
		else if (max_slices_h > 0) { // Fall back to max slices if min slices is not working out
			if (policy.max_slices_h)
				num_slices_h = min(policy.max_slices_h, max_slices_h);
			else
				num_slices_h = max_slices_h;
		} else
			is_dsc_possible = false;
	} else {
		if (max_slices_h > 0) {
			if (policy.max_slices_h)
				num_slices_h = min(policy.max_slices_h, max_slices_h);
			else
				num_slices_h = max_slices_h;
		} else if (min_slices_h > 0) // Fall back to min slices if max slices is not possible
			num_slices_h = min_slices_h;
		else
			is_dsc_possible = false;
	}
	if (dsc_sink_caps->is_frl)
		num_slices_h = hdmi_dsc_get_num_slices(timing);
	// When we force ODM, num dsc h slices must be divisible by num odm h slices
	switch (options->dsc_force_odm_hslice_override) {
	case 0:
	case 1:
		break;
	case 2:
		if (num_slices_h < 2)
			num_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, 2);
		break;
	case 3:
		if (dsc_common_caps.slice_caps.bits.NUM_SLICES_12)
			num_slices_h = 12;
		else
			num_slices_h = 0;
		break;
	case 4:
		if (num_slices_h < 4)
			num_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, 4);
		break;
	default:
		break;
	}
	if (num_slices_h == 0)
		is_dsc_possible = false;
	if (!is_dsc_possible)
		goto done;

	dsc_cfg->num_slices_h = num_slices_h;
	slice_width = pic_width / num_slices_h;

	is_dsc_possible = slice_width <= dsc_common_caps.max_slice_width;
	if (!is_dsc_possible)
		goto done;

	// Slice height (i.e. number of slices per column): start with policy and pick the first one that height is divisible by.
	// For 4:2:0 make sure the slice height is divisible by 2 as well.
	if (options->dsc_min_slice_height_override == 0)
		slice_height = min(policy.min_slice_height, pic_height);
	else
		slice_height = min((int)(options->dsc_min_slice_height_override), pic_height);

	while (slice_height < pic_height && (pic_height % slice_height != 0 ||
		slice_height % options->slice_height_granularity != 0 ||
		(timing->pixel_encoding == PIXEL_ENCODING_YCBCR420 && slice_height % 2 != 0)))
		slice_height++;

	if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420) // For the case when pic_height < dsc_policy.min_sice_height
		is_dsc_possible = (slice_height % 2 == 0);

	if (!is_dsc_possible)
		goto done;

	if (slice_height > 0) {
		dsc_cfg->num_slices_v = pic_height / slice_height;
	} else {
		is_dsc_possible = false;
		goto done;
	}

	if (target_bandwidth_kbps > 0) {
		is_dsc_possible = decide_dsc_target_bpp_x16(
				&policy,
				options,
				&dsc_common_caps,
				target_bandwidth_kbps,
				timing,
				num_slices_h,
				link_encoding,
				&target_bpp);
		dsc_cfg->bits_per_pixel = target_bpp;
	}
	if (!is_dsc_possible)
		goto done;

	/* Fill out the rest of DSC settings */
	dsc_cfg->block_pred_enable = dsc_common_caps.is_block_pred_supported;
	dsc_cfg->linebuf_depth = dsc_common_caps.lb_bit_depth;
	dsc_cfg->version_minor = (dsc_common_caps.dsc_version & 0xf0) >> 4;
	dsc_cfg->is_frl = dsc_sink_caps->is_frl;
	if (dsc_cfg->is_frl)
		dsc_cfg->num_slices_h = num_slices_h;
	dsc_cfg->is_vic_all_bpp = dsc_sink_caps->is_vic_all_bpp;
	dsc_cfg->total_chunk_kbytes = dsc_sink_caps->total_chunk_kbytes;
	dsc_cfg->is_dp = dsc_sink_caps->is_dp;

done:
	if (!is_dsc_possible)
		memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));

	return is_dsc_possible;
}

bool dc_dsc_compute_config(
		const struct display_stream_compressor *dsc,
		const struct dsc_dec_dpcd_caps *dsc_sink_caps,
		const struct dc_dsc_config_options *options,
		uint32_t target_bandwidth_kbps,
		const struct dc_crtc_timing *timing,
		const enum dc_link_encoding_format link_encoding,
		struct dc_dsc_config *dsc_cfg)
{
	bool is_dsc_possible = false;
	struct dsc_enc_caps dsc_enc_caps;
	unsigned int min_dsc_slice_count;
	get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);

	min_dsc_slice_count = get_min_dsc_slice_count_for_odm(dsc, &dsc_enc_caps, timing);

	is_dsc_possible = setup_dsc_config(dsc_sink_caps,
		&dsc_enc_caps,
		target_bandwidth_kbps,
		timing,
		options,
		link_encoding,
		min_dsc_slice_count,
		dsc_cfg);
	return is_dsc_possible;
}

uint32_t dc_dsc_stream_bandwidth_in_kbps(const struct dc_crtc_timing *timing,
	uint32_t bpp_x16, uint32_t num_slices_h, bool is_dp)
{
	uint32_t overhead_in_kbps;
	struct fixed31_32 bpp;
	struct fixed31_32 actual_bandwidth_in_kbps;

	overhead_in_kbps = dc_dsc_stream_bandwidth_overhead_in_kbps(
		timing, num_slices_h, is_dp);
	bpp = dc_fixpt_from_fraction(bpp_x16, 16);
	actual_bandwidth_in_kbps = dc_fixpt_from_fraction(timing->pix_clk_100hz, 10);
	actual_bandwidth_in_kbps = dc_fixpt_mul(actual_bandwidth_in_kbps, bpp);
	actual_bandwidth_in_kbps = dc_fixpt_add_int(actual_bandwidth_in_kbps, overhead_in_kbps);
	return dc_fixpt_ceil(actual_bandwidth_in_kbps);
}

uint32_t dc_dsc_stream_bandwidth_overhead_in_kbps(
		const struct dc_crtc_timing *timing,
		const uint32_t num_slices_h,
		const bool is_dp)
{
	struct fixed31_32 max_dsc_overhead;
	struct fixed31_32 refresh_rate;

	if (dsc_policy_disable_dsc_stream_overhead || !is_dp)
		return 0;

	/* use target bpp that can take entire target bandwidth */
	refresh_rate = dc_fixpt_from_int(timing->pix_clk_100hz);
	refresh_rate = dc_fixpt_div_int(refresh_rate, timing->h_total);
	refresh_rate = dc_fixpt_div_int(refresh_rate, timing->v_total);
	refresh_rate = dc_fixpt_mul_int(refresh_rate, 100);

	max_dsc_overhead = dc_fixpt_from_int(num_slices_h);
	max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, timing->v_total);
	max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, 256);
	max_dsc_overhead = dc_fixpt_div_int(max_dsc_overhead, 1000);
	max_dsc_overhead = dc_fixpt_mul(max_dsc_overhead, refresh_rate);

	return dc_fixpt_ceil(max_dsc_overhead);
}

void dc_dsc_get_policy_for_timing(const struct dc_crtc_timing *timing,
		uint32_t max_target_bpp_limit_override_x16,
		struct dc_dsc_policy *policy,
		const enum dc_link_encoding_format link_encoding)
{
	uint32_t bpc = 0;

	policy->min_target_bpp = 0;
	policy->max_target_bpp = 0;

	/* DSC Policy: Use minimum number of slices that fits the pixel clock */
	policy->use_min_slices_h = true;

	/* DSC Policy: Use max available slices
	 * (in our case 4 for or 8, depending on the mode)
	 */
	policy->max_slices_h = 0;

	/* DSC Policy: Use slice height recommended
	 * by VESA DSC Spreadsheet user guide
	 */
	policy->min_slice_height = 108;

	/* DSC Policy: follow DP specs with an internal upper limit to 16 bpp
	 * for better interoperability
	 */
	switch (timing->display_color_depth) {
	case COLOR_DEPTH_888:
		bpc = 8;
		break;
	case COLOR_DEPTH_101010:
		bpc = 10;
		break;
	case COLOR_DEPTH_121212:
		bpc = 12;
		break;
	default:
		return;
	}
	switch (timing->pixel_encoding) {
	case PIXEL_ENCODING_RGB:
	case PIXEL_ENCODING_YCBCR444:
	case PIXEL_ENCODING_YCBCR422: /* assume no YCbCr422 native support */
		/* DP specs limits to 8 */
		policy->min_target_bpp = 8;
		/* DP specs limits to 3 x bpc */
		policy->max_target_bpp = 3 * bpc;
		policy->ycbcr422_simple = true;
		if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR422 && link_encoding == DC_LINK_ENCODING_HDMI_FRL) {
			/* HDMI FRL YCbCr422 native support */
			policy->min_target_bpp = 7;
			policy->max_target_bpp = 2 * bpc;
			policy->ycbcr422_simple = false;
		}
		break;
	case PIXEL_ENCODING_YCBCR420:
		/* DP specs limits to 6 */
		policy->min_target_bpp = 6;
		/* DP specs limits to 1.5 x bpc assume bpc is an even number */
		policy->max_target_bpp = bpc * 3 / 2;
		break;
	default:
		return;
	}

	/* internal upper limit, default 16 bpp */
	if (policy->max_target_bpp > dsc_policy_max_target_bpp_limit)
		policy->max_target_bpp = dsc_policy_max_target_bpp_limit;

	/* apply override */
	if (max_target_bpp_limit_override_x16 && policy->max_target_bpp > max_target_bpp_limit_override_x16 / 16)
		policy->max_target_bpp = max_target_bpp_limit_override_x16 / 16;

	/* enable DSC when not needed, default false */
	policy->enable_dsc_when_not_needed = dsc_policy_enable_dsc_when_not_needed;
}

void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit)
{
	dsc_policy_max_target_bpp_limit = limit;
}

void dc_dsc_policy_set_enable_dsc_when_not_needed(bool enable)
{
	dsc_policy_enable_dsc_when_not_needed = enable;
}

void dc_dsc_policy_set_disable_dsc_stream_overhead(bool disable)
{
	dsc_policy_disable_dsc_stream_overhead = disable;
}

void dc_set_disable_128b_132b_stream_overhead(bool disable)
{
	disable_128b_132b_stream_overhead = disable;
}

void dc_dsc_get_default_config_option(const struct dc *dc, struct dc_dsc_config_options *options)
{
	options->dsc_min_slice_height_override = dc->debug.dsc_min_slice_height_override;
	options->dsc_force_odm_hslice_override = dc->debug.force_odm_combine;
	options->max_target_bpp_limit_override_x16 = 0;
	options->slice_height_granularity = 1;
	options->force_dsc_when_not_needed = false;
}