#include "dml2_core_dcn6_funcs_mode_programming.h"
#include "dml2_core_dcn6_calcs.h"
#include "dml2_core_utils.h"
static const struct dml2_core_dcn6_calcs *get_calcs(const struct dml2_core_calculate_mp_context *ctx)
{
return ctx->calcs->dcn6;
}
static void dcn6_mp_populate_odm_mode(const struct dml2_display_solution *solution,
struct dml2_core_internal_mode_program *outputs)
{
unsigned int k;
const struct core_display_cfg_support_info *cfg_support_info =
&solution->validation_result.mode_support.cfg_support_info;
const struct dml2_display_cfg *display_cfg = &solution->dispcfg;
unsigned int stream_index;
for (k = 0; k < solution->dispcfg.num_planes; ++k) {
stream_index = display_cfg->plane_descriptors[k].stream_index;
DML_ASSERT(cfg_support_info->stream_support_info[stream_index].odms_used <= 4);
DML_ASSERT(cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 4
|| cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 2
|| cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 1);
if (cfg_support_info->stream_support_info[stream_index].odms_used > 1)
DML_ASSERT(cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 1);
switch (cfg_support_info->stream_support_info[stream_index].odms_used) {
case (4):
outputs->ODMMode[k] = dml2_odm_mode_combine_4to1;
break;
case (3):
outputs->ODMMode[k] = dml2_odm_mode_combine_3to1;
break;
case (2):
outputs->ODMMode[k] = dml2_odm_mode_combine_2to1;
break;
default:
if (cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 4)
outputs->ODMMode[k] = dml2_odm_mode_mso_1to4;
else if (cfg_support_info->stream_support_info[stream_index].num_odm_output_segments == 2)
outputs->ODMMode[k] = dml2_odm_mode_mso_1to2;
else
outputs->ODMMode[k] = dml2_odm_mode_bypass;
break;
}
}
}
static void dcn6_mp_calculate_dcc_configurations(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
unsigned int k;
for (k = 0; k < display_cfg->num_planes; ++k) {
DML_LOG_VERBOSE("DML::%s: Calculate DCC configuration for surface k=%u\n", __func__, k);
get_calcs(ctx)->calculate_dcc_configuration(
display_cfg->plane_descriptors[k].surface.dcc.enable,
display_cfg->overrides.dcc_programming_assumes_scan_direction_unknown,
display_cfg->plane_descriptors[k].pixel_format,
display_cfg->plane_descriptors[k].surface.plane0.width,
display_cfg->plane_descriptors[k].surface.plane1.width,
display_cfg->plane_descriptors[k].surface.plane0.height,
display_cfg->plane_descriptors[k].surface.plane1.height,
inputs->NomDETInKByte,
inputs->Read256BlockHeightY[k],
inputs->Read256BlockHeightC[k],
display_cfg->plane_descriptors[k].surface.tiling,
inputs->BytePerPixelY[k],
inputs->BytePerPixelC[k],
inputs->BytePerPixelInDETY[k],
inputs->BytePerPixelInDETC[k],
display_cfg->plane_descriptors[k].composition.rotation_angle,
&outputs->RequestLuma[k],
&outputs->RequestChroma[k],
&outputs->DCCYMaxUncompressedBlock[k],
&outputs->DCCCMaxUncompressedBlock[k],
&outputs->DCCYMaxCompressedBlock[k],
&outputs->DCCCMaxCompressedBlock[k],
&outputs->DCCYIndependentBlock[k],
&outputs->DCCCIndependentBlock[k]);
}
}
static void dcn6_mp_calculate_pixel_delivery_times(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
get_calcs(ctx)->calculate_pixel_delivery_times(
display_cfg,
inputs->NoOfDPP,
display_cfg->num_planes,
inputs->VRatioPrefetchY,
inputs->VRatioPrefetchC,
inputs->swath_width_luma_ub,
inputs->swath_width_chroma_ub,
inputs->PSCL_THROUGHPUT,
inputs->PSCL_THROUGHPUT_CHROMA,
inputs->Dppclk,
inputs->DCFCLKDeepSleep,
inputs->BytePerPixelY,
inputs->BytePerPixelC,
inputs->req_per_swath_ub_l,
inputs->req_per_swath_ub_c,
outputs->DisplayPipeLineDeliveryTimeLuma,
outputs->DisplayPipeLineDeliveryTimeChroma,
outputs->DisplayPipeLineDeliveryTimeLumaPrefetch,
outputs->DisplayPipeLineDeliveryTimeChromaPrefetch,
outputs->DisplayPipeRequestDeliveryTimeLuma,
outputs->DisplayPipeRequestDeliveryTimeChroma,
outputs->DisplayPipeRequestDeliveryTimeLumaPrefetch,
outputs->DisplayPipeRequestDeliveryTimeChromaPrefetch);
}
static void dcn6_mp_calculate_meta_and_pte_times(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
const struct dml2_core_ip_params *ip = ctx->ip;
struct dml2_core_internal_scratch *func_params = ctx->func_params;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
struct dml2_core_shared_CalculateMetaAndPTETimes_params *p = &func_params->CalculateMetaAndPTETimes_params;
p->scratch = func_params;
p->display_cfg = display_cfg;
p->NumberOfActiveSurfaces = display_cfg->num_planes;
p->use_one_row_for_frame = inputs->use_one_row_for_frame;
p->dst_y_per_row_vblank = inputs->dst_y_per_row_vblank;
p->dst_y_per_row_flip = inputs->dst_y_per_row_flip;
p->BytePerPixelY = inputs->BytePerPixelY;
p->BytePerPixelC = inputs->BytePerPixelC;
p->dpte_row_height = inputs->dpte_row_height;
p->dpte_row_height_chroma = inputs->dpte_row_height_chroma;
p->dpte_group_bytes = inputs->dpte_group_bytes;
p->PTERequestSizeY = inputs->PTERequestSizeY;
p->PTERequestSizeC = inputs->PTERequestSizeC;
p->PixelPTEReqWidthY = inputs->PixelPTEReqWidthY;
p->PixelPTEReqHeightY = inputs->PixelPTEReqHeightY;
p->PixelPTEReqWidthC = inputs->PixelPTEReqWidthC;
p->PixelPTEReqHeightC = inputs->PixelPTEReqHeightC;
p->dpte_row_width_luma_ub = inputs->dpte_row_width_luma_ub;
p->dpte_row_width_chroma_ub = inputs->dpte_row_width_chroma_ub;
p->tdlut_groups_per_2row_ub = inputs->tdlut_groups_per_2row_ub;
p->mrq_present = ip->dcn_mrq_present;
p->MetaChunkSize = ip->meta_chunk_size_kbytes;
p->MinMetaChunkSizeBytes = ip->min_meta_chunk_size_bytes;
p->meta_row_width = inputs->meta_row_width;
p->meta_row_width_chroma = inputs->meta_row_width_chroma;
p->meta_row_height = inputs->meta_row_height;
p->meta_row_height_chroma = inputs->meta_row_height_chroma;
p->meta_req_width = inputs->meta_req_width;
p->meta_req_width_chroma = inputs->meta_req_width_chroma;
p->meta_req_height = inputs->meta_req_height;
p->meta_req_height_chroma = inputs->meta_req_height_chroma;
p->time_per_tdlut_group = outputs->time_per_tdlut_group;
p->DST_Y_PER_PTE_ROW_NOM_L = outputs->DST_Y_PER_PTE_ROW_NOM_L;
p->DST_Y_PER_PTE_ROW_NOM_C = outputs->DST_Y_PER_PTE_ROW_NOM_C;
p->time_per_pte_group_nom_luma = outputs->time_per_pte_group_nom_luma;
p->time_per_pte_group_vblank_luma = outputs->time_per_pte_group_vblank_luma;
p->time_per_pte_group_flip_luma = outputs->time_per_pte_group_flip_luma;
p->time_per_pte_group_nom_chroma = outputs->time_per_pte_group_nom_chroma;
p->time_per_pte_group_vblank_chroma = outputs->time_per_pte_group_vblank_chroma;
p->time_per_pte_group_flip_chroma = outputs->time_per_pte_group_flip_chroma;
p->DST_Y_PER_META_ROW_NOM_L = outputs->DST_Y_PER_META_ROW_NOM_L;
p->DST_Y_PER_META_ROW_NOM_C = outputs->DST_Y_PER_META_ROW_NOM_C;
p->TimePerMetaChunkNominal = outputs->TimePerMetaChunkNominal;
p->TimePerChromaMetaChunkNominal = outputs->TimePerChromaMetaChunkNominal;
p->TimePerMetaChunkVBlank = outputs->TimePerMetaChunkVBlank;
p->TimePerChromaMetaChunkVBlank = outputs->TimePerChromaMetaChunkVBlank;
p->TimePerMetaChunkFlip = outputs->TimePerMetaChunkFlip;
p->TimePerChromaMetaChunkFlip = outputs->TimePerChromaMetaChunkFlip;
get_calcs(ctx)->calculate_meta_and_pte_times(p);
}
static void dcn6_mp_calculate_vm_group_and_request_times(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
const struct dml2_core_ip_params *ip = ctx->ip;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
get_calcs(ctx)->calculate_vm_group_and_request_times(
display_cfg,
display_cfg->num_planes,
inputs->BytePerPixelC,
inputs->dst_y_per_vm_vblank,
inputs->dst_y_per_vm_flip,
inputs->dpte_row_width_luma_ub,
inputs->dpte_row_width_chroma_ub,
inputs->vm_group_bytes,
inputs->dpde0_bytes_per_frame_ub_l,
inputs->dpde0_bytes_per_frame_ub_c,
inputs->tdlut_pte_bytes_per_frame,
inputs->meta_pte_bytes_per_frame_ub_l,
inputs->meta_pte_bytes_per_frame_ub_c,
ip->dcn_mrq_present,
outputs->TimePerVMGroupVBlank,
outputs->TimePerVMGroupFlip,
outputs->TimePerVMRequestVBlank,
outputs->TimePerVMRequestFlip);
}
static void dcn6_mp_calculate_vstartup_adjustment(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
const struct dml2_core_ip_params *ip = ctx->ip;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
unsigned int k;
bool isInterlaceTiming;
const struct dml2_plane_parameters *plane;
const struct dml2_stream_parameters *stream;
double Tvstartup_margin;
double dlg_vblank_start;
double LSetup;
double blank_lines_remaining;
for (k = 0; k < display_cfg->num_planes; ++k) {
plane = &display_cfg->plane_descriptors[k];
stream = &display_cfg->stream_descriptors[plane->stream_index];
isInterlaceTiming = (stream->timing.interlaced && !ip->ptoi_supported);
outputs->MinTTUVBlank[k] = inputs->TWait[k] + inputs->ExtraLatency;
if (!display_cfg->plane_descriptors[k].dynamic_meta_data.enable)
outputs->MinTTUVBlank[k] = inputs->TCalc + outputs->MinTTUVBlank[k];
DML_LOG_VERBOSE("DML::%s: k=%u, MinTTUVBlank = %f (before vstartup margin)\n",
__func__, k, outputs->MinTTUVBlank[k]);
Tvstartup_margin = (inputs->MaxVStartupLines[k] - inputs->VStartupMin[k])
* stream->timing.h_total
/ ((double)stream->timing.pixel_clock_khz / 1000);
outputs->MinTTUVBlank[k] = outputs->MinTTUVBlank[k] + Tvstartup_margin;
DML_LOG_VERBOSE("DML::%s: k=%u, Tvstartup_margin = %f\n", __func__, k, Tvstartup_margin);
DML_LOG_VERBOSE("DML::%s: k=%u, MaxVStartupLines = %u\n", __func__, k, inputs->MaxVStartupLines[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, MinTTUVBlank = %f\n", __func__, k, outputs->MinTTUVBlank[k]);
outputs->Tdmdl[k] = inputs->Tdmdl_raw[k] + Tvstartup_margin;
if (plane->dynamic_meta_data.enable && ip->dynamic_metadata_vm_enabled)
outputs->Tdmdl_vm[k] = inputs->Tdmdl_vm_raw[k] + Tvstartup_margin;
else
outputs->Tdmdl_vm[k] = inputs->Tdmdl_vm_raw[k];
outputs->VStartup[k] = (isInterlaceTiming ?
(2 * inputs->MaxVStartupLines[k]) : inputs->MaxVStartupLines[k]);
dlg_vblank_start =
((isInterlaceTiming ?
math_floor2((stream->timing.v_total - stream->timing.v_front_porch) / 2.0, 1.0) :
stream->timing.v_total)
- stream->timing.v_front_porch);
LSetup = math_floor2(
4.0 * inputs->TSetup[k]
/ ((double)stream->timing.h_total
/ ((double)stream->timing.pixel_clock_khz / 1000)),
1.0) / 4.0;
blank_lines_remaining = (stream->timing.v_total - stream->timing.v_active) - outputs->VStartup[k];
if (blank_lines_remaining < 0) {
DML_LOG_VERBOSE("ERROR: Vstartup is larger than vblank!?\n");
blank_lines_remaining = 0;
DML_ASSERT(0);
}
outputs->MIN_DST_Y_NEXT_START[k] = dlg_vblank_start + blank_lines_remaining + LSetup;
if (((inputs->VUpdateOffsetPix[k] + inputs->VUpdateWidthPix[k] + inputs->VReadyOffsetPix[k]) / (double) stream->timing.h_total)
<= (isInterlaceTiming ?
math_floor2((stream->timing.v_total - stream->timing.v_active - stream->timing.v_front_porch - outputs->VStartup[k]) / 2.0, 1.0) :
(int)(stream->timing.v_total - stream->timing.v_active - stream->timing.v_front_porch - outputs->VStartup[k]))) {
outputs->VREADY_AT_OR_AFTER_VSYNC[k] = true;
} else {
outputs->VREADY_AT_OR_AFTER_VSYNC[k] = false;
}
DML_LOG_VERBOSE("DML::%s: k=%u, VStartup = %u (max)\n", __func__, k, outputs->VStartup[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, VStartupMin = %u (max)\n", __func__, k, inputs->VStartupMin[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, VUpdateOffsetPix = %u\n", __func__, k, inputs->VUpdateOffsetPix[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, VUpdateWidthPix = %u\n", __func__, k, inputs->VUpdateWidthPix[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, VReadyOffsetPix = %u\n", __func__, k, inputs->VReadyOffsetPix[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, HTotal = %lu\n", __func__, k, stream->timing.h_total);
DML_LOG_VERBOSE("DML::%s: k=%u, VTotal = %lu\n", __func__, k, stream->timing.v_total);
DML_LOG_VERBOSE("DML::%s: k=%u, VActive = %lu\n", __func__, k, stream->timing.v_active);
DML_LOG_VERBOSE("DML::%s: k=%u, VFrontPorch = %lu\n", __func__, k, stream->timing.v_front_porch);
DML_LOG_VERBOSE("DML::%s: k=%u, TSetup = %f\n", __func__, k, inputs->TSetup[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, MIN_DST_Y_NEXT_START = %f\n",
__func__, k, outputs->MIN_DST_Y_NEXT_START[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, VREADY_AT_OR_AFTER_VSYNC = %u\n",
__func__, k, (unsigned char)outputs->VREADY_AT_OR_AFTER_VSYNC[k]);
}
}
static void dcn6_mp_calculate_max_bandwidth_used(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
unsigned int j, k;
const struct dml2_stream_parameters *stream;
double WRBandwidth;
outputs->TotalWRBandwidth = 0;
for (k = 0; k < display_cfg->num_streams; ++k) {
stream = &display_cfg->stream_descriptors[k];
for (j = 0; j < stream->writeback.active_writebacks_per_stream; ++j) {
double writeback_bytes_per_pixel;
if (stream->writeback.writeback_stream[j].pixel_format == dml2_444_64)
writeback_bytes_per_pixel = 8.0;
else if (stream->writeback.writeback_stream[j].pixel_format == dml2_444_32)
writeback_bytes_per_pixel = 4.0;
else if (stream->writeback.writeback_stream[j].pixel_format == dml2_420_8)
writeback_bytes_per_pixel = 1.5;
else if (stream->writeback.writeback_stream[j].pixel_format == dml2_420_10)
writeback_bytes_per_pixel = 3.0;
else if (stream->writeback.writeback_stream[j].pixel_format == dml2_422_packed_8)
writeback_bytes_per_pixel = 2.0;
else if (stream->writeback.writeback_stream[j].pixel_format == dml2_422_packed_10)
writeback_bytes_per_pixel = 4.0;
else
writeback_bytes_per_pixel = 0.0;
WRBandwidth = stream->writeback.writeback_stream[j].output_height
* stream->writeback.writeback_stream[j].output_width
/ (stream->timing.h_total
* stream->writeback.writeback_stream[j].input_height
/ ((double)stream->timing.pixel_clock_khz / 1000))
* writeback_bytes_per_pixel;
outputs->TotalWRBandwidth = outputs->TotalWRBandwidth + WRBandwidth;
}
}
outputs->TotalDataReadBandwidth = 0;
for (k = 0; k < display_cfg->num_planes; ++k) {
outputs->TotalDataReadBandwidth =
outputs->TotalDataReadBandwidth
+ inputs->vactive_sw_bw_l[k]
+ inputs->vactive_sw_bw_c[k];
DML_LOG_VERBOSE("DML::%s: k=%u, TotalDataReadBandwidth = %f\n",
__func__, k, outputs->TotalDataReadBandwidth);
DML_LOG_VERBOSE("DML::%s: k=%u, vactive_sw_bw_l = %f\n", __func__, k, inputs->vactive_sw_bw_l[k]);
DML_LOG_VERBOSE("DML::%s: k=%u, vactive_sw_bw_c = %f\n", __func__, k, inputs->vactive_sw_bw_c[k]);
}
}
static void dcn6_mp_calculate_stutter_efficiency(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
const struct dml2_core_ip_params *ip = ctx->ip;
const struct dml2_utm_soc_bb *soc_bb = ctx->soc_bb;
struct dml2_core_internal_scratch *func_params = ctx->func_params;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
struct dml2_core_calcs_CalculateStutterEfficiency_params *p =
&func_params->CalculateStutterEfficiency_params;
p->display_cfg = display_cfg;
p->CompressedBufferSizeInkByte = inputs->CompressedBufferSizeInkByte;
p->UnboundedRequestEnabled = inputs->UnboundedRequestEnabled;
p->MetaFIFOSizeInKEntries = ip->meta_fifo_size_in_kentries;
p->ZeroSizeBufferEntries = ip->zero_size_buffer_entries;
p->PixelChunkSizeInKByte = ip->pixel_chunk_size_kbytes;
p->NumberOfActiveSurfaces = display_cfg->num_planes;
p->ROBBufferSizeInKByte = ip->rob_buffer_size_kbytes;
p->TotalDataReadBandwidth = inputs->TotalDataReadBandwidth;
p->DCFCLK = inputs->Dcfclk;
p->ReturnBW = **inputs->urg_bandwidth_available;
p->CompbufReservedSpace64B = inputs->compbuf_reserved_space_64b;
p->CompbufReservedSpaceZs = ip->compbuf_reserved_space_zs;
p->SRExitTime = soc_bb->power_management_parameters.stutter_exit_latency_us;
p->SRExitTimeLowPower = soc_bb->power_management_parameters.low_power_stutter_exit_latency_us;
p->SRExitZ8Time = soc_bb->power_management_parameters.z8_stutter_exit_latency_us;
p->SynchronizeTimings = display_cfg->overrides.synchronize_timings;
p->StutterEnterPlusExitWatermark = inputs->Watermark.StutterEnterPlusExitWatermark;
p->LowPowerStutterEnterPlusExitWatermark = inputs->Watermark.LowPowerStutterEnterPlusExitWatermark;
p->Z8StutterEnterPlusExitWatermark = inputs->Watermark.Z8StutterEnterPlusExitWatermark;
p->ProgressiveToInterlaceUnitInOPP = ip->ptoi_supported;
p->MinTTUVBlank = inputs->MinTTUVBlank;
p->DPPPerSurface = inputs->NoOfDPP;
p->DETBufferSizeY = inputs->DETBufferSizeY;
p->BytePerPixelY = inputs->BytePerPixelY;
p->BytePerPixelDETY = inputs->BytePerPixelInDETY;
p->SwathWidthY = inputs->SwathWidthY;
p->SwathHeightY = inputs->SwathHeightY;
p->SwathHeightC = inputs->SwathHeightC;
p->BlockHeight256BytesY = inputs->Read256BlockHeightY;
p->BlockWidth256BytesY = inputs->Read256BlockWidthY;
p->BlockHeight256BytesC = inputs->Read256BlockHeightC;
p->BlockWidth256BytesC = inputs->Read256BlockWidthC;
p->DCCYMaxUncompressedBlock = inputs->DCCYMaxUncompressedBlock;
p->DCCCMaxUncompressedBlock = inputs->DCCCMaxUncompressedBlock;
p->ReadBandwidthSurfaceLuma = inputs->vactive_sw_bw_l;
p->ReadBandwidthSurfaceChroma = inputs->vactive_sw_bw_c;
p->dpte_row_bw = inputs->dpte_row_bw;
p->meta_row_bw = inputs->meta_row_bw;
p->rob_alloc_compressed = ip->dcn_mrq_present;
p->StutterEfficiencyNotIncludingVBlank = &outputs->StutterEfficiencyNotIncludingVBlank;
p->StutterEfficiency = &outputs->StutterEfficiency;
p->NumberOfStutterBurstsPerFrame = &outputs->NumberOfStutterBurstsPerFrame;
p->LowPowerStutterEfficiencyNotIncludingVBlank = &outputs->LowPowerStutterEfficiencyNotIncludingVBlank;
p->LowPowerStutterEfficiency = &outputs->LowPowerStutterEfficiency;
p->LowPowerNumberOfStutterBurstsPerFrame = &outputs->LowPowerNumberOfStutterBurstsPerFrame;
p->Z8StutterEfficiencyNotIncludingVBlank = &outputs->Z8StutterEfficiencyNotIncludingVBlank;
p->Z8StutterEfficiency = &outputs->Z8StutterEfficiency;
p->Z8NumberOfStutterBurstsPerFrame = &outputs->Z8NumberOfStutterBurstsPerFrame;
p->StutterPeriod = &outputs->StutterPeriod;
p->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = &outputs->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE;
get_calcs(ctx)->calculate_stutter_efficiency(func_params, p);
#ifdef __DML_VBA_ALLOW_DELTA__
p->CompbufReservedSpace64B = 0;
p->CompbufReservedSpaceZs = 0;
p->Z8StutterEfficiencyNotIncludingVBlank = &outputs->Z8StutterEfficiencyNotIncludingVBlankBestCase;
p->Z8StutterEfficiency = &outputs->Z8StutterEfficiencyBestCase;
p->Z8NumberOfStutterBurstsPerFrame = &outputs->Z8NumberOfStutterBurstsPerFrameBestCase;
p->StutterPeriod = &outputs->StutterPeriodBestCase;
get_calcs(ctx)->calculate_stutter_efficiency(func_params, p);
#else
outputs->Z8StutterEfficiencyNotIncludingVBlankBestCase = outputs->Z8StutterEfficiencyNotIncludingVBlank;
outputs->Z8StutterEfficiencyBestCase = outputs->Z8StutterEfficiency;
outputs->Z8NumberOfStutterBurstsPerFrameBestCase = outputs->Z8NumberOfStutterBurstsPerFrame;
outputs->StutterPeriodBestCase = outputs->StutterPeriod;
#endif
}
static void dcn6_mp_calculate_fraction_of_urgent_bandwidth(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
(void)ctx;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
outputs->FractionOfUrgentBandwidth = inputs->non_urg_bandwidth_required[dml2_core_internal_soc_state_sys_active][dml2_core_internal_bw_sdp]
/ inputs->min_available_urgent_bandwidth_MBps;
outputs->FractionOfUrgentBandwidthImmediateFlip = inputs->non_urg_bandwidth_required_flip[dml2_core_internal_soc_state_sys_active][dml2_core_internal_bw_sdp]
/ inputs->min_available_urgent_bandwidth_MBps;
DML_LOG_DEBUG_DOUBLE(outputs->FractionOfUrgentBandwidth);
}
static void dcn6_mp_calculate_writeback_allow_clock_change_end_position(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
unsigned int k;
const struct dml2_plane_parameters *plane;
const struct dml2_stream_parameters *stream;
double line_time_us;
for (k = 0; k < display_cfg->num_planes; ++k) {
plane = &display_cfg->plane_descriptors[k];
stream = &display_cfg->stream_descriptors[plane->stream_index];
if (stream->writeback.active_writebacks_per_stream > 0) {
line_time_us = stream->timing.h_total / ((double) stream->timing.pixel_clock_khz / 1000);
outputs->WritebackAllowDRAMClockChangeEndPosition[k] =
math_max2(0, inputs->VStartupMin[k] * line_time_us
- inputs->Watermark.WritebackDRAMClockChangeWatermark);
outputs->WritebackAllowFCLKChangeEndPosition[k] =
math_max2(0, inputs->VStartupMin[k] * line_time_us
- inputs->Watermark.WritebackFCLKChangeWatermark);
} else {
outputs->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
outputs->WritebackAllowFCLKChangeEndPosition[k] = 0;
}
}
}
static void dcn6_mp_calculate_pstate_keepout_dst_lines(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_display_cfg *display_cfg = ctx->display_cfg;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
get_calcs(ctx)->calculate_pstate_keepout_dst_lines(display_cfg, &inputs->Watermark,
outputs->pstate_keepout_dst_lines);
}
static void dcn6_mp_calculate_dcfclk_deep_sleep_hysteresis(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
const struct dml2_core_ip_params *ip = ctx->ip;
const struct dml2_utm_soc_bb *soc_bb = ctx->soc_bb;
struct dml2_core_internal_mode_program *inputs = states;
struct dml2_core_internal_mode_program *outputs = states;
const struct dml2_sop_table *sop_table = &soc_bb->sop_table;
struct dml2_soc_operating_point max_sop;
double min_return_latency_in_DCFCLK_cycles = 0;
const long min_return_uclk_cycles = 83;
const long min_return_fclk_cycles = 75;
sop_table->get_max_sop(sop_table, &max_sop);
min_return_latency_in_DCFCLK_cycles =
(min_return_uclk_cycles / (max_sop.uclk_khz / 1000.0)
+ min_return_fclk_cycles / (max_sop.fclk_khz / 1000.0))
* inputs->Dcfclk;
outputs->min_return_latency_in_dcfclk = (unsigned int)min_return_latency_in_DCFCLK_cycles;
outputs->dcfclk_deep_sleep_hysteresis = (unsigned int)math_max2(
32,
(double)ip->pixel_chunk_size_kbytes * 1024 * 3 / 4 / 64
- min_return_latency_in_DCFCLK_cycles);
}
void dcn6_calculate_mode_programming(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_internal_mode_program *states)
{
dcn6_mp_calculate_fraction_of_urgent_bandwidth(ctx, states);
dcn6_mp_calculate_pstate_keepout_dst_lines(ctx, states);
dcn6_mp_calculate_dcc_configurations(ctx, states);
dcn6_mp_calculate_writeback_allow_clock_change_end_position(ctx, states);
dcn6_mp_calculate_pixel_delivery_times(ctx, states);
dcn6_mp_calculate_meta_and_pte_times(ctx, states);
dcn6_mp_calculate_vm_group_and_request_times(ctx, states);
dcn6_mp_calculate_vstartup_adjustment(ctx, states);
dcn6_mp_calculate_max_bandwidth_used(ctx, states);
dcn6_mp_calculate_stutter_efficiency(ctx, states);
dcn6_mp_calculate_dcfclk_deep_sleep_hysteresis(ctx, states);
DML_LOG_VERBOSE("DML::%s: --- END --- \n", __func__);
}
void dcn6_get_global_sync_programming(const struct dml2_core_internal_display_mode_lib *mode_lib, union dml2_global_sync_programming *out, int pipe_index)
{
out->dcn4x.vready_offset_pixels = mode_lib->mp.VReadyOffsetPix[mode_lib->mp.pipe_plane[pipe_index]];
out->dcn4x.vstartup_lines = mode_lib->mp.VStartup[mode_lib->mp.pipe_plane[pipe_index]];
out->dcn4x.vupdate_offset_pixels = mode_lib->mp.VUpdateOffsetPix[mode_lib->mp.pipe_plane[pipe_index]];
out->dcn4x.vupdate_vupdate_width_pixels = mode_lib->mp.VUpdateWidthPix[mode_lib->mp.pipe_plane[pipe_index]];
out->dcn4x.pstate_keepout_start_lines = mode_lib->mp.pstate_keepout_dst_lines[mode_lib->mp.pipe_plane[pipe_index]];
}
void dcn6_get_stream_programming(const struct dml2_core_internal_display_mode_lib *mode_lib, struct dml2_per_stream_programming *out, int pipe_index)
{
dcn6_get_global_sync_programming(mode_lib, &out->global_sync, pipe_index);
}
static unsigned int get_element_size_idx(unsigned int byte_per_pix)
{
unsigned int idx = 0;
while (byte_per_pix > 1) {
byte_per_pix >>= 1;
idx++;
}
return idx;
}
enum sw_swizzle_mode {
SW_LINEAR = 0,
SW_256B_S = 1,
SW_256B_D = 2,
SW_256B_R_2D = 3,
SW_4KB_S = 5,
SW_4KB_D = 6,
SW_4KB_R_2D = 7,
SW_64KB_S = 9,
SW_64KB_D = 10,
SW_64KB_R_2D = 11,
SW_256KB_R_2D = 15,
SW_64KB_S_T = 17,
SW_64KB_D_T = 18,
SW_4KB_S_X = 21,
SW_4KB_D_X = 22,
SW_64KB_S_X = 25,
SW_64KB_D_X = 26,
SW_64KB_R_X = 27,
SW_VAR_R_X = 31,
};
static uint8_t dml2_swizzle_mode_to_sw_swizzle_mode(enum dml2_swizzle_mode tiling)
{
uint8_t sw_swizzle_mode = 0;
switch (tiling) {
case dml2_sw_linear:
case dml2_gfx11_sw_linear:
case dml2_sw_256b_2d:
sw_swizzle_mode = SW_256B_R_2D;
break;
case dml2_sw_4kb_2d:
sw_swizzle_mode = SW_4KB_R_2D;
break;
case dml2_sw_64kb_2d:
sw_swizzle_mode = SW_64KB_R_2D;
break;
case dml2_sw_256kb_2d:
case dml2_gfx11_sw_256kb_d_x:
case dml2_gfx11_sw_256kb_r_x:
sw_swizzle_mode = SW_256KB_R_2D;
break;
case dml2_gfx11_sw_64kb_d_t:
sw_swizzle_mode = SW_64KB_D_T;
break;
case dml2_gfx11_sw_64kb_r_x:
case dml2_gfx11_sw_64kb_d_x:
sw_swizzle_mode = SW_64KB_D_X;
break;
case dml2_gfx11_sw_64kb_d:
sw_swizzle_mode = SW_64KB_D;
break;
default:
sw_swizzle_mode = SW_LINEAR;
break;
}
return sw_swizzle_mode;
}
static void dcn6_populate_fams2_programming(const struct dml2_core_internal_display_mode_lib *mode_lib,
const struct dml2_display_solution *solution,
struct dml2_display_cfg_programming *programming,
unsigned int main_stream_index)
{
const struct dml2_uclk_pstate_params *uclk_params = &solution->uclk_pstate_params;
union dmub_cmd_fams2_config *fams2_base_programming = &programming->stream_programming[main_stream_index].fams2_base_params;
enum dml2_pstate_method pstate_method = programming->stream_programming[main_stream_index].uclk_pstate_method;
const struct dml2_display_cfg *disp_cfg = &solution->dispcfg;
const struct dml2_stream_parameters *stream_descriptor = &disp_cfg->stream_descriptors[main_stream_index];
const struct dml2_plane_parameters *plane_descriptor;
const struct dml2_pstate_meta *stream_pstate_meta = &uclk_params->stream_pstate_meta[main_stream_index];
struct dmub_fams2_cmd_stream_static_base_state *base_programming = &fams2_base_programming->stream_v1.base;
union dmub_fams2_stream_static_sub_state_v2 *sub_programming = &programming->stream_programming[main_stream_index].fams2_sub_params_v2;
unsigned int i, vready_offset, per_stream_plane_index = 0;
bool vertical_access;
if (disp_cfg->overrides.all_streams_blanked) {
return;
}
base_programming->htotal = (uint16_t)stream_descriptor->timing.h_total;
base_programming->vtotal = (uint16_t)stream_descriptor->timing.v_total;
base_programming->vblank_start = (uint16_t)(stream_pstate_meta->nom_vtotal -
stream_descriptor->timing.v_front_porch);
base_programming->vblank_end = (uint16_t)(stream_pstate_meta->nom_vtotal -
stream_descriptor->timing.v_front_porch -
stream_descriptor->timing.v_active);
base_programming->config.bits.is_drr = stream_descriptor->timing.drr_config.enabled;
base_programming->otg_vline_time_ns =
(unsigned int)(stream_pstate_meta->otg_vline_time_us * 1000.0);
base_programming->scheduling_delay_otg_vlines = (uint8_t)stream_pstate_meta->scheduling_delay_otg_vlines;
base_programming->contention_delay_otg_vlines = (uint8_t)stream_pstate_meta->contention_delay_otg_vlines;
base_programming->vline_int_ack_delay_otg_vlines = (uint8_t)stream_pstate_meta->vertical_interrupt_ack_delay_otg_vlines;
base_programming->drr_keepout_otg_vline = (uint16_t)(stream_pstate_meta->nom_vtotal -
stream_descriptor->timing.v_front_porch -
stream_pstate_meta->method_drr.programming_delay_otg_vlines);
base_programming->allow_to_target_delay_otg_vlines = (uint8_t)stream_pstate_meta->allow_to_target_delay_otg_vlines;
base_programming->max_vtotal = (uint16_t)stream_pstate_meta->max_vtotal;
base_programming->config.bits.min_ttu_vblank_usable = true;
for (i = 0; i < disp_cfg->num_planes; i++) {
if (disp_cfg->plane_descriptors[i].stream_index == main_stream_index &&
mode_lib->mp.MinTTUVBlank[i] <= mode_lib->mp.Watermark.DRAMClockChangeWatermark) {
base_programming->config.bits.min_ttu_vblank_usable = false;
break;
}
}
switch (pstate_method) {
case dml2_pstate_method_vactive:
case dml2_pstate_method_fw_vactive_drr:
base_programming->type = FAMS2_STREAM_TYPE_VACTIVE;
sub_programming->legacy.vactive_det_fill_delay_otg_vlines =
(uint8_t)stream_pstate_meta->method_vactive.max_vactive_det_fill_delay_otg_vlines;
sub_programming->legacy.disallow_time_us =
(uint32_t)(stream_pstate_meta->method_vactive.common.disallow_time_us);
base_programming->allow_start_otg_vline =
(uint16_t)stream_pstate_meta->method_vactive.common.allow_start_otg_vline;
base_programming->allow_end_otg_vline =
(uint16_t)stream_pstate_meta->method_vactive.common.allow_end_otg_vline;
base_programming->config.bits.clamp_vtotal_min = true;
break;
case dml2_pstate_method_vblank:
case dml2_pstate_method_fw_vblank_drr:
base_programming->type = FAMS2_STREAM_TYPE_VBLANK;
base_programming->allow_start_otg_vline =
(uint16_t)stream_pstate_meta->method_vblank.common.allow_start_otg_vline;
base_programming->allow_end_otg_vline =
(uint16_t)stream_pstate_meta->method_vblank.common.allow_end_otg_vline;
base_programming->config.bits.clamp_vtotal_min = true;
sub_programming->legacy.disallow_time_us =
(uint32_t)(stream_pstate_meta->method_vblank.common.disallow_time_us);
break;
case dml2_pstate_method_fw_drr:
base_programming->type = FAMS2_STREAM_TYPE_DRR;
sub_programming->drr.programming_delay_otg_vlines =
(uint8_t)stream_pstate_meta->method_drr.programming_delay_otg_vlines;
sub_programming->drr.nom_stretched_vtotal =
(uint16_t)stream_pstate_meta->method_drr.stretched_vtotal;
base_programming->allow_start_otg_vline =
(uint16_t)stream_pstate_meta->method_drr.common.allow_start_otg_vline;
base_programming->allow_end_otg_vline =
(uint16_t)stream_pstate_meta->method_drr.common.allow_end_otg_vline;
base_programming->config.bits.clamp_vtotal_min = disp_cfg->num_streams == 1;
sub_programming->drr.only_stretch_if_required = true;
break;
case dml2_pstate_method_alternate:
base_programming->type = FAMS2_STREAM_TYPE_ALTERNATE;
base_programming->allow_start_otg_vline =
(uint16_t)stream_pstate_meta->method_alternate.common.allow_start_otg_vline;
base_programming->allow_end_otg_vline =
(uint16_t)stream_pstate_meta->method_alternate.common.allow_end_otg_vline;
base_programming->config.bits.clamp_vtotal_min = true;
sub_programming->alternate.total_bytes_to_copy = mode_lib->mp.svp0_max_bytes + mode_lib->mp.svp1_max_bytes;
sub_programming->alternate.svp0_dst_lines = (uint16_t)mode_lib->mp.svp0_dst_lines[main_stream_index];
sub_programming->alternate.svp1_dst_lines = (uint16_t)mode_lib->mp.svp1_dst_lines[main_stream_index];
sub_programming->alternate.svp_req_limit = (uint16_t)mode_lib->mp.svp_req_limit[main_stream_index];
sub_programming->alternate.min_lead_dst_lines = (uint16_t)mode_lib->mp.min_lead_dst_lines[main_stream_index];
sub_programming->alternate.fw_delays = (uint16_t)(stream_pstate_meta->method_alternate.pmfw_throttle_delay_otg_vlines + stream_pstate_meta->method_alternate.programming_delay_otg_vlines +
stream_pstate_meta->scheduling_delay_otg_vlines + stream_pstate_meta->contention_delay_otg_vlines);
sub_programming->alternate.max_cursor_size = 128;
sub_programming->alternate.vready_offset_lines = 0;
base_programming->allow_to_target_delay_otg_vlines = (uint16_t)math_max2(mode_lib->mp.svp_req_limit[main_stream_index], mode_lib->mp.max_prefetch_in_lines[main_stream_index]);
for (i = 0; i < programming->display_config.num_planes; i++) {
if (disp_cfg->plane_descriptors[i].stream_index == main_stream_index) {
plane_descriptor = &disp_cfg->plane_descriptors[i];
vertical_access = plane_descriptor->composition.rotation_angle == dml2_rotation_90 || plane_descriptor->composition.rotation_angle == dml2_rotation_270;
sub_programming->alternate.rec_height[per_stream_plane_index] = vertical_access ? (uint16_t)((double)plane_descriptor->composition.viewport.plane0.width / plane_descriptor->composition.scaler_info.plane0.v_ratio) :
(uint16_t)((double)plane_descriptor->composition.viewport.plane0.height / plane_descriptor->composition.scaler_info.plane0.v_ratio);
sub_programming->alternate.vstartup_start = (uint16_t)mode_lib->mp.VStartup[i];
sub_programming->alternate.viewport_start[per_stream_plane_index] = vertical_access ? (uint16_t)plane_descriptor->composition.viewport.plane0.x_start : (uint16_t)plane_descriptor->composition.viewport.plane0.y_start;
sub_programming->alternate.viewport_size[per_stream_plane_index] = vertical_access ? (uint16_t)plane_descriptor->composition.viewport.plane0.width : (uint16_t)plane_descriptor->composition.viewport.plane0.height;
sub_programming->alternate.viewport_start_c[per_stream_plane_index] = vertical_access ? (uint16_t)plane_descriptor->composition.viewport.plane1.x_start : (uint16_t)plane_descriptor->composition.viewport.plane1.y_start;
sub_programming->alternate.viewport_size_c[per_stream_plane_index] = vertical_access ? (uint16_t)plane_descriptor->composition.viewport.plane1.width : (uint16_t)plane_descriptor->composition.viewport.plane1.height;
sub_programming->alternate.surface_pitch[per_stream_plane_index] = (uint16_t)plane_descriptor->surface.plane0.pitch;
sub_programming->alternate.surface_pitch_c[per_stream_plane_index] = (uint16_t)plane_descriptor->surface.plane1.pitch;
sub_programming->alternate.surface_height[per_stream_plane_index] = (uint16_t)plane_descriptor->surface.plane0.height;
sub_programming->alternate.surface_height_c[per_stream_plane_index] = (uint16_t)plane_descriptor->surface.plane1.height;
sub_programming->alternate.element_size[per_stream_plane_index] = (uint8_t) get_element_size_idx(mode_lib->mp.BytePerPixelY[i]);
sub_programming->alternate.element_size_c[per_stream_plane_index] = (uint8_t) get_element_size_idx(mode_lib->mp.BytePerPixelC[i]);
sub_programming->alternate.swath_height[per_stream_plane_index] = (uint8_t)mode_lib->mp.SwathHeightY[i];
sub_programming->alternate.swath_height_c[per_stream_plane_index] = (uint8_t)mode_lib->mp.SwathHeightC[i];
sub_programming->alternate.macro_tile_width[per_stream_plane_index] = (uint16_t)mode_lib->mp.MacroTileWidthY[i];
sub_programming->alternate.macro_tile_width_c[per_stream_plane_index] = (uint16_t)mode_lib->mp.MacroTileWidthC[i];
sub_programming->alternate.block_256b_width[per_stream_plane_index] = (uint16_t)mode_lib->mp.Read256BlockWidthY[i];
sub_programming->alternate.block_256b_height[per_stream_plane_index] = (uint16_t)mode_lib->mp.Read256BlockHeightY[i];
sub_programming->alternate.block_256b_width_c[per_stream_plane_index] = (uint16_t)mode_lib->mp.Read256BlockWidthC[i];
sub_programming->alternate.block_256b_height_c[per_stream_plane_index] = (uint16_t)mode_lib->mp.Read256BlockHeightC[i];
sub_programming->alternate.dst_y_prefetch_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.dst_y_prefetch[i] * 1000);
sub_programming->alternate.total_swaths[per_stream_plane_index] = (uint16_t)mode_lib->mp.total_swaths[i];
sub_programming->alternate.total_swaths_c[per_stream_plane_index] = (uint16_t)mode_lib->mp.total_swaths_c[i];
sub_programming->alternate.prefetch_swaths[per_stream_plane_index] = (uint8_t)mode_lib->mp.prefetch_swaths[i];
sub_programming->alternate.prefetch_swaths_c[per_stream_plane_index] = (uint8_t)mode_lib->mp.prefetch_swaths_c[i];
sub_programming->alternate.pre_hdl_delta_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.prefetch_hdl_delta[i] * 1000);
sub_programming->alternate.rec_hdl_delta_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.recout_hdl_delta[i] * 1000);
sub_programming->alternate.pre_hdl_delta_c_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.prefetch_hdl_delta_c[i] * 1000);
sub_programming->alternate.rec_hdl_delta_c_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.recout_hdl_delta_c[i] * 1000);
sub_programming->alternate.dst_y_per_vm_vblank_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.dst_y_per_vm_vblank[i] * 1000);
sub_programming->alternate.dst_y_per_row_vblank_x1000[per_stream_plane_index] = (uint16_t)(mode_lib->mp.dst_y_per_row_vblank[i] * 1000);
sub_programming->alternate.dst_y_after_scaler[per_stream_plane_index] = (uint16_t)mode_lib->mp.DSTYAfterScaler[i];
sub_programming->alternate.vinit_prefill[per_stream_plane_index] = (uint16_t)mode_lib->mp.VInitPreFillY[i];
sub_programming->alternate.vinit_prefill_c[per_stream_plane_index] = (uint16_t)mode_lib->mp.VInitPreFillC[i];
sub_programming->alternate.vratio_x1000[per_stream_plane_index] = (uint16_t)(plane_descriptor->composition.scaler_info.plane0.v_ratio * 1000);
sub_programming->alternate.vratio_c_x1000[per_stream_plane_index] = (uint16_t)(plane_descriptor->composition.scaler_info.plane1.v_ratio * 1000);
sub_programming->alternate.swizzle_mode[per_stream_plane_index] = dml2_swizzle_mode_to_sw_swizzle_mode(plane_descriptor->surface.tiling);
vready_offset = (unsigned int)(math_ceil(((double)mode_lib->mp.VUpdateOffsetPix[i] + mode_lib->mp.VUpdateWidthPix[i] + mode_lib->mp.VReadyOffsetPix[i] + 1) / stream_descriptor->timing.h_total) + 1);
if (vready_offset > sub_programming->alternate.vready_offset_lines)
sub_programming->alternate.vready_offset_lines = (uint8_t)vready_offset;
sub_programming->alternate.config[per_stream_plane_index].bits.prefetch_relative_vblank = 1;
sub_programming->alternate.config[per_stream_plane_index].bits.dcc = plane_descriptor->surface.dcc.enable;
sub_programming->alternate.config[per_stream_plane_index].bits.is_multi_planar =
plane_descriptor->surface.plane1.height > 0;
sub_programming->alternate.config[per_stream_plane_index].bits.is_yuv420 =
plane_descriptor->pixel_format == dml2_420_8 ||
plane_descriptor->pixel_format == dml2_420_10 ||
plane_descriptor->pixel_format == dml2_420_12;
sub_programming->alternate.config[per_stream_plane_index].bits.vertical_access = vertical_access ? 1 : 0;
sub_programming->alternate.config[per_stream_plane_index].bits.access_direction =
(plane_descriptor->composition.rotation_angle == dml2_rotation_90 && !plane_descriptor->composition.mirrored) ||
(plane_descriptor->composition.rotation_angle == dml2_rotation_270 && plane_descriptor->composition.mirrored) ||
(plane_descriptor->composition.rotation_angle == dml2_rotation_180) ? 1 : 0;
sub_programming->alternate.pipe_copy_max_size[0][per_stream_plane_index] = mode_lib->mp.svp0_max_bytes_per_dpp[i];
sub_programming->alternate.pipe_copy_max_size[1][per_stream_plane_index] = mode_lib->mp.svp1_max_bytes_per_dpp[i];
sub_programming->alternate.pipe_copy_max_size_c[0][per_stream_plane_index] = mode_lib->mp.svp0_max_bytes_per_dpp_c[i];
sub_programming->alternate.pipe_copy_max_size_c[1][per_stream_plane_index] = mode_lib->mp.svp1_max_bytes_per_dpp_c[i];
per_stream_plane_index++;
}
}
base_programming->num_planes = (uint8_t)per_stream_plane_index;
break;
case dml2_pstate_method_reserved_hw:
case dml2_pstate_method_reserved_fw:
case dml2_pstate_method_reserved_fw_drr_clamped:
case dml2_pstate_method_reserved_fw_drr_var:
case dml2_pstate_method_fw_svp:
case dml2_pstate_method_fw_svp_drr:
case dml2_pstate_method_na:
case dml2_pstate_method_count:
default:
break;
}
}
static void dcn6_populate_global_fams2_programming(const struct dml2_core_internal_display_mode_lib *mode_lib,
const struct dml2_display_solution *solution,
struct dmub_cmd_fams2_global_config *fams2_global_config)
{
unsigned int i, allow_to_target_delta_us;
double line_time_us;
fams2_global_config->features.bits.enable = solution->uclk_pstate_params.fams2_required;
fams2_global_config->features.bits.legacy_method_no_fams2 = solution->uclk_pstate_params.legacy_pstate_info_for_dmu;
if (fams2_global_config->features.bits.enable || fams2_global_config->features.bits.legacy_method_no_fams2) {
fams2_global_config->features.bits.enable_stall_recovery = true;
fams2_global_config->features.bits.allow_delay_check_mode = FAMS2_ALLOW_DELAY_CHECK_FROM_START;
fams2_global_config->max_allow_delay_us = mode_lib->ip_caps.fams2.max_allow_delay_us;
fams2_global_config->lock_wait_time_us = mode_lib->ip_caps.fams2.lock_timeout_us;
fams2_global_config->recovery_timeout_us = mode_lib->ip_caps.fams2.recovery_timeout_us;
fams2_global_config->hwfq_flip_programming_delay_us = mode_lib->ip_caps.fams2.flip_programming_delay_us;
fams2_global_config->num_streams = solution->dispcfg.num_streams;
for (i = 0; i < solution->dispcfg.num_streams; i++) {
line_time_us = ((double)solution->dispcfg.stream_descriptors[i].timing.h_total * 1000 / solution->dispcfg.stream_descriptors[i].timing.pixel_clock_khz);
allow_to_target_delta_us = (unsigned int)math_ceil(mode_lib->mp.svp_req_limit[i] * line_time_us);
if (fams2_global_config->max_allow_to_target_delta_us < allow_to_target_delta_us)
fams2_global_config->max_allow_to_target_delta_us = allow_to_target_delta_us;
}
}
}
static void dcn6_populate_min_clocks(struct dml2_display_cfg_programming *programming,
const struct dml2_display_solution *solution, const struct dml2_utm_soc_bb *utm_soc_bb)
{
unsigned int i;
programming->min_clocks.dcn4x.dispclk_khz = solution->validation_result.mode_support.global.dispclk_khz;
programming->min_clocks.dcn4x.dpprefclk_khz = solution->validation_result.mode_support.global.dpprefclk_khz;
programming->min_clocks.dcn4x.dtbrefclk_khz = solution->validation_result.mode_support.global.dtbrefclk_khz;
programming->min_clocks.dcn4x.socclk_khz = utm_soc_bb->min_socclk_khz;
if (solution->dispcfg.overrides.hw.dcfclk_mhz > 0)
programming->min_clocks.dcn4x.active.dcfclk_khz =
(unsigned long) math_ceil(solution->dispcfg.overrides.hw.dcfclk_mhz * 1000);
else
programming->min_clocks.dcn4x.active.dcfclk_khz = solution->sop_constraint.dcn5.clocks.dcfclk_khz;
programming->min_clocks.dcn4x.active.fclk_khz = solution->sop_constraint.dcn5.clocks.fclk_khz;
programming->min_clocks.dcn4x.active.uclk_khz = solution->sop_constraint.dcn5.clocks.uclk_khz;
programming->min_sop_index = solution->sop_constraint.dcn5.min_sop_index;
programming->min_clocks.dcn4x.deepsleep_dcfclk_khz =
(unsigned long) math_min2((double)solution->validation_result.mode_support.global.dcfclk_deepsleep_khz, (double)programming->min_clocks.dcn4x.active.dcfclk_khz);
for (i = 0; i < solution->dispcfg.num_planes; i++)
programming->plane_programming[i].min_clocks.dcn4x.dppclk_khz =
solution->validation_result.mode_support.per_plane[i].dppclk_khz;
for (i = 0; i < solution->dispcfg.num_streams; i++) {
programming->stream_programming[i].min_clocks.dcn4x.dscclk_khz =
solution->validation_result.mode_support.per_stream[i].dscclk_khz;
programming->stream_programming[i].min_clocks.dcn4x.dtbclk_khz =
solution->validation_result.mode_support.per_stream[i].dtbclk_khz;
programming->stream_programming[i].min_clocks.dcn4x.phyclk_khz =
solution->validation_result.mode_support.per_stream[i].phyclk_khz;
}
}
static void dcn6_populate_stutter_support(struct dml2_display_cfg_programming *programming,
const struct dml2_core_internal_display_mode_lib *mode_lib,
const struct dml2_display_solution *solution,
const struct dml2_utm_soc_bb *utm_soc_bb)
{
programming->stutter.supported_in_blank = solution->stutter_support_in_vblank;
programming->z8_stutter.supported_in_blank = solution->z8_stutter_support_in_vblank;
programming->z8_stutter.meets_eco = utm_soc_bb->power_management_parameters.z8_min_idle_time > 0
&& mode_lib->mp.StutterPeriod >= utm_soc_bb->power_management_parameters.z8_min_idle_time;
programming->stutter.base_percent_efficiency = (uint8_t)(mode_lib->mp.StutterEfficiency);
programming->stutter.low_power_percent_efficiency = (uint8_t)(mode_lib->mp.LowPowerStutterEfficiency);
}
static void dcn6_populate_mcache_allocation(struct dml2_display_cfg_programming *programming,
const struct dml2_display_solution *solution)
{
unsigned int i;
for (i = 0; i < solution->dispcfg.num_planes; i++)
programming->plane_programming[i].mcache_allocation = solution->mcache_allocations[i];
}
static void dcn6_populate_qos_bound(struct dml2_display_cfg_programming *programming,
const struct dml2_display_solution *solution)
{
programming->qos_bound.latency_ub = solution->sop_constraint.dcn5.latency;
programming->qos_bound.bandwidth_lb = solution->validation_result.mode_support.bandwidth_upper_bound;
programming->qos_bound.lsdma_bandwidth_lb_kbps = solution->validation_result.mode_support.global.lsdma_bw_req_for_alt_kbps;
}
void dcn6_populate_mode_programming(struct dml2_core_calculate_mp_context *ctx,
struct dml2_display_cfg_programming *programming,
struct dml2_core_internal_scratch *s,
const struct dml2_core_internal_display_mode_lib *mode_lib,
const struct dml2_display_solution *solution,
const struct dml2_utm_soc_bb *utm_soc_bb)
{
const struct dml2_uclk_pstate_params *uclk_params = &solution->uclk_pstate_params;
const struct core_display_cfg_support_info *cfg_support_info = &solution->validation_result.mode_support.cfg_support_info;
unsigned int pipe_offset;
int dml_internal_pipe_index;
int total_pipe_regs_copied = 0;
int stream_already_populated_mask = 0;
unsigned int main_stream_index;
unsigned int plane_index;
memcpy(&programming->display_config, &solution->dispcfg, sizeof(struct dml2_display_cfg));
dcn6_populate_min_clocks(programming, solution, utm_soc_bb);
get_calcs(ctx)->get_arb_params(&programming->display_config, mode_lib, utm_soc_bb, &programming->global_regs.arb_regs);
programming->global_regs.num_watermark_sets = 1;
get_calcs(ctx)->get_watermarks(&programming->display_config, mode_lib, utm_soc_bb,
&programming->global_regs.wm_regs[0]);
dcn6_populate_stutter_support(programming, mode_lib, solution, utm_soc_bb);
dcn6_populate_mcache_allocation(programming, solution);
dcn6_populate_qos_bound(programming, solution);
dml_internal_pipe_index = 0;
programming->fclk_pstate_supported = solution->fclk_pstate_support;
if (uclk_params) {
programming->uclk_pstate_supported = uclk_params->support;
if (programming->uclk_pstate_supported) {
programming->fams2_required = uclk_params->fams2_required;
programming->legacy_pstate_info_for_dmu = uclk_params->legacy_pstate_info_for_dmu;
dcn6_populate_global_fams2_programming(mode_lib, solution, &programming->fams2_global_config);
}
}
DML_LOG_VERBOSE("DML_PMO::%s: num_planes=%u\n", __func__, programming->display_config.num_planes);
for (plane_index = 0; plane_index < programming->display_config.num_planes; plane_index++) {
programming->plane_programming[plane_index].num_dpps_required = mode_lib->mp.NoOfDPP[plane_index];
if (uclk_params) {
if (programming->uclk_pstate_supported)
programming->plane_programming[plane_index].uclk_pstate_support_method = uclk_params->pstate_switch_modes[plane_index];
else
programming->plane_programming[plane_index].uclk_pstate_support_method = dml2_pstate_method_na;
} else {
if (mode_lib->mp.MaxActiveDRAMClockChangeLatencySupported[plane_index] >= utm_soc_bb->power_management_parameters.dram_clk_change_blackout_us)
programming->plane_programming[plane_index].uclk_pstate_support_method = dml2_pstate_method_vactive;
else if (mode_lib->mp.TWait[plane_index] >= utm_soc_bb->power_management_parameters.dram_clk_change_blackout_us)
programming->plane_programming[plane_index].uclk_pstate_support_method = dml2_pstate_method_vblank;
else
programming->plane_programming[plane_index].uclk_pstate_support_method = dml2_pstate_method_na;
}
for (pipe_offset = 0; pipe_offset < programming->plane_programming[plane_index].num_dpps_required; pipe_offset++) {
programming->plane_programming[plane_index].plane_descriptor = &programming->display_config.plane_descriptors[plane_index];
programming->plane_programming[plane_index].pipe_regs[pipe_offset] = &programming->pipe_regs[total_pipe_regs_copied];
memset(programming->plane_programming[plane_index].pipe_regs[pipe_offset], 0, sizeof(struct dml2_dchub_per_pipe_register_set));
total_pipe_regs_copied++;
get_calcs(ctx)->get_pipe_regs(&programming->display_config, mode_lib,
programming->plane_programming[plane_index].pipe_regs[pipe_offset],
dml_internal_pipe_index, utm_soc_bb, s);
main_stream_index = programming->display_config.plane_descriptors[plane_index].stream_index;
if (!(stream_already_populated_mask & (0x1 << main_stream_index))) {
programming->stream_programming[main_stream_index].uclk_pstate_method = programming->plane_programming[plane_index].uclk_pstate_support_method;
programming->stream_programming[main_stream_index].stream_descriptor = &programming->display_config.stream_descriptors[main_stream_index];
programming->stream_programming[main_stream_index].num_odms_required = cfg_support_info->stream_support_info[main_stream_index].odms_used;
dcn6_get_stream_programming(mode_lib, &programming->stream_programming[main_stream_index], dml_internal_pipe_index);
stream_already_populated_mask |= (0x1 << main_stream_index);
}
dml_internal_pipe_index++;
}
}
for (main_stream_index = 0; main_stream_index < programming->display_config.num_streams; main_stream_index++) {
if (uclk_params) {
dcn6_populate_fams2_programming(mode_lib,
solution,
programming,
main_stream_index);
}
}
}
void dcn6_mp_initialize_from_solution(struct dml2_core_internal_mode_program *outputs,
const struct dml2_display_solution *solution,
const struct dml2_utm_soc_bb *utm_soc_bb)
{
const struct dml2_display_cfg *display_cfg = &solution->dispcfg;
const struct core_display_cfg_support_info *cfg_support_info =
&solution->validation_result.mode_support.cfg_support_info;
const struct core_plane_support_info *plane_support_info;
const struct core_stream_support_info *stream_support_info;
unsigned int k;
const struct dml2_plane_parameters *plane;
outputs->num_active_pipes = dml2_core_util_get_num_active_pipes(display_cfg->num_planes, cfg_support_info);
dml2_core_utils_pipe_plane_mapping(cfg_support_info, outputs->pipe_plane);
dml2_core_utils_get_stream_output_bpp(outputs->OutputBpp, display_cfg);
dcn6_mp_populate_odm_mode(solution, outputs);
for (k = 0; k < display_cfg->num_planes; k++) {
plane = &display_cfg->plane_descriptors[k];
plane_support_info = &cfg_support_info->plane_support_info[k];
stream_support_info = &cfg_support_info->stream_support_info[plane->stream_index];
outputs->immediate_flip_required = outputs->immediate_flip_required
|| plane->immediate_flip;
outputs->NoOfDPP[k] = plane_support_info->dpps_used;
outputs->dsc_enable[k] = stream_support_info->dsc_enable;
outputs->num_dsc_slices[k] = stream_support_info->num_dsc_slices;
}
outputs->GlobalDPPCLK = solution->validation_result.mode_support.global.dpprefclk_khz / 1000.0;
if (solution->dispcfg.overrides.hw.dcfclk_mhz > 0)
outputs->Dcfclk = solution->dispcfg.overrides.hw.dcfclk_mhz;
else
outputs->Dcfclk = solution->sop_constraint.dcn5.clocks.dcfclk_khz / 1000.0;
outputs->FabricClock = solution->sop_constraint.dcn5.clocks.fclk_khz / 1000.0;
outputs->uclk_freq_mhz = solution->sop_constraint.dcn5.clocks.uclk_khz / 1000.0;
outputs->SOCCLK = utm_soc_bb->min_socclk_khz / 1000.0;
for (k = 0; k < display_cfg->num_planes; k++) {
plane = &display_cfg->plane_descriptors[k];
outputs->Dppclk[k] = solution->validation_result.mode_support.per_plane[k].dppclk_khz / 1000.0;
outputs->DSCCLK[k] = solution->validation_result.mode_support.per_stream[plane->stream_index].dscclk_khz / 1000.0;
}
outputs->min_available_urgent_bandwidth_MBps = solution->validation_result.mode_support.bandwidth_upper_bound.dcn5.urgent_bandwidth_kbps / 1000.0;
**outputs->urg_bandwidth_available = math_min2(solution->sop_constraint.dcn5.min_available_urgent_bandwidth_KBps / 1000.0,
outputs->Dcfclk * utm_soc_bb->urgent_sdp_derate_percent / 100.0 * utm_soc_bb->return_bus_width_bytes);
**outputs->non_urg_bandwidth_available = math_min2(solution->sop_constraint.dcn5.min_available_non_urgent_bandwidth_KBps / 1000.0,
outputs->Dcfclk * utm_soc_bb->nominal_sdp_derate_percent / 100.0 * utm_soc_bb->return_bus_width_bytes);
outputs->UrgentLatency = solution->sop_constraint.dcn5.latency.dcn5.urgent_ramp;
outputs->TripToMemory = math_max2(solution->sop_constraint.dcn5.latency.dcn5.urgent_ramp,
solution->sop_constraint.dcn5.latency.dcn5.t_trip);
outputs->MetaTripToMemory = solution->sop_constraint.dcn5.latency.dcn5.meta_trip_to_mem;
outputs->max_urgent_latency_us = solution->sop_constraint.dcn5.latency.dcn5.max_req_latency_urg;
outputs->df_response_time_us = solution->sop_constraint.dcn5.latency.dcn5.df_response_time_us;
memcpy(outputs->uclk_pstate_switch_modes,
solution->uclk_pstate_params.pstate_switch_modes,
sizeof(solution->uclk_pstate_params.pstate_switch_modes));
}
void dcn6_mp_build_calculate_mp_context(struct dml2_core_calculate_mp_context *ctx,
struct dml2_core_instance *core,
const struct dml2_display_solution *solution)
{
struct dml2_core_internal_display_mode_lib *mode_lib = &core->clean_me_up.mode_lib;
ctx->display_cfg = &solution->dispcfg;
ctx->ip = &mode_lib->ip;
ctx->soc_bb = core->utm_soc_bb;
ctx->ms = &mode_lib->ms;
ctx->dummies = &mode_lib->scratch.dml_core_mode_programming_locals;
ctx->func_params = &mode_lib->scratch;
ctx->calcs = &core->calcs;
}
void dcn6_mp_initialize_from_ms(struct dml2_core_internal_mode_program *outputs,
const struct dml2_core_internal_mode_support *ms)
{
outputs->DCFCLKDeepSleep = ms->dcfclk_deepsleep;
outputs->Dispclk = ms->RequiredDISPCLK;
outputs->MaxTotalDETInKByte = ms->MaxTotalDETInKByte;
outputs->NomDETInKByte = ms->NomDETInKByte;
outputs->MinCompressedBufferSizeInKByte = ms->MinCompressedBufferSizeInKByte;
memcpy(outputs->PixelClockBackEnd, ms->PixelClockBackEnd, sizeof(outputs->PixelClockBackEnd));
memcpy(outputs->DPPCLKUsingSingleDPP, ms->MinDPPCLKUsingSingleDPP, sizeof(outputs->DPPCLKUsingSingleDPP));
memcpy(outputs->PSCL_THROUGHPUT, ms->PSCL_FACTOR, sizeof(outputs->PSCL_THROUGHPUT));
memcpy(outputs->PSCL_THROUGHPUT_CHROMA, ms->PSCL_FACTOR_CHROMA, sizeof(outputs->PSCL_THROUGHPUT_CHROMA));
memcpy(outputs->BytePerPixelY, ms->BytePerPixelY, sizeof(outputs->BytePerPixelY));
memcpy(outputs->BytePerPixelC, ms->BytePerPixelC, sizeof(outputs->BytePerPixelC));
memcpy(outputs->BytePerPixelInDETY, ms->BytePerPixelInDETY, sizeof(outputs->BytePerPixelInDETY));
memcpy(outputs->BytePerPixelInDETC, ms->BytePerPixelInDETC, sizeof(outputs->BytePerPixelInDETC));
memcpy(outputs->Read256BlockHeightY, ms->Read256BlockHeightY, sizeof(outputs->Read256BlockHeightY));
memcpy(outputs->Read256BlockHeightC, ms->Read256BlockHeightC, sizeof(outputs->Read256BlockHeightC));
memcpy(outputs->Read256BlockWidthY, ms->Read256BlockWidthY, sizeof(outputs->Read256BlockWidthY));
memcpy(outputs->Read256BlockWidthC, ms->Read256BlockWidthC, sizeof(outputs->Read256BlockWidthC));
memcpy(outputs->MacroTileHeightY, ms->MacroTileHeightY, sizeof(outputs->MacroTileHeightY));
memcpy(outputs->MacroTileHeightC, ms->MacroTileHeightC, sizeof(outputs->MacroTileHeightC));
memcpy(outputs->MacroTileWidthY, ms->MacroTileWidthY, sizeof(outputs->MacroTileWidthY));
memcpy(outputs->MacroTileWidthC, ms->MacroTileWidthC, sizeof(outputs->MacroTileWidthC));
memcpy(outputs->surf_linear128_l, ms->surf_linear128_l, sizeof(outputs->surf_linear128_l));
memcpy(outputs->surf_linear128_c, ms->surf_linear128_c, sizeof(outputs->surf_linear128_c));
memcpy(outputs->MaximumSwathWidthChroma, ms->MaximumSwathWidthChroma, sizeof(outputs->MaximumSwathWidthChroma));
outputs->MaximumSwathWidthInLineBufferChroma = ms->MaximumSwathWidthInLineBufferChroma;
memcpy(outputs->MaximumSwathWidthLuma, ms->MaximumSwathWidthLuma, sizeof(outputs->MaximumSwathWidthLuma));
outputs->MaximumSwathWidthInLineBufferLuma = ms->MaximumSwathWidthInLineBufferLuma;
memcpy(outputs->cursor_bw, ms->cursor_bw, sizeof(outputs->cursor_bw));
memcpy(outputs->vactive_sw_bw_c, ms->vactive_sw_bw_c, sizeof(outputs->vactive_sw_bw_c));
memcpy(outputs->vactive_sw_bw_l, ms->vactive_sw_bw_l, sizeof(outputs->vactive_sw_bw_l));
memcpy(outputs->SwathWidthSingleDPPC, ms->SwathWidthCSingleDPP, sizeof(outputs->SwathWidthSingleDPPC));
memcpy(outputs->SwathWidthSingleDPPY, ms->SwathWidthYSingleDPP, sizeof(outputs->SwathWidthSingleDPPY));
memcpy(outputs->req_per_swath_ub_l, ms->req_per_swath_ub_l, sizeof(outputs->req_per_swath_ub_l));
memcpy(outputs->req_per_swath_ub_c, ms->req_per_swath_ub_c, sizeof(outputs->req_per_swath_ub_c));
memcpy(outputs->swath_width_luma_ub, ms->swath_width_luma_ub, sizeof(outputs->swath_width_luma_ub));
memcpy(outputs->swath_width_chroma_ub, ms->swath_width_chroma_ub, sizeof(outputs->swath_width_chroma_ub));
memcpy(outputs->SwathWidthY, ms->SwathWidthY, sizeof(outputs->SwathWidthY));
memcpy(outputs->SwathWidthC, ms->SwathWidthC, sizeof(outputs->SwathWidthC));
memcpy(outputs->SwathHeightY, ms->SwathHeightY, sizeof(outputs->SwathHeightY));
memcpy(outputs->SwathHeightC, ms->SwathHeightC, sizeof(outputs->SwathHeightC));
memcpy(outputs->request_size_bytes_luma, ms->support.request_size_bytes_luma, sizeof(outputs->request_size_bytes_luma));
memcpy(outputs->request_size_bytes_chroma, ms->support.request_size_bytes_chroma, sizeof(outputs->request_size_bytes_chroma));
memcpy(outputs->DETBufferSizeInKByte, ms->DETBufferSizeInKByte, sizeof(outputs->DETBufferSizeInKByte));
memcpy(outputs->DETBufferSizeY, ms->DETBufferSizeY, sizeof(outputs->DETBufferSizeY));
memcpy(outputs->DETBufferSizeC, ms->DETBufferSizeC, sizeof(outputs->DETBufferSizeC));
memcpy(outputs->full_swath_bytes_l, ms->full_swath_bytes_l, sizeof(outputs->full_swath_bytes_l));
memcpy(outputs->full_swath_bytes_c, ms->full_swath_bytes_c, sizeof(outputs->full_swath_bytes_c));
outputs->UnboundedRequestEnabled = ms->UnboundedRequestEnabled;
outputs->compbuf_reserved_space_64b = ms->compbuf_reserved_space_64b;
outputs->hw_debug5 = ms->hw_debug5;
outputs->CompressedBufferSizeInkByte = ms->CompressedBufferSizeInkByte;
memcpy(outputs->DSCDelay, ms->DSCDelay, sizeof(outputs->DSCDelay));
memcpy(outputs->vmpg_height_y, ms->vmpg_height_y, sizeof(outputs->vmpg_height_y));
memcpy(outputs->VInitPreFillC, ms->PrefillC, sizeof(outputs->VInitPreFillC));
memcpy(outputs->is_using_mall_for_ss, ms->is_using_mall_for_ss, sizeof(outputs->is_using_mall_for_ss));
memcpy(outputs->meta_row_width_chroma, ms->meta_row_width_chroma, sizeof(outputs->meta_row_width_chroma));
memcpy(outputs->dpte_row_bytes_per_row_c, ms->dpte_row_bytes_per_row_c, sizeof(outputs->dpte_row_bytes_per_row_c));
memcpy(outputs->PixelPTEReqHeightC, ms->PixelPTEReqHeightC, sizeof(outputs->PixelPTEReqHeightC));
memcpy(outputs->meta_row_height, ms->meta_row_height_luma, sizeof(outputs->meta_row_height));
memcpy(outputs->MaxNumSwathY, ms->MaxNumSwathY, sizeof(outputs->MaxNumSwathY));
memcpy(outputs->meta_row_bytes_per_row_ub_l, ms->meta_row_bytes_per_row_ub_l, sizeof(outputs->meta_row_bytes_per_row_ub_l));
memcpy(outputs->PTE_BUFFER_MODE, ms->PTE_BUFFER_MODE, sizeof(outputs->PTE_BUFFER_MODE));
memcpy(outputs->dpte_row_bytes_per_row_l, ms->dpte_row_bytes_per_row_l, sizeof(outputs->dpte_row_bytes_per_row_l));
memcpy(outputs->dpte_row_height, ms->dpte_row_height, sizeof(outputs->dpte_row_height));
memcpy(outputs->meta_req_height_chroma, ms->meta_req_height_chroma, sizeof(outputs->meta_req_height_chroma));
memcpy(outputs->PixelPTEBytesPerRow, ms->DPTEBytesPerRow, sizeof(outputs->PixelPTEBytesPerRow));
memcpy(outputs->vmpg_width_y, ms->vmpg_width_y, sizeof(outputs->vmpg_width_y));
memcpy(outputs->meta_pte_bytes_per_frame_ub_c, ms->meta_pte_bytes_per_frame_ub_c, sizeof(outputs->meta_pte_bytes_per_frame_ub_c));
memcpy(outputs->dpde0_bytes_per_frame_ub_c, ms->dpde0_bytes_per_frame_ub_c, sizeof(outputs->dpde0_bytes_per_frame_ub_c));
memcpy(outputs->dpte_group_bytes, ms->dpte_group_bytes, sizeof(outputs->dpte_group_bytes));
memcpy(outputs->dpte_row_width_luma_ub, ms->dpte_row_width_luma_ub, sizeof(outputs->dpte_row_width_luma_ub));
memcpy(outputs->meta_req_width, ms->meta_req_width, sizeof(outputs->meta_req_width));
memcpy(outputs->PrefetchSourceLinesY, ms->PrefetchLinesY, sizeof(outputs->PrefetchSourceLinesY));
memcpy(outputs->vmpg_width_c, ms->vmpg_width_c, sizeof(outputs->vmpg_width_c));
memcpy(outputs->meta_row_bytes, ms->meta_row_bytes, sizeof(outputs->meta_row_bytes));
memcpy(outputs->PrefetchSourceLinesC, ms->PrefetchLinesC, sizeof(outputs->PrefetchSourceLinesC));
memcpy(outputs->meta_row_bw, ms->meta_row_bw, sizeof(outputs->meta_row_bw));
memcpy(outputs->meta_row_width, ms->meta_row_width, sizeof(outputs->meta_row_width));
memcpy(outputs->PixelPTEReqWidthY, ms->PixelPTEReqWidthY, sizeof(outputs->PixelPTEReqWidthY));
memcpy(outputs->dpte_row_bw, ms->dpte_row_bw, sizeof(outputs->dpte_row_bw));
memcpy(outputs->dpte_row_height_linear, ms->dpte_row_height_linear, sizeof(outputs->dpte_row_height_linear));
memcpy(outputs->PTERequestSizeY, ms->PTERequestSizeY, sizeof(outputs->PTERequestSizeY));
memcpy(outputs->dpte_row_height_chroma, ms->dpte_row_height_chroma, sizeof(outputs->dpte_row_height_chroma));
memcpy(outputs->VInitPreFillY, ms->PrefillY, sizeof(outputs->VInitPreFillY));
memcpy(outputs->use_one_row_for_frame, ms->use_one_row_for_frame, sizeof(outputs->use_one_row_for_frame));
memcpy(outputs->vmpg_height_c, ms->vmpg_height_c, sizeof(outputs->vmpg_height_c));
memcpy(outputs->dpte_row_width_chroma_ub, ms->dpte_row_width_chroma_ub, sizeof(outputs->dpte_row_width_chroma_ub));
memcpy(outputs->PixelPTEReqWidthC, ms->PixelPTEReqWidthC, sizeof(outputs->PixelPTEReqWidthC));
memcpy(outputs->meta_pte_bytes_per_frame_ub_l, ms->meta_pte_bytes_per_frame_ub_l, sizeof(outputs->meta_pte_bytes_per_frame_ub_l));
memcpy(outputs->meta_row_height_chroma, ms->meta_row_height_chroma, sizeof(outputs->meta_row_height_chroma));
memcpy(outputs->MaxNumSwathC, ms->MaxNumSwathC, sizeof(outputs->MaxNumSwathC));
memcpy(outputs->dpte_row_height_linear_chroma, ms->dpte_row_height_linear_chroma, sizeof(outputs->dpte_row_height_linear_chroma));
memcpy(outputs->PTERequestSizeC, ms->PTERequestSizeC, sizeof(outputs->PTERequestSizeC));
memcpy(outputs->meta_req_height, ms->meta_req_height, sizeof(outputs->meta_req_height));
memcpy(outputs->vm_bytes, ms->vm_bytes, sizeof(outputs->vm_bytes));
memcpy(outputs->meta_row_bytes_per_row_ub_c, ms->meta_row_bytes_per_row_ub_c, sizeof(outputs->meta_row_bytes_per_row_ub_c));
memcpy(outputs->dpde0_bytes_per_frame_ub_l, ms->dpde0_bytes_per_frame_ub_l, sizeof(outputs->dpde0_bytes_per_frame_ub_l));
memcpy(outputs->meta_req_width_chroma, ms->meta_req_width_chroma, sizeof(outputs->meta_req_width_chroma));
memcpy(outputs->PixelPTEReqHeightY, ms->PixelPTEReqHeightY, sizeof(outputs->PixelPTEReqHeightY));
memcpy(outputs->BIGK_FRAGMENT_SIZE, ms->BIGK_FRAGMENT_SIZE, sizeof(outputs->BIGK_FRAGMENT_SIZE));
memcpy(outputs->vm_group_bytes, ms->vm_group_bytes, sizeof(outputs->vm_group_bytes));
memcpy(outputs->use_one_row_for_frame_flip, ms->use_one_row_for_frame_flip, sizeof(outputs->use_one_row_for_frame_flip));
memcpy(outputs->mall_comb_mcache_l, ms->mall_comb_mcache_l, sizeof(outputs->mall_comb_mcache_l));
memcpy(outputs->dcc_dram_bw_nom_overhead_factor_p0, ms->dcc_dram_bw_nom_overhead_factor_p0, sizeof(outputs->dcc_dram_bw_nom_overhead_factor_p0));
memcpy(outputs->mcache_row_bytes_l, ms->mcache_row_bytes_l, sizeof(outputs->mcache_row_bytes_l));
memcpy(outputs->dcc_dram_bw_pref_overhead_factor_p1, ms->dcc_dram_bw_pref_overhead_factor_p1, sizeof(outputs->dcc_dram_bw_pref_overhead_factor_p1));
memcpy(outputs->mcache_offsets_l, ms->mcache_offsets_l, sizeof(outputs->mcache_offsets_l));
memcpy(outputs->mcache_shift_granularity_l, ms->mcache_shift_granularity_l, sizeof(outputs->mcache_shift_granularity_l));
memcpy(outputs->mcache_offsets_c, ms->mcache_offsets_c, sizeof(outputs->mcache_offsets_c));
memcpy(outputs->lc_comb_mcache, ms->lc_comb_mcache, sizeof(outputs->lc_comb_mcache));
memcpy(outputs->num_mcaches_c, ms->num_mcaches_c, sizeof(outputs->num_mcaches_c));
memcpy(outputs->mcache_row_bytes_per_channel_l, ms->mcache_row_bytes_per_channel_l, sizeof(outputs->mcache_row_bytes_per_channel_l));
memcpy(outputs->mcache_shift_granularity_c, ms->mcache_shift_granularity_c, sizeof(outputs->mcache_shift_granularity_c));
memcpy(outputs->mcache_row_bytes_per_channel_c, ms->mcache_row_bytes_per_channel_c, sizeof(outputs->mcache_row_bytes_per_channel_c));
memcpy(outputs->mcache_row_bytes_c, ms->mcache_row_bytes_c, sizeof(outputs->mcache_row_bytes_c));
memcpy(outputs->num_mcaches_l, ms->num_mcaches_l, sizeof(outputs->num_mcaches_l));
memcpy(outputs->mall_comb_mcache_c, ms->mall_comb_mcache_c, sizeof(outputs->mall_comb_mcache_c));
memcpy(outputs->dcc_dram_bw_nom_overhead_factor_p1, ms->dcc_dram_bw_nom_overhead_factor_p1, sizeof(outputs->dcc_dram_bw_nom_overhead_factor_p1));
memcpy(outputs->dcc_dram_bw_pref_overhead_factor_p0, ms->dcc_dram_bw_pref_overhead_factor_p0, sizeof(outputs->dcc_dram_bw_pref_overhead_factor_p0));
outputs->TCalc = ms->TimeCalc;
outputs->HostVMInefficiencyFactor = ms->HostVMInefficiencyFactor;
outputs->HostVMInefficiencyFactorPrefetch = ms->HostVMInefficiencyFactorPrefetch;
memcpy(outputs->tdlut_pte_bytes_per_frame, ms->tdlut_pte_bytes_per_frame, sizeof(outputs->tdlut_pte_bytes_per_frame));
memcpy(outputs->tdlut_bytes_per_frame, ms->tdlut_bytes_per_frame, sizeof(outputs->tdlut_bytes_per_frame));
memcpy(outputs->tdlut_drain_time, ms->tdlut_drain_time, sizeof(outputs->tdlut_drain_time));
memcpy(outputs->tdlut_opt_time, ms->tdlut_opt_time, sizeof(outputs->tdlut_opt_time));
memcpy(outputs->tdlut_bytes_per_group, ms->tdlut_bytes_per_group, sizeof(outputs->tdlut_bytes_per_group));
memcpy(outputs->tdlut_groups_per_2row_ub, ms->tdlut_groups_per_2row_ub, sizeof(outputs->tdlut_groups_per_2row_ub));
outputs->ExtraLatencyPrefetch = ms->ExtraLatencyPrefetch;
outputs->ExtraLatency = ms->ExtraLatency;
outputs->ExtraLatency_sr = ms->ExtraLatency_sr;
memcpy(outputs->WritebackDelay, ms->WritebackDelayTime, sizeof(outputs->WritebackDelay));
memcpy(outputs->excess_vactive_fill_bw_c, ms->excess_vactive_fill_bw_c, sizeof(outputs->excess_vactive_fill_bw_c));
memcpy(outputs->excess_vactive_fill_bw_l, ms->excess_vactive_fill_bw_l, sizeof(outputs->excess_vactive_fill_bw_l));
memcpy(outputs->NotEnoughUrgentLatencyHiding, ms->NotEnoughUrgentLatencyHiding, sizeof(outputs->NotEnoughUrgentLatencyHiding));
memcpy(outputs->UrgentBurstFactorCursor, ms->UrgentBurstFactorCursor, sizeof(outputs->UrgentBurstFactorCursor));
memcpy(outputs->UrgentBurstFactorChroma, ms->UrgentBurstFactorChroma, sizeof(outputs->UrgentBurstFactorChroma));
memcpy(outputs->cursor_bytes_per_chunk, ms->cursor_bytes_per_chunk, sizeof(outputs->cursor_bytes_per_chunk));
memcpy(outputs->cursor_bytes_per_line, ms->cursor_bytes_per_line, sizeof(outputs->cursor_bytes_per_line));
memcpy(outputs->UrgentBurstFactorCursorPre, ms->UrgentBurstFactorCursorPre, sizeof(outputs->UrgentBurstFactorCursorPre));
memcpy(outputs->UrgentBurstFactorLuma, ms->UrgentBurstFactorLuma, sizeof(outputs->UrgentBurstFactorLuma));
memcpy(outputs->MaxVStartupLines, ms->MaxVStartupLines, sizeof(outputs->MaxVStartupLines));
memcpy(outputs->Tr0_trips_flip_rounded, ms->Tr0_trips_flip_rounded, sizeof(outputs->Tr0_trips_flip_rounded));
memcpy(outputs->Tno_bw_flip, ms->Tno_bw_flip, sizeof(outputs->Tno_bw_flip));
memcpy(outputs->dst_y_prefetch, ms->dst_y_prefetch, sizeof(outputs->dst_y_prefetch));
memcpy(outputs->DSTXAfterScaler, ms->DSTXAfterScaler, sizeof(outputs->DSTXAfterScaler));
memcpy(outputs->DSTYAfterScaler, ms->DSTYAfterScaler, sizeof(outputs->DSTYAfterScaler));
memcpy(outputs->Tr0_trips_flip, ms->Tr0_trips_flip, sizeof(outputs->Tr0_trips_flip));
memcpy(outputs->VReadyOffsetPix, ms->VReadyOffsetPix, sizeof(outputs->VReadyOffsetPix));
memcpy(outputs->prefetch_vmrow_bw, ms->prefetch_vmrow_bw, sizeof(outputs->prefetch_vmrow_bw));
memcpy(outputs->dst_y_per_vm_vblank, ms->LinesForVM, sizeof(outputs->dst_y_per_vm_vblank));
memcpy(outputs->VUpdateOffsetPix, ms->VUpdateOffsetPix, sizeof(outputs->VUpdateOffsetPix));
memcpy(outputs->RequiredPrefetchPixelDataBWLuma, ms->RequiredPrefetchPixelDataBWLuma, sizeof(outputs->RequiredPrefetchPixelDataBWLuma));
memcpy(outputs->Tno_bw, ms->Tno_bw, sizeof(outputs->Tno_bw));
memcpy(outputs->TSetup, ms->TSetup, sizeof(outputs->TSetup));
memcpy(outputs->Tdmdl_vm_raw, ms->Tdmdl_vm_raw, sizeof(outputs->Tdmdl_vm_raw));
memcpy(outputs->VRatioPrefetchY, ms->VRatioPreY, sizeof(outputs->VRatioPrefetchY));
memcpy(outputs->prefetch_cursor_bw, ms->prefetch_cursor_bw, sizeof(outputs->prefetch_cursor_bw));
memcpy(outputs->NotEnoughTimeForDynamicMetadata, ms->NoTimeForDynamicMetadata, sizeof(outputs->NotEnoughTimeForDynamicMetadata));
memcpy(outputs->RequiredPrefetchPixelDataBWChroma, ms->RequiredPrefetchPixelDataBWChroma, sizeof(outputs->RequiredPrefetchPixelDataBWChroma));
memcpy(outputs->VUpdateWidthPix, ms->VUpdateWidthPix, sizeof(outputs->VUpdateWidthPix));
memcpy(outputs->NoTimeToPrefetch, ms->NoTimeForPrefetch, sizeof(outputs->NoTimeToPrefetch));
memcpy(outputs->dst_y_per_row_vblank, ms->LinesForDPTERow, sizeof(outputs->dst_y_per_row_vblank));
memcpy(outputs->Tdmdl_raw, ms->Tdmdl_raw, sizeof(outputs->Tdmdl_raw));
memcpy(outputs->Tvm_trips_flip, ms->Tvm_trips_flip, sizeof(outputs->Tvm_trips_flip));
memcpy(outputs->TWait, ms->TWait, sizeof(outputs->TWait));
memcpy(outputs->VRatioPrefetchC, ms->VRatioPreC, sizeof(outputs->VRatioPrefetchC));
memcpy(outputs->Tvm_trips_flip_rounded, ms->Tvm_trips_flip_rounded, sizeof(outputs->Tvm_trips_flip_rounded));
memcpy(outputs->VStartupMin, ms->VStartupMin, sizeof(outputs->VStartupMin));
outputs->PrefetchScheduleSupported = ms->support.PrefetchScheduleSupported;
memcpy(outputs->UrgentBurstFactorLumaPre, ms->UrgentBurstFactorLumaPre, sizeof(outputs->UrgentBurstFactorLumaPre));
memcpy(outputs->UrgentBurstFactorChromaPre, ms->UrgentBurstFactorChromaPre, sizeof(outputs->UrgentBurstFactorChromaPre));
memcpy(outputs->NotEnoughUrgentLatencyHidingPre, ms->NotEnoughUrgentLatencyHidingPre, sizeof(outputs->NotEnoughUrgentLatencyHidingPre));
memcpy(outputs->urg_vactive_bandwidth_required, ms->support.urg_vactive_bandwidth_required, sizeof(outputs->urg_vactive_bandwidth_required));
memcpy(outputs->urg_bandwidth_required, ms->support.urg_bandwidth_required, sizeof(outputs->urg_bandwidth_required));
memcpy(outputs->non_urg_bandwidth_required, ms->support.non_urg_bandwidth_required, sizeof(outputs->non_urg_bandwidth_required));
memcpy(outputs->urg_bandwidth_required_flip, ms->support.urg_bandwidth_required_flip, sizeof(outputs->urg_bandwidth_required_flip));
memcpy(outputs->non_urg_bandwidth_required_flip, ms->support.non_urg_bandwidth_required_flip, sizeof(outputs->non_urg_bandwidth_required_flip));
outputs->PrefetchModeSupported = ms->support.PrefetchSupported;
memcpy(outputs->final_flip_bw, ms->final_flip_bw, sizeof(outputs->final_flip_bw));
memcpy(outputs->ImmediateFlipSupportedForPipe, ms->ImmediateFlipSupportedForPipe, sizeof(outputs->ImmediateFlipSupportedForPipe));
memcpy(outputs->dst_y_per_vm_flip, ms->dst_y_per_vm_flip, sizeof(outputs->dst_y_per_vm_flip));
memcpy(outputs->dst_y_per_row_flip, ms->dst_y_per_row_flip, sizeof(outputs->dst_y_per_row_flip));
outputs->Watermark = ms->support.watermarks;
memcpy(outputs->DRAMClockChangeSupport, ms->support.DRAMClockChangeSupport, sizeof(outputs->DRAMClockChangeSupport));
outputs->global_dram_clock_change_supported = ms->support.global_dram_clock_change_supported;
memcpy(outputs->MaxActiveDRAMClockChangeLatencySupported, ms->MaxActiveDRAMClockChangeLatencySupported, sizeof(outputs->MaxActiveDRAMClockChangeLatencySupported));
memcpy(outputs->SubViewportLinesNeededInMALL, ms->SubViewportLinesNeededInMALL, sizeof(outputs->SubViewportLinesNeededInMALL));
memcpy(outputs->FCLKChangeSupport, ms->support.FCLKChangeSupport, sizeof(outputs->FCLKChangeSupport));
outputs->global_fclk_change_supported = ms->support.global_fclk_change_supported;
outputs->MaxActiveFCLKChangeLatencySupported = ms->MaxActiveFCLKChangeLatencySupported;
outputs->USRRetrainingSupport = ms->support.USRRetrainingSupport;
outputs->global_temp_read_or_ppt_supported = ms->support.global_temp_read_or_ppt_supported;
memcpy(outputs->VActiveLatencyHidingUs, ms->VActiveLatencyHidingUs, sizeof(outputs->VActiveLatencyHidingUs));
outputs->ImmediateFlipSupported = ms->support.ImmediateFlipSupport;
outputs->svp0_max_bytes = ms->svp0_max_bytes;
outputs->svp1_max_bytes = ms->svp1_max_bytes;
memcpy(outputs->svp0_max_bytes_per_dpp, ms->svp0_max_bytes_per_dpp, sizeof(outputs->svp0_max_bytes_per_dpp));
memcpy(outputs->svp0_max_bytes_per_dpp_c, ms->svp0_max_bytes_per_dpp_c, sizeof(outputs->svp0_max_bytes_per_dpp_c));
memcpy(outputs->svp1_max_bytes_per_dpp, ms->svp1_max_bytes_per_dpp, sizeof(outputs->svp1_max_bytes_per_dpp));
memcpy(outputs->svp1_max_bytes_per_dpp_c, ms->svp1_max_bytes_per_dpp_c, sizeof(outputs->svp1_max_bytes_per_dpp_c));
memcpy(outputs->svp0_dst_lines, ms->svp0_dst_lines, sizeof(outputs->svp0_dst_lines));
memcpy(outputs->svp1_dst_lines, ms->svp1_dst_lines, sizeof(outputs->svp1_dst_lines));
memcpy(outputs->svp_req_limit, ms->svp_req_limit, sizeof(outputs->svp_req_limit));
memcpy(outputs->nom_req_limit_alt, ms->nom_req_limit_alt, sizeof(outputs->nom_req_limit_alt));
memcpy(outputs->min_lead_dst_lines, ms->min_lead_dst_lines, sizeof(outputs->min_lead_dst_lines));
memcpy(outputs->total_swaths, ms->total_swaths, sizeof(outputs->total_swaths));
memcpy(outputs->total_swaths_c, ms->total_swaths_c, sizeof(outputs->total_swaths_c));
memcpy(outputs->prefetch_swaths, ms->prefetch_swaths, sizeof(outputs->prefetch_swaths));
memcpy(outputs->prefetch_swaths_c, ms->prefetch_swaths_c, sizeof(outputs->prefetch_swaths_c));
memcpy(outputs->prefetch_hdl_delta, ms->prefetch_hdl_delta, sizeof(outputs->prefetch_hdl_delta));
memcpy(outputs->recout_hdl_delta, ms->recout_hdl_delta, sizeof(outputs->recout_hdl_delta));
memcpy(outputs->prefetch_hdl_delta_c, ms->prefetch_hdl_delta_c, sizeof(outputs->prefetch_hdl_delta_c));
memcpy(outputs->recout_hdl_delta_c, ms->recout_hdl_delta_c, sizeof(outputs->recout_hdl_delta_c));
memcpy(outputs->max_prefetch_in_lines, ms->max_prefetch_in_lines, sizeof(outputs->max_prefetch_in_lines));
}
enum dml2_status dml2_core_dcn6_funcs_populate_programming(struct dml2_core_instance *core,
const struct dml2_display_solution *solution,
struct dml2_display_cfg_programming *programming)
{
struct dml2_core_internal_display_mode_lib *mode_lib = &core->clean_me_up.mode_lib;
struct dml2_core_calculate_mp_context *calc_mp_ctx = &core->scratch.mode_programming_locals.calc_mp_ctx;
enum dml2_status status;
DML_LOG_COMP_IF_ENTER();
memset(&mode_lib->scratch, 0, sizeof(struct dml2_core_internal_scratch));
memset(&mode_lib->mp, 0, sizeof(struct dml2_core_internal_mode_program));
memset(&core->scratch.mode_programming_locals.temp_result, 0, sizeof(struct dml2_validation_result));
status = core->validate_solution(core, solution, &core->scratch.mode_programming_locals.temp_result);
DML_ASSERT_MSG(status == DML2_STATUS_OK,
"an invalid solution is passed into populate_programming interface! (status = %s)\n",
dml2_status_str(status));
dcn6_mp_initialize_from_ms(&mode_lib->mp, &mode_lib->ms);
dcn6_mp_initialize_from_solution(&mode_lib->mp, solution, core->utm_soc_bb);
dcn6_mp_build_calculate_mp_context(calc_mp_ctx, core, solution);
dcn6_calculate_mode_programming(calc_mp_ctx, &mode_lib->mp);
dcn6_populate_mode_programming(calc_mp_ctx, programming, &mode_lib->scratch, mode_lib, solution, core->utm_soc_bb);
DML_LOG_DEBUG("%s exit\n", __func__);
DML_LOG_COMP_IF_EXIT();
return status;
}