Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Revert "drm/amd/display: Fix pbn to kbps Conversion"
Deeply daisy chained DP/MST displays are no longer able to light
up. This reverts commit e0dec00f3d05 ("drm/amd/display: Fix pbn
to kbps Conversion")
Cc: Jerry Zuo <jerry.zuo@amd.com>
Reported-by: nat@nullable.se
Closes: https://gitlab.freedesktop.org/drm/amd/-/issues/4756
Signed-off-by: Mario Limonciello <mario.limonciello@amd.com>
Acked-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
authored by
Mario Limonciello
and committed by
Alex Deucher
e1c94109
84d8beaf
+36
-23
+36
-23
drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c
+36
-23
drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c
···
884
884
};
885
885
886
886
#if defined(CONFIG_DRM_AMD_DC_FP)
887
-
static uint64_t kbps_to_pbn(int kbps, bool is_peak_pbn)
887
+
static uint16_t get_fec_overhead_multiplier(struct dc_link *dc_link)
888
888
{
889
-
uint64_t effective_kbps = (uint64_t)kbps;
889
+
u8 link_coding_cap;
890
+
uint16_t fec_overhead_multiplier_x1000 = PBN_FEC_OVERHEAD_MULTIPLIER_8B_10B;
890
891
891
-
if (is_peak_pbn) { // add 0.6% (1006/1000) overhead into effective kbps
892
-
effective_kbps *= 1006;
893
-
effective_kbps = div_u64(effective_kbps, 1000);
894
-
}
892
+
link_coding_cap = dc_link_dp_mst_decide_link_encoding_format(dc_link);
893
+
if (link_coding_cap == DP_128b_132b_ENCODING)
894
+
fec_overhead_multiplier_x1000 = PBN_FEC_OVERHEAD_MULTIPLIER_128B_132B;
895
895
896
-
return (uint64_t) DIV64_U64_ROUND_UP(effective_kbps * 64, (54 * 8 * 1000));
896
+
return fec_overhead_multiplier_x1000;
897
897
}
898
898
899
-
static uint32_t pbn_to_kbps(unsigned int pbn, bool with_margin)
899
+
static int kbps_to_peak_pbn(int kbps, uint16_t fec_overhead_multiplier_x1000)
900
900
{
901
-
uint64_t pbn_effective = (uint64_t)pbn;
901
+
u64 peak_kbps = kbps;
902
902
903
-
if (with_margin) // deduct 0.6% (994/1000) overhead from effective pbn
904
-
pbn_effective *= (1000000 / PEAK_FACTOR_X1000);
905
-
else
906
-
pbn_effective *= 1000;
907
-
908
-
return DIV_U64_ROUND_UP(pbn_effective * 8 * 54, 64);
903
+
peak_kbps *= 1006;
904
+
peak_kbps *= fec_overhead_multiplier_x1000;
905
+
peak_kbps = div_u64(peak_kbps, 1000 * 1000);
906
+
return (int) DIV64_U64_ROUND_UP(peak_kbps * 64, (54 * 8 * 1000));
909
907
}
910
908
911
909
static void set_dsc_configs_from_fairness_vars(struct dsc_mst_fairness_params *params,
···
974
976
dc_dsc_get_default_config_option(param.sink->ctx->dc, &dsc_options);
975
977
dsc_options.max_target_bpp_limit_override_x16 = drm_connector->display_info.max_dsc_bpp * 16;
976
978
977
-
kbps = pbn_to_kbps(pbn, false);
979
+
kbps = div_u64((u64)pbn * 994 * 8 * 54, 64);
978
980
dc_dsc_compute_config(
979
981
param.sink->ctx->dc->res_pool->dscs[0],
980
982
¶m.sink->dsc_caps.dsc_dec_caps,
···
1003
1005
int link_timeslots_used;
1004
1006
int fair_pbn_alloc;
1005
1007
int ret = 0;
1008
+
uint16_t fec_overhead_multiplier_x1000 = get_fec_overhead_multiplier(dc_link);
1006
1009
1007
1010
for (i = 0; i < count; i++) {
1008
1011
if (vars[i + k].dsc_enabled) {
1009
1012
initial_slack[i] =
1010
-
kbps_to_pbn(params[i].bw_range.max_kbps, false) - vars[i + k].pbn;
1013
+
kbps_to_peak_pbn(params[i].bw_range.max_kbps, fec_overhead_multiplier_x1000) - vars[i + k].pbn;
1011
1014
bpp_increased[i] = false;
1012
1015
remaining_to_increase += 1;
1013
1016
} else {
···
1104
1105
int next_index;
1105
1106
int remaining_to_try = 0;
1106
1107
int ret;
1108
+
uint16_t fec_overhead_multiplier_x1000 = get_fec_overhead_multiplier(dc_link);
1107
1109
int var_pbn;
1108
1110
1109
1111
for (i = 0; i < count; i++) {
···
1137
1137
1138
1138
DRM_DEBUG_DRIVER("MST_DSC index #%d, try no compression\n", next_index);
1139
1139
var_pbn = vars[next_index].pbn;
1140
-
vars[next_index].pbn = kbps_to_pbn(params[next_index].bw_range.stream_kbps, true);
1140
+
vars[next_index].pbn = kbps_to_peak_pbn(params[next_index].bw_range.stream_kbps, fec_overhead_multiplier_x1000);
1141
1141
ret = drm_dp_atomic_find_time_slots(state,
1142
1142
params[next_index].port->mgr,
1143
1143
params[next_index].port,
···
1197
1197
int count = 0;
1198
1198
int i, k, ret;
1199
1199
bool debugfs_overwrite = false;
1200
+
uint16_t fec_overhead_multiplier_x1000 = get_fec_overhead_multiplier(dc_link);
1200
1201
struct drm_connector_state *new_conn_state;
1201
1202
1202
1203
memset(params, 0, sizeof(params));
···
1278
1277
DRM_DEBUG_DRIVER("MST_DSC Try no compression\n");
1279
1278
for (i = 0; i < count; i++) {
1280
1279
vars[i + k].aconnector = params[i].aconnector;
1281
-
vars[i + k].pbn = kbps_to_pbn(params[i].bw_range.stream_kbps, false);
1280
+
vars[i + k].pbn = kbps_to_peak_pbn(params[i].bw_range.stream_kbps, fec_overhead_multiplier_x1000);
1282
1281
vars[i + k].dsc_enabled = false;
1283
1282
vars[i + k].bpp_x16 = 0;
1284
1283
ret = drm_dp_atomic_find_time_slots(state, params[i].port->mgr, params[i].port,
···
1300
1299
DRM_DEBUG_DRIVER("MST_DSC Try max compression\n");
1301
1300
for (i = 0; i < count; i++) {
1302
1301
if (params[i].compression_possible && params[i].clock_force_enable != DSC_CLK_FORCE_DISABLE) {
1303
-
vars[i + k].pbn = kbps_to_pbn(params[i].bw_range.min_kbps, false);
1302
+
vars[i + k].pbn = kbps_to_peak_pbn(params[i].bw_range.min_kbps, fec_overhead_multiplier_x1000);
1304
1303
vars[i + k].dsc_enabled = true;
1305
1304
vars[i + k].bpp_x16 = params[i].bw_range.min_target_bpp_x16;
1306
1305
ret = drm_dp_atomic_find_time_slots(state, params[i].port->mgr,
···
1308
1307
if (ret < 0)
1309
1308
return ret;
1310
1309
} else {
1311
-
vars[i + k].pbn = kbps_to_pbn(params[i].bw_range.stream_kbps, false);
1310
+
vars[i + k].pbn = kbps_to_peak_pbn(params[i].bw_range.stream_kbps, fec_overhead_multiplier_x1000);
1312
1311
vars[i + k].dsc_enabled = false;
1313
1312
vars[i + k].bpp_x16 = 0;
1314
1313
ret = drm_dp_atomic_find_time_slots(state, params[i].port->mgr,
···
1763
1762
return ret;
1764
1763
}
1765
1764
1765
+
static uint32_t kbps_from_pbn(unsigned int pbn)
1766
+
{
1767
+
uint64_t kbps = (uint64_t)pbn;
1768
+
1769
+
kbps *= (1000000 / PEAK_FACTOR_X1000);
1770
+
kbps *= 8;
1771
+
kbps *= 54;
1772
+
kbps /= 64;
1773
+
1774
+
return (uint32_t)kbps;
1775
+
}
1776
+
1766
1777
static bool is_dsc_common_config_possible(struct dc_stream_state *stream,
1767
1778
struct dc_dsc_bw_range *bw_range)
1768
1779
{
···
1873
1860
dc_link_get_highest_encoding_format(stream->link));
1874
1861
cur_link_settings = stream->link->verified_link_cap;
1875
1862
root_link_bw_in_kbps = dc_link_bandwidth_kbps(aconnector->dc_link, &cur_link_settings);
1876
-
virtual_channel_bw_in_kbps = pbn_to_kbps(aconnector->mst_output_port->full_pbn, true);
1863
+
virtual_channel_bw_in_kbps = kbps_from_pbn(aconnector->mst_output_port->full_pbn);
1877
1864
1878
1865
/* pick the end to end bw bottleneck */
1879
1866
end_to_end_bw_in_kbps = min(root_link_bw_in_kbps, virtual_channel_bw_in_kbps);
···
1926
1913
immediate_upstream_port = aconnector->mst_output_port->parent->port_parent;
1927
1914
1928
1915
if (immediate_upstream_port) {
1929
-
virtual_channel_bw_in_kbps = pbn_to_kbps(immediate_upstream_port->full_pbn, true);
1916
+
virtual_channel_bw_in_kbps = kbps_from_pbn(immediate_upstream_port->full_pbn);
1930
1917
virtual_channel_bw_in_kbps = min(root_link_bw_in_kbps, virtual_channel_bw_in_kbps);
1931
1918
} else {
1932
1919
/* For topology LCT 1 case - only one mstb*/