#include "dml2_top_utm.h"
#include "dml2_top_soc15.h"
#include "dml2_mcg_factory.h"
#include "dml2_dpmm_factory.h"
#include "dml2_core_factory.h"
#include "dml2_pmo_factory.h"
#include "dml2_utm_soc_bb_factory.h"
#include "dml2_cga_factory.h"
#include "dml2_debug.h"
static void dml2_top_backup_worksheet(struct dml2_instance *dml, const struct dml2_optimization_worksheet *worksheet)
{
memcpy(&dml->scratch.worksheet_backup, worksheet, sizeof(struct dml2_optimization_worksheet));
}
static void dml2_top_restore_worksheet(struct dml2_instance *dml, struct dml2_optimization_worksheet *worksheet)
{
memcpy(worksheet, &dml->scratch.worksheet_backup, sizeof(struct dml2_optimization_worksheet));
}
static enum dml2_status dml2_top_validate_worksheet(struct dml2_instance *dml,
struct dml2_optimization_worksheet *worksheet)
{
struct dml2_pmo_instance *pmo = &dml->pmo_instance;
struct dml2_core_instance *core = &dml->core_instance;
struct dml2_display_solution *solution = &dml->scratch.solution;
enum dml2_status status;
status = pmo->optional_sanity_check(pmo, worksheet);
if (status == DML2_STATUS_OK) {
pmo->convert_worksheet_to_solution(pmo, worksheet, solution);
status = core->validate_solution(core, solution, &worksheet->validation_result);
pmo->clear_pre_validation_states(pmo, worksheet);
} else
worksheet->validation_result.is_mode_support_valid = false;
return status;
}
static enum dml2_status dml2_top_perform_stage_optimization(struct dml2_instance *dml,
struct dml2_pmo_stage_optimizer *optimizer,
struct dml2_optimization_worksheet *worksheet)
{
static const unsigned int MAX_OPTIMIZATION_ITERATIONS = 20;
unsigned int iteration = 0;
enum dml2_status cur_validate_status = DML2_STATUS_OK;
enum dml2_status cur_optimize_status = DML2_STATUS_UNKNOWN;
bool is_permissible_found = false;
dml2_top_backup_worksheet(dml, worksheet);
optimizer->init(optimizer, worksheet);
while (optimizer->optimize_next(optimizer, worksheet)) {
if (++iteration >= MAX_OPTIMIZATION_ITERATIONS) {
cur_optimize_status = DML2_STATUS_OPTIMIZE_FAIL_EXCEED_MAX_ITERATION;
break;
}
cur_optimize_status = DML2_STATUS_UNKNOWN;
cur_validate_status = dml2_top_validate_worksheet(dml, worksheet);
if (cur_validate_status == DML2_STATUS_OK)
cur_optimize_status = optimizer->test_permissibility(optimizer, worksheet);
if (cur_validate_status == DML2_STATUS_OK && cur_optimize_status == DML2_STATUS_OK) {
is_permissible_found = true;
dml2_top_backup_worksheet(dml, worksheet);
}
}
if (cur_validate_status == DML2_STATUS_OK && cur_optimize_status == DML2_STATUS_UNKNOWN) {
cur_optimize_status = optimizer->test_permissibility(optimizer, worksheet);
if (cur_optimize_status == DML2_STATUS_OK)
is_permissible_found = true;
}
if (cur_validate_status != DML2_STATUS_OK || cur_optimize_status != DML2_STATUS_OK)
dml2_top_restore_worksheet(dml, worksheet);
DML_ASSERT_MSG(worksheet->validation_result.is_mode_support_valid
&& worksheet->validation_result.is_mcache_allocation_valid
&& worksheet->validation_result.is_prefetch_valid,
"worksheet must be valid on exit independent from optimization result!\n");
return is_permissible_found ? DML2_STATUS_OK :
(cur_validate_status != DML2_STATUS_OK) ? cur_validate_status : cur_optimize_status;
}
static enum dml2_status dml2_top_build_and_validate_unoptimized_worksheet(
struct dml2_instance *dml,
const struct dml2_display_cfg *orig_dispcfg,
struct dml2_optimization_worksheet *worksheet)
{
enum dml2_status status = DML2_STATUS_OK;
struct dml2_pmo_instance *pmo = &dml->pmo_instance;
struct dml2_pmo_stage_optimizer *optimizers[dml2_pmo_stage_index_max];
int count;
int i;
if (status == DML2_STATUS_OK) {
pmo->initialize_worksheet(pmo, orig_dispcfg, worksheet);
status = dml2_top_validate_worksheet(dml, worksheet);
}
if (status == DML2_STATUS_OK) {
count = pmo->get_ordered_mandatory_stage_optimizers(pmo, optimizers);
for (i = 0; i < count; i++) {
status = dml2_top_perform_stage_optimization(dml, optimizers[i], worksheet);
if (status != DML2_STATUS_OK)
break;
}
}
return status;
}
static void dml2_top_optimize_worksheet(struct dml2_instance *dml,
struct dml2_optimization_worksheet *worksheet)
{
struct dml2_pmo_instance *pmo = &dml->pmo_instance;
struct dml2_pmo_stage_optimizer *ordered_optional_stage_optimizers[dml2_pmo_stage_index_max];
int count;
int i;
DML_ASSERT(worksheet->validation_result.is_mode_support_valid);
count = pmo->get_ordered_optional_stage_optimizers(pmo, ordered_optional_stage_optimizers);
for (i = 0; i < count; i++)
dml2_top_perform_stage_optimization(dml, ordered_optional_stage_optimizers[i], worksheet);
}
static enum dml2_status dml2_top_map_minimum_clock_state(struct dml2_instance *dml,
struct dml2_display_solution *solution,
struct dml2_display_cfg_programming *programming)
{
bool result;
struct dml2_dpmm_map_mode_to_soc_dpm_params_in_out *params =
&dml->scratch.build_mode_programming_locals.dppm_map_mode_params;
struct dml2_dpmm_instance *dpmm = &dml->dpmm_instance;
if (!dpmm->map_mode_to_soc_dpm)
return DML2_STATUS_OK;
params->utm_soc_bb = &dml->utm_soc_bb;
params->ip = &dml->core_instance.clean_me_up.mode_lib.ip;
params->solution = solution;
params->programming = programming;
result = dpmm->map_mode_to_soc_dpm(params);
return result ? DML2_STATUS_OK : DML2_STATUS_POPULATE_FAIL_MIN_CLOCK_STATE;
}
static enum dml2_status dml2_top_populate_mode_programming(struct dml2_instance *dml,
const struct dml2_display_solution *solution,
struct dml2_display_cfg_programming *programming)
{
enum dml2_status status;
struct dml2_core_instance *core = &dml->core_instance;
status = core->populate_programming(core, solution, programming);
return status;
}
static void dml2_top_populate_informative(struct dml2_instance *dml,
enum dml2_status status,
struct dml2_display_cfg_programming *programming)
{
struct dml2_core_populate_informative_in_out *params = &dml->scratch.build_mode_programming_locals.informative_params;
struct dml2_core_instance *core = &dml->core_instance;
params->instance = core;
params->programming = programming;
params->mode_is_supported = (status == DML2_STATUS_OK);
params->instance->scratch.mode_programming_locals.mode_programming_ex_params.min_clk_index =
dml->scratch.solution.sop_constraint.dcn5.min_sop_index;
dml->core_instance.populate_informative(params);
if (status == DML2_STATUS_POPULATE_FAIL_PROGRAMMING ||
status == DML2_STATUS_VALIDATE_FAIL_MODE_SUPPORT_PREFETCH ||
status == DML2_STATUS_VALIDATE_FAIL_MODE_SUPPORT_PREFETCH_URGENT)
programming->informative.failed_mode_programming_prefetch = true;
else if (status == DML2_STATUS_POPULATE_FAIL_PROGRAMMING_DCFCLK)
programming->informative.failed_mode_programming_dcfclk = true;
else if (status == DML2_STATUS_POPULATE_FAIL_PROGRAMMING_FLIP_BANDWIDTH ||
status == DML2_STATUS_VALIDATE_FAIL_MODE_SUPPORT_QOS_BANDWIDTH)
programming->informative.failed_mode_programming_flip = true;
else if (status == DML2_STATUS_POPULATE_FAIL_MIN_CLOCK_STATE)
programming->informative.failed_dpmm = true;
else if (status == DML2_STATUS_VALIDATE_FAIL_MCACHE ||
status == DML2_STATUS_OPTIMIZE_FAIL_MCACHE ||
status == DML2_STATUS_VALIDATE_FAIL_PMO_SANITY_TOTAL_PIPE_USAGE)
programming->informative.failed_mcache_validation = true;
else if (status == DML2_STATUS_OPTIMIZE_FAIL_UCLK_PSTATE)
programming->informative.failed_uclk_pstate = true;
else if (status == DML2_STATUS_VALIDATE_FAIL_PREFETCH)
programming->informative.failed_prefetch = true;
}
static enum dml2_status dml2_top_build_programming_for_worksheet(
struct dml2_instance *dml, const struct dml2_optimization_worksheet *worksheet,
struct dml2_display_cfg_programming *programming)
{
enum dml2_status status = DML2_STATUS_OK;
struct dml2_display_solution *solution = &dml->scratch.solution;
struct dml2_pmo_instance *pmo = &dml->pmo_instance;
memset(programming, 0, sizeof(struct dml2_display_cfg_programming));
pmo->convert_worksheet_to_solution(pmo, worksheet, solution);
if (status == DML2_STATUS_OK)
status = dml2_top_map_minimum_clock_state(dml, solution, programming);
if (status == DML2_STATUS_OK)
status = dml2_top_populate_mode_programming(dml, solution, programming);
return status;
}
static bool dml2_top_utm_check_mode_supported(struct dml2_check_mode_supported_in_out *in_out)
{
enum dml2_status status = DML2_STATUS_OK;
struct dml2_instance *dml = in_out->dml2_instance;
DML_LOG_TOP_IF_ENTER();
status = dml2_top_build_and_validate_unoptimized_worksheet(
dml, in_out->display_config, &dml->scratch.worksheet);
in_out->is_supported = (status == DML2_STATUS_OK);
DML_LOG_INFO("%s exit with %s\n", __func__, dml2_status_str(status));
DML_LOG_TOP_IF_EXIT();
return status == DML2_STATUS_OK;
}
static bool dml2_top_utm_build_mode_programming(struct dml2_build_mode_programming_in_out *in_out)
{
struct dml2_instance *dml = in_out->dml2_instance;
struct dml2_optimization_worksheet *worksheet = &dml->scratch.worksheet;
enum dml2_status status = DML2_STATUS_OK;
DML_LOG_TOP_IF_ENTER();
if (status == DML2_STATUS_OK)
status = dml2_top_build_and_validate_unoptimized_worksheet(dml, in_out->display_config, worksheet);
if (status == DML2_STATUS_OK) {
dml2_top_optimize_worksheet(dml, worksheet);
status = dml2_top_build_programming_for_worksheet(dml, worksheet, in_out->programming);
if (status != DML2_STATUS_OK)
DML_LOG_ERROR("build mode programming fails for a supported display config! (%s)\n",
dml2_status_str(status));
}
dml2_top_populate_informative(dml, status, in_out->programming);
if (status == DML2_STATUS_OK)
DML_LOG_INFO("%s exit with %s\n", __func__, dml2_status_str(status));
else
DML_LOG_WARN("%s exit with %s\n", __func__, dml2_status_str(status));
DML_LOG_TOP_IF_EXIT();
return status == DML2_STATUS_OK;
}
static const struct dml2_top_funcs utm_funcs = {
.check_mode_supported = dml2_top_utm_check_mode_supported,
.build_mode_programming = dml2_top_utm_build_mode_programming,
.build_mcache_programming = dml2_top_soc15_build_mcache_programming,
};
bool dml2_top_utm_initialize_instance(struct dml2_initialize_instance_in_out *in_out)
{
struct dml2_instance *dml = in_out->dml2_instance;
struct dml2_core_initialize_in_out core_init_params = { 0 };
struct dml2_pmo_initialize_in_out pmo_init_params = { 0 };
struct dml2_cga_initialize_in_out cga_init_params = { 0 };
bool result = true;
DML_LOG_TOP_IF_ENTER();
memset(dml, 0, sizeof(struct dml2_instance));
if (result) {
memcpy(&dml->ip_caps, &in_out->ip_caps, sizeof(struct dml2_ip_capabilities));
dml->project_id = in_out->options.project_id;
dml->pmo_options = in_out->options.pmo_options;
dml->funcs = utm_funcs;
}
if (result)
result = dml2_dpmm_create(in_out->options.project_id, &dml->dpmm_instance);
if (result)
result = dml2_core_create(in_out->options.project_id, &dml->core_instance);
if (result)
result = dml2_pmo_create(in_out->options.project_id, &dml->pmo_instance);
if (result)
result = dml2_utm_soc_bb_create(in_out->options.project_id, &dml->utm_soc_bb,
&in_out->soc_bb, in_out->overrides.explicit_qos_model);
if (result)
result = dml2_cga_create(in_out->options.project_id, &dml->clock_adjuster);
if (result) {
core_init_params.project_id = in_out->options.project_id;
core_init_params.instance = &dml->core_instance;
core_init_params.explicit_ip_bb = in_out->overrides.explicit_ip_bb;
core_init_params.explicit_ip_bb_size = in_out->overrides.explicit_ip_bb_size;
core_init_params.ip_caps = &dml->ip_caps;
core_init_params.utm_soc_bb = &dml->utm_soc_bb;
core_init_params.clock_adjuster = &dml->clock_adjuster;
result = dml->core_instance.initialize(&core_init_params);
}
if (result) {
pmo_init_params.instance = &dml->pmo_instance;
pmo_init_params.ip_caps = &dml->ip_caps;
pmo_init_params.utm_soc_bb = &dml->utm_soc_bb;
pmo_init_params.options = &dml->pmo_options;
dml->pmo_instance.initialize(&pmo_init_params);
}
if (result && dml->clock_adjuster.initialize) {
cga_init_params.adjuster = &dml->clock_adjuster;
cga_init_params.soc_bb = &in_out->soc_bb;
cga_init_params.ip = &dml->core_instance.clean_me_up.mode_lib.ip;
dml->clock_adjuster.initialize(&cga_init_params);
}
DML_LOG_DEBUG("%s exit with %s\n", __func__, result ? "true":"false");
DML_LOG_TOP_IF_EXIT();
return result;
}