From: Paul Hsieh <paul.hs...@amd.com>

[ Upstream commit 26a9f53198c955b15161da48cdb51041a38d5325 ]

[Why]
In 2560x1440@240p eDP panel, some use cases will enable MPC
combine with RGB MPO then underflow happened. This case is
not allowed from HW formula. 

[How]
Correct eDP, DP and DP2 output bpp calculation to align HW
formula.

Reviewed-by: Nicholas Kazlauskas <nicholas.kazlaus...@amd.com>
Acked-by: Qingqing Zhuo <qingqing.z...@amd.com>
Signed-off-by: Paul Hsieh <paul.hs...@amd.com>
Tested-by: Daniel Wheeler <daniel.whee...@amd.com>
Signed-off-by: Alex Deucher <alexander.deuc...@amd.com>
Signed-off-by: Sasha Levin <sas...@kernel.org>
---
 .../dc/dml/dcn31/display_mode_vba_31.c        | 298 ++++++++++++------
 .../dc/dml/dcn314/display_mode_vba_314.c      | 298 ++++++++++++------
 2 files changed, 392 insertions(+), 204 deletions(-)

diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn31/display_mode_vba_31.c 
b/drivers/gpu/drm/amd/display/dc/dml/dcn31/display_mode_vba_31.c
index 27f488405335f..8f8e2e7e5cc53 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/dcn31/display_mode_vba_31.c
+++ b/drivers/gpu/drm/amd/display/dc/dml/dcn31/display_mode_vba_31.c
@@ -4308,11 +4308,11 @@ void dml31_ModeSupportAndSystemConfigurationFull(struct 
display_mode_lib *mode_l
                                                        v->AudioSampleRate[k],
                                                        v->AudioSampleLayout[k],
                                                        
v->ODMCombineEnablePerState[i][k]);
-                               } else if (v->Output[k] == dm_dp || 
v->Output[k] == dm_edp) {
+                               } else if (v->Output[k] == dm_dp || 
v->Output[k] == dm_edp || v->Output[k] == dm_dp2p0) {
                                        if (v->DSCEnable[k] == true) {
                                                v->RequiresDSC[i][k] = true;
                                                v->LinkDSCEnable = true;
-                                               if (v->Output[k] == dm_dp) {
+                                               if (v->Output[k] == dm_dp || 
v->Output[k] == dm_dp2p0) {
                                                        v->RequiresFEC[i][k] = 
true;
                                                } else {
                                                        v->RequiresFEC[i][k] = 
false;
@@ -4320,107 +4320,201 @@ void 
dml31_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l
                                        } else {
                                                v->RequiresDSC[i][k] = false;
                                                v->LinkDSCEnable = false;
-                                               v->RequiresFEC[i][k] = false;
-                                       }
-
-                                       v->Outbpp = BPP_INVALID;
-                                       if (v->PHYCLKPerState[i] >= 270.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 2700,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 540.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 5400,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 810.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 8100,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKD18PerState[i] >= 10000.0 / 18) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 10000,
-                                                               4,
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               
//v->OutputTypeAndRatePerState[i][k] = v->Output[k] & "10x4";
+                                               if (v->Output[k] == dm_dp2p0) {
+                                                       v->RequiresFEC[i][k] = 
true;
+                                               } else {
+                                                       v->RequiresFEC[i][k] = 
false;
+                                               }
                                        }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKD18PerState[i] >= 12000.0 / 18) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               12000,
-                                                               4,
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               
//v->OutputTypeAndRatePerState[i][k] = v->Output[k] & "12x4";
+                                       if (v->Output[k] == dm_dp2p0) {
+                                               v->Outbpp = BPP_INVALID;
+                                               if ((v->OutputLinkDPRate[k] == 
dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr10) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 10000.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 10000,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->PHYCLKD18PerState[k] < 13500.0 / 18.0 &&
+                                                               v->DSCEnable[k] 
== true && v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 10000,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR10"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID &&
+                                                       (v->OutputLinkDPRate[k] 
== dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 13500.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 13500,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->PHYCLKD18PerState[k] < 20000.0 / 18.0 &&
+                                                               v->DSCEnable[k] 
== true && v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 13500,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR13p5"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID &&
+                                                       (v->OutputLinkDPRate[k] 
== dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr20) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 20000.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 20000,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->DSCEnable[k] == true &&
+                                                               
v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 20000,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR20"
+                                               }
+                                       } else {
+                                               v->Outbpp = BPP_INVALID;
+                                               if (v->PHYCLKPerState[i] >= 
270.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 2700,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 540.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 5400,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 810.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 8100,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
+                                               }
                                        }
                                }
                        } else {
diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn314/display_mode_vba_314.c 
b/drivers/gpu/drm/amd/display/dc/dml/dcn314/display_mode_vba_314.c
index c843b394aeb4a..e8bcae63f2656 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/dcn314/display_mode_vba_314.c
+++ b/drivers/gpu/drm/amd/display/dc/dml/dcn314/display_mode_vba_314.c
@@ -4406,11 +4406,11 @@ void 
dml314_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_
                                                        v->AudioSampleRate[k],
                                                        v->AudioSampleLayout[k],
                                                        
v->ODMCombineEnablePerState[i][k]);
-                               } else if (v->Output[k] == dm_dp || 
v->Output[k] == dm_edp) {
+                               } else if (v->Output[k] == dm_dp || 
v->Output[k] == dm_edp || v->Output[k] == dm_dp2p0) {
                                        if (v->DSCEnable[k] == true) {
                                                v->RequiresDSC[i][k] = true;
                                                v->LinkDSCEnable = true;
-                                               if (v->Output[k] == dm_dp) {
+                                               if (v->Output[k] == dm_dp || 
v->Output[k] == dm_dp2p0) {
                                                        v->RequiresFEC[i][k] = 
true;
                                                } else {
                                                        v->RequiresFEC[i][k] = 
false;
@@ -4418,107 +4418,201 @@ void 
dml314_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_
                                        } else {
                                                v->RequiresDSC[i][k] = false;
                                                v->LinkDSCEnable = false;
-                                               v->RequiresFEC[i][k] = false;
-                                       }
-
-                                       v->Outbpp = BPP_INVALID;
-                                       if (v->PHYCLKPerState[i] >= 270.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 2700,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 540.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 5400,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 810.0) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 8100,
-                                                               
v->OutputLinkDPLanes[k],
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               // TODO: Need some other way to 
handle this nonsense
-                                               // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
-                                       }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKD18PerState[i] >= 10000.0 / 18) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               (1.0 - 
v->Downspreading / 100.0) * 10000,
-                                                               4,
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               
//v->OutputTypeAndRatePerState[i][k] = v->Output[k] & "10x4";
+                                               if (v->Output[k] == dm_dp2p0) {
+                                                       v->RequiresFEC[i][k] = 
true;
+                                               } else {
+                                                       v->RequiresFEC[i][k] = 
false;
+                                               }
                                        }
-                                       if (v->Outbpp == BPP_INVALID && 
v->PHYCLKD18PerState[i] >= 12000.0 / 18) {
-                                               v->Outbpp = TruncToValidBPP(
-                                                               12000,
-                                                               4,
-                                                               v->HTotal[k],
-                                                               v->HActive[k],
-                                                               
v->PixelClockBackEnd[k],
-                                                               
v->ForcedOutputLinkBPP[k],
-                                                               
v->LinkDSCEnable,
-                                                               v->Output[k],
-                                                               
v->OutputFormat[k],
-                                                               
v->DSCInputBitPerComponent[k],
-                                                               
v->NumberOfDSCSlices[k],
-                                                               
v->AudioSampleRate[k],
-                                                               
v->AudioSampleLayout[k],
-                                                               
v->ODMCombineEnablePerState[i][k]);
-                                               v->OutputBppPerState[i][k] = 
v->Outbpp;
-                                               
//v->OutputTypeAndRatePerState[i][k] = v->Output[k] & "12x4";
+                                       if (v->Output[k] == dm_dp2p0) {
+                                               v->Outbpp = BPP_INVALID;
+                                               if ((v->OutputLinkDPRate[k] == 
dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr10) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 10000.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 10000,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->PHYCLKD18PerState[k] < 13500.0 / 18.0 &&
+                                                               v->DSCEnable[k] 
== true && v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 10000,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR10"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID &&
+                                                       (v->OutputLinkDPRate[k] 
== dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 13500.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 13500,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->PHYCLKD18PerState[k] < 20000.0 / 18.0 &&
+                                                               v->DSCEnable[k] 
== true && v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 13500,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR13p5"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID &&
+                                                       (v->OutputLinkDPRate[k] 
== dm_dp_rate_na || v->OutputLinkDPRate[k] == dm_dp_rate_uhbr20) &&
+                                                       v->PHYCLKD18PerState[k] 
>= 20000.0 / 18.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 20000,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       if (v->Outbpp == 
BPP_INVALID && v->DSCEnable[k] == true &&
+                                                               
v->ForcedOutputLinkBPP[k] == 0) {
+                                                               
v->RequiresDSC[i][k] = true;
+                                                               
v->LinkDSCEnable = true;
+                                                               v->Outbpp = 
TruncToValidBPP(
+                                                                               
(1.0 - v->Downspreading / 100.0) * 20000,
+                                                                               
v->OutputLinkDPLanes[k],
+                                                                               
v->HTotal[k],
+                                                                               
v->HActive[k],
+                                                                               
v->PixelClockBackEnd[k],
+                                                                               
v->ForcedOutputLinkBPP[k],
+                                                                               
v->LinkDSCEnable,
+                                                                               
v->Output[k],
+                                                                               
v->OutputFormat[k],
+                                                                               
v->DSCInputBitPerComponent[k],
+                                                                               
v->NumberOfDSCSlices[k],
+                                                                               
v->AudioSampleRate[k],
+                                                                               
v->AudioSampleLayout[k],
+                                                                               
v->ODMCombineEnablePerState[i][k]);
+                                                       }
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " UHBR20"
+                                               }
+                                       } else {
+                                               v->Outbpp = BPP_INVALID;
+                                               if (v->PHYCLKPerState[i] >= 
270.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 2700,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 540.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 5400,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
+                                               }
+                                               if (v->Outbpp == BPP_INVALID && 
v->PHYCLKPerState[i] >= 810.0) {
+                                                       v->Outbpp = 
TruncToValidBPP(
+                                                                       (1.0 - 
v->Downspreading / 100.0) * 8100,
+                                                                       
v->OutputLinkDPLanes[k],
+                                                                       
v->HTotal[k],
+                                                                       
v->HActive[k],
+                                                                       
v->PixelClockBackEnd[k],
+                                                                       
v->ForcedOutputLinkBPP[k],
+                                                                       
v->LinkDSCEnable,
+                                                                       
v->Output[k],
+                                                                       
v->OutputFormat[k],
+                                                                       
v->DSCInputBitPerComponent[k],
+                                                                       
v->NumberOfDSCSlices[k],
+                                                                       
v->AudioSampleRate[k],
+                                                                       
v->AudioSampleLayout[k],
+                                                                       
v->ODMCombineEnablePerState[i][k]);
+                                                       
v->OutputBppPerState[i][k] = v->Outbpp;
+                                                       // TODO: Need some 
other way to handle this nonsense
+                                                       // 
v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
+                                               }
                                        }
                                }
                        } else {
-- 
2.39.2

Reply via email to