#include <kunit/test.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include "dc.h"
#include "dm_services.h"
#include "dm_pp_smu.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_pp_smu.h"
#include "amdgpu_dm_kunit_test_helpers.h"
struct stub_dpm_context {
int ret_val;
struct amd_pp_clock_info get_current_clocks_info;
struct amd_pp_clocks get_clock_by_type_clocks;
struct amd_pp_simple_clock_info get_validation_clks;
int get_validation_clks_ret;
struct pp_clock_levels_with_latency get_clock_by_type_with_latency_clks;
struct pp_clock_levels_with_voltage get_clock_by_type_with_voltage_clks;
int set_watermarks_ret;
int display_clock_voltage_ret;
int display_disable_memory_clock_switch_ret;
int get_max_sustainable_ret;
int get_uclk_dpm_ret;
int get_dpm_clock_table_ret;
int set_active_display_count_ret;
int set_min_deep_sleep_dcefclk_ret;
};
static struct stub_dpm_context *stub_dpm_ctx;
static int stub_get_current_clocks(void *handle, struct amd_pp_clock_info *clocks)
{
if (stub_dpm_ctx->ret_val)
return stub_dpm_ctx->ret_val;
*clocks = stub_dpm_ctx->get_current_clocks_info;
return 0;
}
static int stub_get_clock_by_type(void *handle, enum amd_pp_clock_type type,
struct amd_pp_clocks *clocks)
{
if (stub_dpm_ctx->ret_val)
return stub_dpm_ctx->ret_val;
*clocks = stub_dpm_ctx->get_clock_by_type_clocks;
return 0;
}
static int stub_get_display_mode_validation_clocks(void *handle,
struct amd_pp_simple_clock_info *clocks)
{
if (stub_dpm_ctx->get_validation_clks_ret)
return stub_dpm_ctx->get_validation_clks_ret;
*clocks = stub_dpm_ctx->get_validation_clks;
return 0;
}
static int stub_get_clock_by_type_with_latency(void *handle,
enum amd_pp_clock_type type,
struct pp_clock_levels_with_latency *clocks)
{
if (stub_dpm_ctx->ret_val)
return stub_dpm_ctx->ret_val;
*clocks = stub_dpm_ctx->get_clock_by_type_with_latency_clks;
return 0;
}
static int stub_get_clock_by_type_with_voltage(void *handle,
enum amd_pp_clock_type type,
struct pp_clock_levels_with_voltage *clocks)
{
if (stub_dpm_ctx->ret_val)
return stub_dpm_ctx->ret_val;
*clocks = stub_dpm_ctx->get_clock_by_type_with_voltage_clks;
return 0;
}
static void stub_display_configuration_change(void *handle)
{
}
static void stub_pm_compute_clocks(void *handle)
{
}
static int stub_set_watermarks_for_clocks_ranges(void *handle, void *clock_ranges)
{
return stub_dpm_ctx->set_watermarks_ret;
}
static int stub_display_clock_voltage_request(void *handle,
struct pp_display_clock_request *clock)
{
return stub_dpm_ctx->display_clock_voltage_ret;
}
static int stub_set_active_display_count(void *handle, uint32_t count)
{
return stub_dpm_ctx->set_active_display_count_ret;
}
static int stub_set_min_deep_sleep_dcefclk(void *handle, uint32_t clock)
{
return stub_dpm_ctx->set_min_deep_sleep_dcefclk_ret;
}
static int stub_set_hard_min_dcefclk_by_freq(void *handle, uint32_t clock)
{
return 0;
}
static int stub_set_hard_min_fclk_by_freq(void *handle, uint32_t clock)
{
return 0;
}
static int stub_notify_smu_enable_pwe(void *handle)
{
return 0;
}
static int stub_display_disable_memory_clock_switch(void *handle,
bool disable_memory_clock_switch)
{
return stub_dpm_ctx->display_disable_memory_clock_switch_ret;
}
static int stub_get_max_sustainable_clocks_by_dc(void *handle,
struct pp_smu_nv_clock_table *max_clocks)
{
return stub_dpm_ctx->get_max_sustainable_ret;
}
static int stub_get_uclk_dpm_states(void *handle,
unsigned int *clock_values_in_khz,
unsigned int *num_states)
{
return stub_dpm_ctx->get_uclk_dpm_ret;
}
static int stub_get_dpm_clock_table(void *handle, struct dpm_clocks *clock_table)
{
return stub_dpm_ctx->get_dpm_clock_table_ret;
}
static const struct amd_pm_funcs stub_pp_funcs = {
.get_current_clocks = stub_get_current_clocks,
.get_clock_by_type = stub_get_clock_by_type,
.get_display_mode_validation_clocks = stub_get_display_mode_validation_clocks,
.get_clock_by_type_with_latency = stub_get_clock_by_type_with_latency,
.get_clock_by_type_with_voltage = stub_get_clock_by_type_with_voltage,
.display_configuration_changed = stub_display_configuration_change,
.pm_compute_clocks = stub_pm_compute_clocks,
.set_watermarks_for_clocks_ranges = stub_set_watermarks_for_clocks_ranges,
.display_clock_voltage_request = stub_display_clock_voltage_request,
.set_active_display_count = stub_set_active_display_count,
.set_min_deep_sleep_dcefclk = stub_set_min_deep_sleep_dcefclk,
.set_hard_min_dcefclk_by_freq = stub_set_hard_min_dcefclk_by_freq,
.set_hard_min_fclk_by_freq = stub_set_hard_min_fclk_by_freq,
.notify_smu_enable_pwe = stub_notify_smu_enable_pwe,
.display_disable_memory_clock_switch = stub_display_disable_memory_clock_switch,
.get_max_sustainable_clocks_by_dc = stub_get_max_sustainable_clocks_by_dc,
.get_uclk_dpm_states = stub_get_uclk_dpm_states,
.get_dpm_clock_table = stub_get_dpm_clock_table,
};
static void setup_stub_dpm(struct kunit *test, struct amdgpu_device *adev)
{
stub_dpm_ctx = kunit_kzalloc(test, sizeof(*stub_dpm_ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, stub_dpm_ctx);
adev->powerplay.pp_funcs = &stub_pp_funcs;
adev->powerplay.pp_handle = adev;
mutex_init(&adev->pm.mutex);
}
static void dm_test_default_clock_levels_display(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
uint32_t expected[] = { 300000, 400000, 496560, 626090, 685720, 757900 };
int i;
get_default_clock_levels(DM_PP_CLOCK_TYPE_DISPLAY_CLK, &clks);
KUNIT_EXPECT_EQ(test, clks.num_levels, 6U);
for (i = 0; i < 6; i++)
KUNIT_EXPECT_EQ(test, clks.clocks_in_khz[i], expected[i]);
}
static void dm_test_default_clock_levels_engine(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
uint32_t expected[] = { 300000, 360000, 423530, 514290, 626090, 720000 };
int i;
get_default_clock_levels(DM_PP_CLOCK_TYPE_ENGINE_CLK, &clks);
KUNIT_EXPECT_EQ(test, clks.num_levels, 6U);
for (i = 0; i < 6; i++)
KUNIT_EXPECT_EQ(test, clks.clocks_in_khz[i], expected[i]);
}
static void dm_test_default_clock_levels_memory(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
get_default_clock_levels(DM_PP_CLOCK_TYPE_MEMORY_CLK, &clks);
KUNIT_EXPECT_EQ(test, clks.num_levels, 2U);
KUNIT_EXPECT_EQ(test, clks.clocks_in_khz[0], 333000U);
KUNIT_EXPECT_EQ(test, clks.clocks_in_khz[1], 800000U);
}
static void dm_test_default_clock_levels_unknown(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
get_default_clock_levels(DM_PP_CLOCK_TYPE_FCLK, &clks);
KUNIT_EXPECT_EQ(test, clks.num_levels, 0U);
}
static void dm_test_dc_to_pp_clock_type_display(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_DISPLAY_CLK),
(int)amd_pp_disp_clock);
}
static void dm_test_dc_to_pp_clock_type_engine(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_ENGINE_CLK),
(int)amd_pp_sys_clock);
}
static void dm_test_dc_to_pp_clock_type_memory(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_MEMORY_CLK),
(int)amd_pp_mem_clock);
}
static void dm_test_dc_to_pp_clock_type_dcefclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_DCEFCLK),
(int)amd_pp_dcef_clock);
}
static void dm_test_dc_to_pp_clock_type_dcfclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_DCFCLK),
(int)amd_pp_dcf_clock);
}
static void dm_test_dc_to_pp_clock_type_pixelclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_PIXELCLK),
(int)amd_pp_pixel_clock);
}
static void dm_test_dc_to_pp_clock_type_fclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_FCLK),
(int)amd_pp_f_clock);
}
static void dm_test_dc_to_pp_clock_type_phyclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_DISPLAYPHYCLK),
(int)amd_pp_phy_clock);
}
static void dm_test_dc_to_pp_clock_type_dppclk(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(DM_PP_CLOCK_TYPE_DPPCLK),
(int)amd_pp_dpp_clock);
}
static void dm_test_dc_to_pp_clock_type_invalid(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)dc_to_pp_clock_type(0), 0);
}
static void dm_test_pp_to_dc_clock_levels_within_limit(struct kunit *test)
{
struct amd_pp_clocks pp_clks = {};
struct dm_pp_clock_levels dc_clks = {};
pp_clks.count = 3;
pp_clks.clock[0] = 300000;
pp_clks.clock[1] = 500000;
pp_clks.clock[2] = 700000;
pp_to_dc_clock_levels(&pp_clks, &dc_clks, DM_PP_CLOCK_TYPE_ENGINE_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 3U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[0], 300000U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[1], 500000U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[2], 700000U);
}
static void dm_test_pp_to_dc_clock_levels_caps_at_max(struct kunit *test)
{
struct amd_pp_clocks pp_clks = {};
struct dm_pp_clock_levels dc_clks = {};
uint32_t i;
pp_clks.count = DM_PP_MAX_CLOCK_LEVELS + 1;
for (i = 0; i < DM_PP_MAX_CLOCK_LEVELS; i++)
pp_clks.clock[i] = (i + 1) * 100000;
pp_to_dc_clock_levels(&pp_clks, &dc_clks, DM_PP_CLOCK_TYPE_ENGINE_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, (uint32_t)DM_PP_MAX_CLOCK_LEVELS);
}
static void dm_test_pp_to_dc_clock_levels_latency_within_limit(struct kunit *test)
{
struct pp_clock_levels_with_latency pp_clks = {};
struct dm_pp_clock_levels_with_latency dc_clks = {};
pp_clks.num_levels = 2;
pp_clks.data[0].clocks_in_khz = 400000;
pp_clks.data[0].latency_in_us = 10;
pp_clks.data[1].clocks_in_khz = 800000;
pp_clks.data[1].latency_in_us = 20;
pp_to_dc_clock_levels_with_latency(&pp_clks, &dc_clks,
DM_PP_CLOCK_TYPE_ENGINE_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 2U);
KUNIT_EXPECT_EQ(test, dc_clks.data[0].clocks_in_khz, 400000U);
KUNIT_EXPECT_EQ(test, dc_clks.data[0].latency_in_us, 10U);
KUNIT_EXPECT_EQ(test, dc_clks.data[1].clocks_in_khz, 800000U);
KUNIT_EXPECT_EQ(test, dc_clks.data[1].latency_in_us, 20U);
}
static void dm_test_pp_to_dc_clock_levels_latency_caps_at_max(struct kunit *test)
{
struct pp_clock_levels_with_latency pp_clks = {};
struct dm_pp_clock_levels_with_latency dc_clks = {};
pp_clks.num_levels = DM_PP_MAX_CLOCK_LEVELS + 1;
pp_to_dc_clock_levels_with_latency(&pp_clks, &dc_clks,
DM_PP_CLOCK_TYPE_ENGINE_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, (uint32_t)DM_PP_MAX_CLOCK_LEVELS);
}
static void dm_test_pp_to_dc_clock_levels_voltage_within_limit(struct kunit *test)
{
struct pp_clock_levels_with_voltage pp_clks = {};
struct dm_pp_clock_levels_with_voltage dc_clks = {};
pp_clks.num_levels = 2;
pp_clks.data[0].clocks_in_khz = 300000;
pp_clks.data[0].voltage_in_mv = 800;
pp_clks.data[1].clocks_in_khz = 600000;
pp_clks.data[1].voltage_in_mv = 950;
pp_to_dc_clock_levels_with_voltage(&pp_clks, &dc_clks,
DM_PP_CLOCK_TYPE_MEMORY_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 2U);
KUNIT_EXPECT_EQ(test, dc_clks.data[0].clocks_in_khz, 300000U);
KUNIT_EXPECT_EQ(test, dc_clks.data[0].voltage_in_mv, 800U);
KUNIT_EXPECT_EQ(test, dc_clks.data[1].clocks_in_khz, 600000U);
KUNIT_EXPECT_EQ(test, dc_clks.data[1].voltage_in_mv, 950U);
}
static void dm_test_pp_to_dc_clock_levels_voltage_caps_at_max(struct kunit *test)
{
struct pp_clock_levels_with_voltage pp_clks = {};
struct dm_pp_clock_levels_with_voltage dc_clks = {};
pp_clks.num_levels = DM_PP_MAX_CLOCK_LEVELS + 1;
pp_to_dc_clock_levels_with_voltage(&pp_clks, &dc_clks,
DM_PP_CLOCK_TYPE_MEMORY_CLK);
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, (uint32_t)DM_PP_MAX_CLOCK_LEVELS);
}
static void dm_test_get_funcs_rv(struct kunit *test)
{
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu_funcs *funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, funcs);
ctx->dce_version = DCN_VERSION_1_0;
dm_pp_get_funcs(ctx, funcs);
KUNIT_EXPECT_EQ(test, funcs->ctx.ver, PP_SMU_VER_RV);
KUNIT_EXPECT_PTR_EQ(test, funcs->rv_funcs.pp_smu.dm, ctx);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_wm_ranges != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_pme_wa_enable != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_display_count != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_min_deep_sleep_dcfclk != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_hard_min_dcfclk_by_freq != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_hard_min_fclk_by_freq != NULL);
KUNIT_EXPECT_FALSE(test, funcs->rv_funcs.set_hard_min_socclk_by_freq != NULL);
}
static void dm_test_get_funcs_rv_101(struct kunit *test)
{
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu_funcs *funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, funcs);
ctx->dce_version = DCN_VERSION_1_01;
dm_pp_get_funcs(ctx, funcs);
KUNIT_EXPECT_EQ(test, funcs->ctx.ver, PP_SMU_VER_RV);
KUNIT_EXPECT_PTR_EQ(test, funcs->rv_funcs.pp_smu.dm, ctx);
KUNIT_EXPECT_TRUE(test, funcs->rv_funcs.set_display_count != NULL);
}
static void dm_test_get_funcs_nv(struct kunit *test)
{
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu_funcs *funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, funcs);
ctx->dce_version = DCN_VERSION_2_0;
dm_pp_get_funcs(ctx, funcs);
KUNIT_EXPECT_EQ(test, funcs->ctx.ver, PP_SMU_VER_NV);
KUNIT_EXPECT_PTR_EQ(test, funcs->nv_funcs.pp_smu.dm, ctx);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_display_count != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_hard_min_dcfclk_by_freq != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_min_deep_sleep_dcfclk != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_voltage_by_freq != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_wm_ranges != NULL);
KUNIT_EXPECT_FALSE(test, funcs->nv_funcs.set_pme_wa_enable != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_hard_min_uclk_by_freq != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.get_maximum_sustainable_clocks != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.get_uclk_dpm_states != NULL);
KUNIT_EXPECT_TRUE(test, funcs->nv_funcs.set_pstate_handshake_support != NULL);
}
static void dm_test_get_funcs_rn(struct kunit *test)
{
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu_funcs *funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, funcs);
ctx->dce_version = DCN_VERSION_2_1;
dm_pp_get_funcs(ctx, funcs);
KUNIT_EXPECT_EQ(test, funcs->ctx.ver, PP_SMU_VER_RN);
KUNIT_EXPECT_PTR_EQ(test, funcs->rn_funcs.pp_smu.dm, ctx);
KUNIT_EXPECT_TRUE(test, funcs->rn_funcs.set_wm_ranges != NULL);
KUNIT_EXPECT_TRUE(test, funcs->rn_funcs.get_dpm_clock_table != NULL);
}
static void dm_test_get_funcs_unsupported(struct kunit *test)
{
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu_funcs *funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, funcs);
ctx->dce_version = DCE_VERSION_MAX;
dm_pp_get_funcs(ctx, funcs);
KUNIT_EXPECT_EQ(test, funcs->ctx.ver, PP_SMU_UNSUPPORTED);
KUNIT_EXPECT_FALSE(test, funcs->rv_funcs.set_wm_ranges != NULL);
}
static void dm_test_apply_display_requirements_dpm_disabled(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_display_configuration cfg = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
adev->pm.dpm_enabled = false;
ctx->driver_context = adev;
KUNIT_EXPECT_TRUE(test, dm_pp_apply_display_requirements(ctx, &cfg));
}
static void dm_test_apply_clock_for_voltage_invalid_type(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_for_voltage_req req = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
ctx->driver_context = adev;
req.clk_type = (enum dm_pp_clock_type)0xffff;
req.clocks_in_khz = 500000;
KUNIT_EXPECT_FALSE(test, dm_pp_apply_clock_for_voltage_request(ctx, &req));
}
static void dm_test_build_pm_display_cfg_scalar_fields(struct kunit *test)
{
struct amd_pp_display_configuration *pm =
kunit_kzalloc(test, sizeof(*pm), GFP_KERNEL);
struct dm_pp_display_configuration *pp =
kunit_kzalloc(test, sizeof(*pp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, pm);
KUNIT_ASSERT_NOT_NULL(test, pp);
pp->cpu_cc6_disable = true;
pp->cpu_pstate_disable = true;
pp->cpu_pstate_separation_time = 7;
pp->nb_pstate_switch_disable = true;
pp->display_count = 2;
pp->min_engine_clock_khz = 300000;
pp->min_engine_clock_deep_sleep_khz = 50000;
pp->min_memory_clock_khz = 800000;
pp->min_dcfclock_khz = 600000;
pp->all_displays_in_sync = true;
pp->avail_mclk_switch_time_us = 11;
pp->disp_clk_khz = 400000;
pp->avail_mclk_switch_time_in_disp_active_us = 13;
pp->crtc_index = 3;
pp->line_time_in_us = 17;
pp->disp_configs[0].v_refresh = 60;
build_pm_display_cfg(pm, pp);
KUNIT_EXPECT_TRUE(test, pm->cpu_cc6_disable);
KUNIT_EXPECT_TRUE(test, pm->cpu_pstate_disable);
KUNIT_EXPECT_EQ(test, pm->cpu_pstate_separation_time, 7);
KUNIT_EXPECT_TRUE(test, pm->nb_pstate_switch_disable);
KUNIT_EXPECT_EQ(test, pm->num_display, 2);
KUNIT_EXPECT_EQ(test, pm->num_path_including_non_display, 2);
KUNIT_EXPECT_EQ(test, pm->min_core_set_clock, 30000);
KUNIT_EXPECT_EQ(test, pm->min_core_set_clock_in_sr, 5000);
KUNIT_EXPECT_EQ(test, pm->min_mem_set_clock, 80000);
KUNIT_EXPECT_EQ(test, pm->min_dcef_deep_sleep_set_clk, 5000);
KUNIT_EXPECT_EQ(test, pm->min_dcef_set_clk, 60000);
KUNIT_EXPECT_TRUE(test, pm->multi_monitor_in_sync);
KUNIT_EXPECT_EQ(test, pm->min_vblank_time, 11);
KUNIT_EXPECT_EQ(test, pm->display_clk, 40000);
KUNIT_EXPECT_EQ(test, pm->dce_tolerable_mclk_in_active_latency, 13);
KUNIT_EXPECT_EQ(test, pm->crtc_index, 3);
KUNIT_EXPECT_EQ(test, pm->line_time_in_us, 17);
KUNIT_EXPECT_EQ(test, pm->vrefresh, 60);
KUNIT_EXPECT_EQ(test, pm->crossfire_display_index, -1);
KUNIT_EXPECT_EQ(test, pm->min_bus_bandwidth, 0);
}
static void dm_test_build_pm_display_cfg_per_display(struct kunit *test)
{
struct amd_pp_display_configuration *pm =
kunit_kzalloc(test, sizeof(*pm), GFP_KERNEL);
struct dm_pp_display_configuration *pp =
kunit_kzalloc(test, sizeof(*pp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, pm);
KUNIT_ASSERT_NOT_NULL(test, pp);
pp->display_count = 2;
pp->disp_configs[0].pipe_idx = 0;
pp->disp_configs[0].pixel_clock = 148500;
pp->disp_configs[1].pipe_idx = 4;
pp->disp_configs[1].pixel_clock = 297000;
build_pm_display_cfg(pm, pp);
KUNIT_EXPECT_EQ(test, pm->displays[0].controller_id, 1);
KUNIT_EXPECT_EQ(test, pm->displays[0].pixel_clock, 148500);
KUNIT_EXPECT_EQ(test, pm->displays[1].controller_id, 5);
KUNIT_EXPECT_EQ(test, pm->displays[1].pixel_clock, 297000);
}
static void dm_test_build_wm_clock_ranges_dmif(struct kunit *test)
{
struct pp_smu_wm_range_sets *ranges =
kunit_kzalloc(test, sizeof(*ranges), GFP_KERNEL);
struct dm_pp_wm_sets_with_clock_ranges_soc15 *wm =
kunit_kzalloc(test, sizeof(*wm), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ranges);
KUNIT_ASSERT_NOT_NULL(test, wm);
ranges->num_reader_wm_sets = 2;
ranges->reader_wm_sets[0].wm_inst = 2;
ranges->reader_wm_sets[0].max_drain_clk_mhz = 600;
ranges->reader_wm_sets[0].min_drain_clk_mhz = 300;
ranges->reader_wm_sets[0].max_fill_clk_mhz = 800;
ranges->reader_wm_sets[0].min_fill_clk_mhz = 400;
ranges->reader_wm_sets[1].wm_inst = 5;
ranges->reader_wm_sets[1].max_drain_clk_mhz = 700;
ranges->reader_wm_sets[1].min_drain_clk_mhz = 350;
ranges->reader_wm_sets[1].max_fill_clk_mhz = 900;
ranges->reader_wm_sets[1].min_fill_clk_mhz = 450;
build_wm_clock_ranges_soc15(ranges, wm);
KUNIT_EXPECT_EQ(test, wm->num_wm_dmif_sets, 2U);
KUNIT_EXPECT_EQ(test, wm->num_wm_mcif_sets, 0U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[0].wm_set_id, WM_SET_C);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[0].wm_max_dcfclk_clk_in_khz, 600000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[0].wm_min_dcfclk_clk_in_khz, 300000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[0].wm_max_mem_clk_in_khz, 800000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[0].wm_min_mem_clk_in_khz, 400000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[1].wm_set_id, WM_SET_A);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[1].wm_max_dcfclk_clk_in_khz, 700000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[1].wm_min_dcfclk_clk_in_khz, 350000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[1].wm_max_mem_clk_in_khz, 900000U);
KUNIT_EXPECT_EQ(test, wm->wm_dmif_clocks_ranges[1].wm_min_mem_clk_in_khz, 450000U);
}
static void dm_test_build_wm_clock_ranges_mcif(struct kunit *test)
{
struct pp_smu_wm_range_sets *ranges =
kunit_kzalloc(test, sizeof(*ranges), GFP_KERNEL);
struct dm_pp_wm_sets_with_clock_ranges_soc15 *wm =
kunit_kzalloc(test, sizeof(*wm), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ranges);
KUNIT_ASSERT_NOT_NULL(test, wm);
ranges->num_writer_wm_sets = 2;
ranges->writer_wm_sets[0].wm_inst = 1;
ranges->writer_wm_sets[0].max_fill_clk_mhz = 1200;
ranges->writer_wm_sets[0].min_fill_clk_mhz = 600;
ranges->writer_wm_sets[0].max_drain_clk_mhz = 1000;
ranges->writer_wm_sets[0].min_drain_clk_mhz = 500;
ranges->writer_wm_sets[1].wm_inst = 5;
ranges->writer_wm_sets[1].max_fill_clk_mhz = 1400;
ranges->writer_wm_sets[1].min_fill_clk_mhz = 700;
ranges->writer_wm_sets[1].max_drain_clk_mhz = 1100;
ranges->writer_wm_sets[1].min_drain_clk_mhz = 550;
build_wm_clock_ranges_soc15(ranges, wm);
KUNIT_EXPECT_EQ(test, wm->num_wm_dmif_sets, 0U);
KUNIT_EXPECT_EQ(test, wm->num_wm_mcif_sets, 2U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[0].wm_set_id, WM_SET_B);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[0].wm_max_socclk_clk_in_khz, 1200000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[0].wm_min_socclk_clk_in_khz, 600000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[0].wm_max_mem_clk_in_khz, 1000000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[0].wm_min_mem_clk_in_khz, 500000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[1].wm_set_id, WM_SET_A);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[1].wm_max_socclk_clk_in_khz, 1400000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[1].wm_min_socclk_clk_in_khz, 700000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[1].wm_max_mem_clk_in_khz, 1100000U);
KUNIT_EXPECT_EQ(test, wm->wm_mcif_clocks_ranges[1].wm_min_mem_clk_in_khz, 550000U);
}
static void dm_test_cap_clock_levels_engine_caps(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
struct amd_pp_simple_clock_info validation = {
.engine_max_clock = 450000,
.memory_max_clock = 800000,
};
clks.num_levels = 3;
clks.clocks_in_khz[0] = 300000;
clks.clocks_in_khz[1] = 400000;
clks.clocks_in_khz[2] = 500000;
cap_clock_levels_to_validation(&clks, DM_PP_CLOCK_TYPE_ENGINE_CLK, &validation);
KUNIT_EXPECT_EQ(test, clks.num_levels, 2U);
}
static void dm_test_cap_clock_levels_engine_first_exceeds(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
struct amd_pp_simple_clock_info validation = {
.engine_max_clock = 100000,
.memory_max_clock = 800000,
};
clks.num_levels = 3;
clks.clocks_in_khz[0] = 300000;
clks.clocks_in_khz[1] = 400000;
clks.clocks_in_khz[2] = 500000;
cap_clock_levels_to_validation(&clks, DM_PP_CLOCK_TYPE_ENGINE_CLK, &validation);
KUNIT_EXPECT_EQ(test, clks.num_levels, 1U);
}
static void dm_test_cap_clock_levels_memory_caps(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
struct amd_pp_simple_clock_info validation = {
.engine_max_clock = 100000,
.memory_max_clock = 700000,
};
clks.num_levels = 2;
clks.clocks_in_khz[0] = 333000;
clks.clocks_in_khz[1] = 800000;
cap_clock_levels_to_validation(&clks, DM_PP_CLOCK_TYPE_MEMORY_CLK, &validation);
KUNIT_EXPECT_EQ(test, clks.num_levels, 1U);
}
static void dm_test_cap_clock_levels_within_limit(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
struct amd_pp_simple_clock_info validation = {
.engine_max_clock = 999000,
.memory_max_clock = 999000,
};
clks.num_levels = 3;
clks.clocks_in_khz[0] = 300000;
clks.clocks_in_khz[1] = 400000;
clks.clocks_in_khz[2] = 500000;
cap_clock_levels_to_validation(&clks, DM_PP_CLOCK_TYPE_ENGINE_CLK, &validation);
KUNIT_EXPECT_EQ(test, clks.num_levels, 3U);
}
static void dm_test_cap_clock_levels_other_type(struct kunit *test)
{
struct dm_pp_clock_levels clks = { 0 };
struct amd_pp_simple_clock_info validation = {
.engine_max_clock = 1,
.memory_max_clock = 1,
};
clks.num_levels = 3;
clks.clocks_in_khz[0] = 300000;
clks.clocks_in_khz[1] = 400000;
clks.clocks_in_khz[2] = 500000;
cap_clock_levels_to_validation(&clks, DM_PP_CLOCK_TYPE_DISPLAY_CLK, &validation);
KUNIT_EXPECT_EQ(test, clks.num_levels, 3U);
}
static void dm_test_nv_clock_id_dispclk(struct kunit *test)
{
enum amd_pp_clock_type clock_type = amd_pp_mem_clock;
KUNIT_EXPECT_TRUE(test, pp_smu_nv_clock_id_to_pp(PP_SMU_NV_DISPCLK, &clock_type));
KUNIT_EXPECT_EQ(test, clock_type, amd_pp_disp_clock);
}
static void dm_test_nv_clock_id_phyclk(struct kunit *test)
{
enum amd_pp_clock_type clock_type = amd_pp_mem_clock;
KUNIT_EXPECT_TRUE(test, pp_smu_nv_clock_id_to_pp(PP_SMU_NV_PHYCLK, &clock_type));
KUNIT_EXPECT_EQ(test, clock_type, amd_pp_phy_clock);
}
static void dm_test_nv_clock_id_pixelclk(struct kunit *test)
{
enum amd_pp_clock_type clock_type = amd_pp_mem_clock;
KUNIT_EXPECT_TRUE(test, pp_smu_nv_clock_id_to_pp(PP_SMU_NV_PIXELCLK, &clock_type));
KUNIT_EXPECT_EQ(test, clock_type, amd_pp_pixel_clock);
}
static void dm_test_nv_clock_id_invalid(struct kunit *test)
{
enum amd_pp_clock_type clock_type = amd_pp_dcef_clock;
KUNIT_EXPECT_FALSE(test, pp_smu_nv_clock_id_to_pp((enum pp_smu_nv_clock_id)0xff,
&clock_type));
KUNIT_EXPECT_EQ(test, clock_type, amd_pp_dcef_clock);
}
static void dm_test_apply_display_requirements_dpm_enabled(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_display_configuration cfg = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
adev->pm.dpm_enabled = true;
cfg.display_count = 1;
cfg.min_engine_clock_khz = 300000;
cfg.disp_configs[0].v_refresh = 60;
KUNIT_EXPECT_TRUE(test, dm_pp_apply_display_requirements(ctx, &cfg));
KUNIT_EXPECT_EQ(test, adev->pm.pm_display_cfg.min_core_set_clock, 30000);
KUNIT_EXPECT_EQ(test, adev->pm.pm_display_cfg.vrefresh, 60);
}
static void dm_test_get_clock_levels_by_type_dpm_error(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels dc_clks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->ret_val = -EINVAL;
KUNIT_EXPECT_TRUE(test, dm_pp_get_clock_levels_by_type(ctx,
DM_PP_CLOCK_TYPE_DISPLAY_CLK, &dc_clks));
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 6U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[0], 300000U);
}
static void dm_test_get_clock_levels_by_type_success(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels dc_clks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->get_clock_by_type_clocks.count = 3;
stub_dpm_ctx->get_clock_by_type_clocks.clock[0] = 300000;
stub_dpm_ctx->get_clock_by_type_clocks.clock[1] = 500000;
stub_dpm_ctx->get_clock_by_type_clocks.clock[2] = 700000;
stub_dpm_ctx->get_validation_clks.engine_max_clock = 60000;
stub_dpm_ctx->get_validation_clks.memory_max_clock = 80000;
KUNIT_EXPECT_TRUE(test, dm_pp_get_clock_levels_by_type(ctx,
DM_PP_CLOCK_TYPE_ENGINE_CLK, &dc_clks));
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 2U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[0], 300000U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[1], 500000U);
}
static void dm_test_get_clock_levels_by_type_validation_fallback(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels dc_clks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->get_clock_by_type_clocks.count = 3;
stub_dpm_ctx->get_clock_by_type_clocks.clock[0] = 300000;
stub_dpm_ctx->get_clock_by_type_clocks.clock[1] = 500000;
stub_dpm_ctx->get_clock_by_type_clocks.clock[2] = 800000;
stub_dpm_ctx->get_validation_clks_ret = -EINVAL;
KUNIT_EXPECT_TRUE(test, dm_pp_get_clock_levels_by_type(ctx,
DM_PP_CLOCK_TYPE_ENGINE_CLK, &dc_clks));
KUNIT_EXPECT_EQ(test, dc_clks.num_levels, 2U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[0], 300000U);
KUNIT_EXPECT_EQ(test, dc_clks.clocks_in_khz[1], 500000U);
}
static void dm_test_get_clock_levels_with_latency_success(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels_with_latency info = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->get_clock_by_type_with_latency_clks.num_levels = 1;
stub_dpm_ctx->get_clock_by_type_with_latency_clks.data[0].clocks_in_khz = 600000;
stub_dpm_ctx->get_clock_by_type_with_latency_clks.data[0].latency_in_us = 15;
KUNIT_EXPECT_TRUE(test, dm_pp_get_clock_levels_by_type_with_latency(ctx,
DM_PP_CLOCK_TYPE_ENGINE_CLK, &info));
KUNIT_EXPECT_EQ(test, info.num_levels, 1U);
KUNIT_EXPECT_EQ(test, info.data[0].clocks_in_khz, 600000U);
KUNIT_EXPECT_EQ(test, info.data[0].latency_in_us, 15U);
}
static void dm_test_get_clock_levels_with_latency_failure(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels_with_latency info = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->ret_val = -EINVAL;
KUNIT_EXPECT_FALSE(test, dm_pp_get_clock_levels_by_type_with_latency(ctx,
DM_PP_CLOCK_TYPE_ENGINE_CLK, &info));
}
static void dm_test_get_clock_levels_with_voltage_success(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels_with_voltage info = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->get_clock_by_type_with_voltage_clks.num_levels = 1;
stub_dpm_ctx->get_clock_by_type_with_voltage_clks.data[0].clocks_in_khz = 400000;
stub_dpm_ctx->get_clock_by_type_with_voltage_clks.data[0].voltage_in_mv = 900;
KUNIT_EXPECT_TRUE(test, dm_pp_get_clock_levels_by_type_with_voltage(ctx,
DM_PP_CLOCK_TYPE_MEMORY_CLK, &info));
KUNIT_EXPECT_EQ(test, info.num_levels, 1U);
KUNIT_EXPECT_EQ(test, info.data[0].clocks_in_khz, 400000U);
KUNIT_EXPECT_EQ(test, info.data[0].voltage_in_mv, 900U);
}
static void dm_test_get_clock_levels_with_voltage_failure(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_levels_with_voltage info = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->ret_val = -EINVAL;
KUNIT_EXPECT_FALSE(test, dm_pp_get_clock_levels_by_type_with_voltage(ctx,
DM_PP_CLOCK_TYPE_MEMORY_CLK, &info));
}
static void dm_test_notify_wm_clock_changes_polaris(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_wm_sets_with_clock_ranges wm = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
adev->asic_type = CHIP_POLARIS10;
stub_dpm_ctx->set_watermarks_ret = 0;
KUNIT_EXPECT_TRUE(test, dm_pp_notify_wm_clock_changes(ctx, &wm));
}
static void dm_test_notify_wm_clock_changes_non_polaris(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_wm_sets_with_clock_ranges wm = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
adev->asic_type = CHIP_NAVI10;
KUNIT_EXPECT_FALSE(test, dm_pp_notify_wm_clock_changes(ctx, &wm));
}
static void dm_test_apply_clock_for_voltage_success(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_for_voltage_req req = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->display_clock_voltage_ret = 0;
req.clk_type = DM_PP_CLOCK_TYPE_ENGINE_CLK;
req.clocks_in_khz = 500000;
KUNIT_EXPECT_TRUE(test, dm_pp_apply_clock_for_voltage_request(ctx, &req));
}
static void dm_test_apply_clock_for_voltage_eopnotsupp(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_for_voltage_req req = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->display_clock_voltage_ret = -EOPNOTSUPP;
req.clk_type = DM_PP_CLOCK_TYPE_ENGINE_CLK;
req.clocks_in_khz = 500000;
KUNIT_EXPECT_TRUE(test, dm_pp_apply_clock_for_voltage_request(ctx, &req));
}
static void dm_test_apply_clock_for_voltage_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct dm_pp_clock_for_voltage_req req = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
stub_dpm_ctx->display_clock_voltage_ret = -EIO;
req.clk_type = DM_PP_CLOCK_TYPE_ENGINE_CLK;
req.clocks_in_khz = 500000;
KUNIT_EXPECT_FALSE(test, dm_pp_apply_clock_for_voltage_request(ctx, &req));
}
static void dm_test_nv_set_display_count_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_active_display_count_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_display_count(&pp_smu, 2),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_display_count_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_active_display_count_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_display_count(&pp_smu, 2),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_set_display_count_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_active_display_count_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_display_count(&pp_smu, 2),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_set_voltage_by_freq_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_voltage_by_freq(&pp_smu, PP_SMU_NV_DISPCLK, 600),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_voltage_by_freq_invalid_id(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_set_voltage_by_freq(&pp_smu, (enum pp_smu_nv_clock_id)0xff, 600),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_pstate_handshake_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_disable_memory_clock_switch_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_pstate_handshake_support(&pp_smu, true),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_pstate_handshake_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_disable_memory_clock_switch_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_pstate_handshake_support(&pp_smu, true),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_rn_get_dpm_clock_table_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct dpm_clocks clock_table = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_dpm_clock_table_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_rn_get_dpm_clock_table(&pp_smu, &clock_table),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_rn_get_dpm_clock_table_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct dpm_clocks clock_table = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_dpm_clock_table_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test, (int)pp_rn_get_dpm_clock_table(&pp_smu, &clock_table),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_rn_get_dpm_clock_table_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct dpm_clocks clock_table = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_dpm_clock_table_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_rn_get_dpm_clock_table(&pp_smu, &clock_table),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_rv_set_wm_ranges(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct pp_smu_wm_range_sets ranges = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
ranges.num_reader_wm_sets = 1;
ranges.reader_wm_sets[0].wm_inst = 0;
ranges.reader_wm_sets[0].max_drain_clk_mhz = 600;
ranges.reader_wm_sets[0].min_drain_clk_mhz = 300;
pp_rv_set_wm_ranges(&pp_smu, &ranges);
KUNIT_SUCCEED(test);
}
static void dm_test_rv_set_pme_wa_enable(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
pp_rv_set_pme_wa_enable(&pp_smu);
KUNIT_SUCCEED(test);
}
static void dm_test_rv_set_active_display_count(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
pp_rv_set_active_display_count(&pp_smu, 2);
KUNIT_SUCCEED(test);
}
static void dm_test_rv_set_min_deep_sleep_dcfclk(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
pp_rv_set_min_deep_sleep_dcfclk(&pp_smu, 300);
KUNIT_SUCCEED(test);
}
static void dm_test_rv_set_hard_min_dcefclk_by_freq(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
pp_rv_set_hard_min_dcefclk_by_freq(&pp_smu, 600);
KUNIT_SUCCEED(test);
}
static void dm_test_rv_set_hard_min_fclk_by_freq(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
pp_rv_set_hard_min_fclk_by_freq(&pp_smu, 800);
KUNIT_SUCCEED(test);
}
static void dm_test_nv_set_wm_ranges(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct pp_smu_wm_range_sets ranges = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
ranges.num_reader_wm_sets = 1;
ranges.reader_wm_sets[0].wm_inst = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_wm_ranges(&pp_smu, &ranges),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_min_deep_sleep_dcfclk_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_min_deep_sleep_dcefclk_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_min_deep_sleep_dcfclk(&pp_smu, 300),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_min_deep_sleep_dcfclk_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_min_deep_sleep_dcefclk_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_min_deep_sleep_dcfclk(&pp_smu, 300),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_set_min_deep_sleep_dcfclk_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->set_min_deep_sleep_dcefclk_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_min_deep_sleep_dcfclk(&pp_smu, 300),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_set_hard_min_dcefclk_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_dcefclk_by_freq(&pp_smu, 600),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_hard_min_dcefclk_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_dcefclk_by_freq(&pp_smu, 600),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_set_hard_min_dcefclk_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_dcefclk_by_freq(&pp_smu, 600),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_set_hard_min_uclk_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = 0;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_uclk_by_freq(&pp_smu, 800),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_set_hard_min_uclk_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_uclk_by_freq(&pp_smu, 800),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_set_hard_min_uclk_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->display_clock_voltage_ret = -EIO;
KUNIT_EXPECT_EQ(test, (int)pp_nv_set_hard_min_uclk_by_freq(&pp_smu, 800),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_get_max_sustainable_clocks_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct pp_smu_nv_clock_table max_clocks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_max_sustainable_ret = 0;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_maximum_sustainable_clocks(&pp_smu, &max_clocks),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_get_max_sustainable_clocks_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct pp_smu_nv_clock_table max_clocks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_max_sustainable_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_maximum_sustainable_clocks(&pp_smu, &max_clocks),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_get_max_sustainable_clocks_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
struct pp_smu_nv_clock_table max_clocks = {};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_max_sustainable_ret = -EIO;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_maximum_sustainable_clocks(&pp_smu, &max_clocks),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_nv_get_uclk_dpm_states_ok(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
unsigned int clock_values[4] = {};
unsigned int num_states = 0;
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_uclk_dpm_ret = 0;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_uclk_dpm_states(&pp_smu, clock_values, &num_states),
(int)PP_SMU_RESULT_OK);
}
static void dm_test_nv_get_uclk_dpm_states_unsupported(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
unsigned int clock_values[4] = {};
unsigned int num_states = 0;
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_uclk_dpm_ret = -EOPNOTSUPP;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_uclk_dpm_states(&pp_smu, clock_values, &num_states),
(int)PP_SMU_RESULT_UNSUPPORTED);
}
static void dm_test_nv_get_uclk_dpm_states_fail(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct dc_context *ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
struct pp_smu pp_smu = {};
unsigned int clock_values[4] = {};
unsigned int num_states = 0;
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ctx);
setup_stub_dpm(test, adev);
ctx->driver_context = adev;
pp_smu.dm = ctx;
stub_dpm_ctx->get_uclk_dpm_ret = -EIO;
KUNIT_EXPECT_EQ(test,
(int)pp_nv_get_uclk_dpm_states(&pp_smu, clock_values, &num_states),
(int)PP_SMU_RESULT_FAIL);
}
static void dm_test_smu_write_watermarks_table_default(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
KUNIT_EXPECT_EQ(test, amdgpu_dm_smu_write_watermarks_table(adev), 0);
}
static struct kunit_case dm_pp_smu_test_cases[] = {
KUNIT_CASE(dm_test_default_clock_levels_display),
KUNIT_CASE(dm_test_default_clock_levels_engine),
KUNIT_CASE(dm_test_default_clock_levels_memory),
KUNIT_CASE(dm_test_default_clock_levels_unknown),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_display),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_engine),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_memory),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_dcefclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_dcfclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_pixelclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_fclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_phyclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_dppclk),
KUNIT_CASE(dm_test_dc_to_pp_clock_type_invalid),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_within_limit),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_caps_at_max),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_latency_within_limit),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_latency_caps_at_max),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_voltage_within_limit),
KUNIT_CASE(dm_test_pp_to_dc_clock_levels_voltage_caps_at_max),
KUNIT_CASE(dm_test_get_funcs_rv),
KUNIT_CASE(dm_test_get_funcs_rv_101),
KUNIT_CASE(dm_test_get_funcs_nv),
KUNIT_CASE(dm_test_get_funcs_rn),
KUNIT_CASE(dm_test_get_funcs_unsupported),
KUNIT_CASE(dm_test_apply_display_requirements_dpm_disabled),
KUNIT_CASE(dm_test_apply_clock_for_voltage_invalid_type),
KUNIT_CASE(dm_test_build_pm_display_cfg_scalar_fields),
KUNIT_CASE(dm_test_build_pm_display_cfg_per_display),
KUNIT_CASE(dm_test_build_wm_clock_ranges_dmif),
KUNIT_CASE(dm_test_build_wm_clock_ranges_mcif),
KUNIT_CASE(dm_test_cap_clock_levels_engine_caps),
KUNIT_CASE(dm_test_cap_clock_levels_engine_first_exceeds),
KUNIT_CASE(dm_test_cap_clock_levels_memory_caps),
KUNIT_CASE(dm_test_cap_clock_levels_within_limit),
KUNIT_CASE(dm_test_cap_clock_levels_other_type),
KUNIT_CASE(dm_test_nv_clock_id_dispclk),
KUNIT_CASE(dm_test_nv_clock_id_phyclk),
KUNIT_CASE(dm_test_nv_clock_id_pixelclk),
KUNIT_CASE(dm_test_nv_clock_id_invalid),
KUNIT_CASE(dm_test_apply_display_requirements_dpm_enabled),
KUNIT_CASE(dm_test_get_clock_levels_by_type_dpm_error),
KUNIT_CASE(dm_test_get_clock_levels_by_type_success),
KUNIT_CASE(dm_test_get_clock_levels_by_type_validation_fallback),
KUNIT_CASE(dm_test_get_clock_levels_with_latency_success),
KUNIT_CASE(dm_test_get_clock_levels_with_latency_failure),
KUNIT_CASE(dm_test_get_clock_levels_with_voltage_success),
KUNIT_CASE(dm_test_get_clock_levels_with_voltage_failure),
KUNIT_CASE(dm_test_notify_wm_clock_changes_polaris),
KUNIT_CASE(dm_test_notify_wm_clock_changes_non_polaris),
KUNIT_CASE(dm_test_apply_clock_for_voltage_success),
KUNIT_CASE(dm_test_apply_clock_for_voltage_eopnotsupp),
KUNIT_CASE(dm_test_apply_clock_for_voltage_fail),
KUNIT_CASE(dm_test_nv_set_display_count_ok),
KUNIT_CASE(dm_test_nv_set_display_count_unsupported),
KUNIT_CASE(dm_test_nv_set_display_count_fail),
KUNIT_CASE(dm_test_nv_set_voltage_by_freq_ok),
KUNIT_CASE(dm_test_nv_set_voltage_by_freq_invalid_id),
KUNIT_CASE(dm_test_nv_pstate_handshake_ok),
KUNIT_CASE(dm_test_nv_pstate_handshake_fail),
KUNIT_CASE(dm_test_rn_get_dpm_clock_table_ok),
KUNIT_CASE(dm_test_rn_get_dpm_clock_table_unsupported),
KUNIT_CASE(dm_test_rn_get_dpm_clock_table_fail),
KUNIT_CASE(dm_test_rv_set_wm_ranges),
KUNIT_CASE(dm_test_rv_set_pme_wa_enable),
KUNIT_CASE(dm_test_rv_set_active_display_count),
KUNIT_CASE(dm_test_rv_set_min_deep_sleep_dcfclk),
KUNIT_CASE(dm_test_rv_set_hard_min_dcefclk_by_freq),
KUNIT_CASE(dm_test_rv_set_hard_min_fclk_by_freq),
KUNIT_CASE(dm_test_nv_set_wm_ranges),
KUNIT_CASE(dm_test_nv_set_min_deep_sleep_dcfclk_ok),
KUNIT_CASE(dm_test_nv_set_min_deep_sleep_dcfclk_unsupported),
KUNIT_CASE(dm_test_nv_set_min_deep_sleep_dcfclk_fail),
KUNIT_CASE(dm_test_nv_set_hard_min_dcefclk_ok),
KUNIT_CASE(dm_test_nv_set_hard_min_dcefclk_unsupported),
KUNIT_CASE(dm_test_nv_set_hard_min_dcefclk_fail),
KUNIT_CASE(dm_test_nv_set_hard_min_uclk_ok),
KUNIT_CASE(dm_test_nv_set_hard_min_uclk_unsupported),
KUNIT_CASE(dm_test_nv_set_hard_min_uclk_fail),
KUNIT_CASE(dm_test_nv_get_max_sustainable_clocks_ok),
KUNIT_CASE(dm_test_nv_get_max_sustainable_clocks_unsupported),
KUNIT_CASE(dm_test_nv_get_max_sustainable_clocks_fail),
KUNIT_CASE(dm_test_nv_get_uclk_dpm_states_ok),
KUNIT_CASE(dm_test_nv_get_uclk_dpm_states_unsupported),
KUNIT_CASE(dm_test_nv_get_uclk_dpm_states_fail),
KUNIT_CASE(dm_test_smu_write_watermarks_table_default),
{}
};
static struct kunit_suite dm_pp_smu_test_suite = {
.name = "amdgpu_dm_pp_smu",
.test_cases = dm_pp_smu_test_cases,
};
kunit_test_suite(dm_pp_smu_test_suite);
MODULE_LICENSE("Dual MIT/GPL");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_pp_smu"