/usr/src/sys/dev/pci/drm/radeon/kv

Bug Summary

File:	dev/pci/drm/radeon/kv_dpm.c
Warning:	line 1396, column 13 The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'int'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name kv_dpm.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/drm/radeon/kv_dpm.c
1/*
* Copyright 2013 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
*/

24#include <linux/pci.h>
25#include <linux/seq_file.h>

27#include "cikd.h"
28#include "kv_dpm.h"
29#include "r600_dpm.h"
30#include "radeon.h"
31#include "radeon_asic.h"

33#define KV_MAX_DEEPSLEEP_DIVIDER_ID5     5
34#define KV_MINIMUM_ENGINE_CLOCK800         800
35#define SMC_RAM_END0x40000                     0x40000

37static int kv_enable_nb_dpm(struct radeon_device *rdev,
	    bool_Bool enable);
39static void kv_init_graphics_levels(struct radeon_device *rdev);
40static int kv_calculate_ds_divider(struct radeon_device *rdev);
41static int kv_calculate_nbps_level_settings(struct radeon_device *rdev);
42static int kv_calculate_dpm_settings(struct radeon_device *rdev);
43static void kv_enable_new_levels(struct radeon_device *rdev);
44static void kv_program_nbps_index_settings(struct radeon_device *rdev,
			   struct radeon_ps *new_rps);
46static int kv_set_enabled_level(struct radeon_device *rdev, u32 level);
47static int kv_set_enabled_levels(struct radeon_device *rdev);
48static int kv_force_dpm_highest(struct radeon_device *rdev);
49static int kv_force_dpm_lowest(struct radeon_device *rdev);
50static void kv_apply_state_adjust_rules(struct radeon_device *rdev,
			struct radeon_ps *new_rps,
			struct radeon_ps *old_rps);
53static int kv_set_thermal_temperature_range(struct radeon_device *rdev,
			    int min_temp, int max_temp);
55static int kv_init_fps_limits(struct radeon_device *rdev);

57void kv_dpm_powergate_uvd(struct radeon_device *rdev, bool_Bool gate);
58static void kv_dpm_powergate_vce(struct radeon_device *rdev, bool_Bool gate);
59static void kv_dpm_powergate_samu(struct radeon_device *rdev, bool_Bool gate);
60static void kv_dpm_powergate_acp(struct radeon_device *rdev, bool_Bool gate);

62extern void cik_enter_rlc_safe_mode(struct radeon_device *rdev);
63extern void cik_exit_rlc_safe_mode(struct radeon_device *rdev);
64extern void cik_update_cg(struct radeon_device *rdev,
	  u32 block, bool_Bool enable);

67static const struct kv_pt_config_reg didt_config_kv[] =
68{
{ 0x10, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x10, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x10, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x10, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x11, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x11, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x11, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x11, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x12, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x12, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x12, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x12, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x2, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
{ 0x2, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
{ 0x2, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
{ 0x1, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x1, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x0, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x30, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x30, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x30, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x30, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x31, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x31, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x31, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x31, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x32, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x32, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x32, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x32, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x22, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
{ 0x22, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
{ 0x22, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
{ 0x21, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x21, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x20, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x50, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x50, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x50, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x50, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x51, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x51, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x51, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x51, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x52, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x52, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x52, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x52, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x42, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
{ 0x42, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
{ 0x42, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
{ 0x41, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x41, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x40, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x70, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x70, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x70, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x70, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x71, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x71, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x71, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x71, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x72, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x72, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x72, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x72, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0x62, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
{ 0x62, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
{ 0x62, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
{ 0x61, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x61, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
{ 0x60, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
{ 0xFFFFFFFF }
142};

144static struct kv_ps *kv_get_ps(struct radeon_ps *rps)
145{
struct kv_ps *ps = rps->ps_priv;

return ps;
149}

151static struct kv_power_info *kv_get_pi(struct radeon_device *rdev)
152{
struct kv_power_info *pi = rdev->pm.dpm.priv;

return pi;
156}

158static int kv_program_pt_config_registers(struct radeon_device *rdev,
			  const struct kv_pt_config_reg *cac_config_regs)
160{
const struct kv_pt_config_reg *config_regs = cac_config_regs;
u32 data;
u32 cache = 0;

if (config_regs == NULL((void *)0))
return -EINVAL22;

while (config_regs->offset != 0xFFFFFFFF) {
if (config_regs->type == KV_CONFIGREG_CACHE) {
	cache |= ((config_regs->value << config_regs->shift) & config_regs->mask);
} else {
	switch (config_regs->type) {
	case KV_CONFIGREG_SMC_IND:
		data = RREG32_SMC(config_regs->offset)tn_smc_rreg(rdev, (config_regs->offset));
		break;
	case KV_CONFIGREG_DIDT_IND:
		data = RREG32_DIDT(config_regs->offset)cik_didt_rreg(rdev, (config_regs->offset));
		break;
	default:
		data = RREG32(config_regs->offset << 2)r100_mm_rreg(rdev, (config_regs->offset << 2), 0);
		break;
	}

	data &= ~config_regs->mask;
	data |= ((config_regs->value << config_regs->shift) & config_regs->mask);
	data |= cache;
	cache = 0;

	switch (config_regs->type) {
	case KV_CONFIGREG_SMC_IND:
		WREG32_SMC(config_regs->offset, data)tn_smc_wreg(rdev, (config_regs->offset), (data));
		break;
	case KV_CONFIGREG_DIDT_IND:
		WREG32_DIDT(config_regs->offset, data)cik_didt_wreg(rdev, (config_regs->offset), (data));
		break;
	default:
		WREG32(config_regs->offset << 2, data)r100_mm_wreg(rdev, (config_regs->offset << 2), (data
), 0);
		break;
	}
}
config_regs++;
}

return 0;
205}

207static void kv_do_enable_didt(struct radeon_device *rdev, bool_Bool enable)
208{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 data;

if (pi->caps_sq_ramping) {
data = RREG32_DIDT(DIDT_SQ_CTRL0)cik_didt_rreg(rdev, (0x0));
if (enable)
	data |= DIDT_CTRL_EN(1 << 0);
else
	data &= ~DIDT_CTRL_EN(1 << 0);
WREG32_DIDT(DIDT_SQ_CTRL0, data)cik_didt_wreg(rdev, (0x0), (data));
}

if (pi->caps_db_ramping) {
data = RREG32_DIDT(DIDT_DB_CTRL0)cik_didt_rreg(rdev, (0x20));
if (enable)
	data |= DIDT_CTRL_EN(1 << 0);
else
	data &= ~DIDT_CTRL_EN(1 << 0);
WREG32_DIDT(DIDT_DB_CTRL0, data)cik_didt_wreg(rdev, (0x20), (data));
}

if (pi->caps_td_ramping) {
data = RREG32_DIDT(DIDT_TD_CTRL0)cik_didt_rreg(rdev, (0x40));
if (enable)
	data |= DIDT_CTRL_EN(1 << 0);
else
	data &= ~DIDT_CTRL_EN(1 << 0);
WREG32_DIDT(DIDT_TD_CTRL0, data)cik_didt_wreg(rdev, (0x40), (data));
}

if (pi->caps_tcp_ramping) {
data = RREG32_DIDT(DIDT_TCP_CTRL0)cik_didt_rreg(rdev, (0x60));
if (enable)
	data |= DIDT_CTRL_EN(1 << 0);
else
	data &= ~DIDT_CTRL_EN(1 << 0);
WREG32_DIDT(DIDT_TCP_CTRL0, data)cik_didt_wreg(rdev, (0x60), (data));
}
247}

249static int kv_enable_didt(struct radeon_device *rdev, bool_Bool enable)
250{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

if (pi->caps_sq_ramping ||
   pi->caps_db_ramping ||
   pi->caps_td_ramping ||
   pi->caps_tcp_ramping) {
cik_enter_rlc_safe_mode(rdev);

if (enable) {
	ret = kv_program_pt_config_registers(rdev, didt_config_kv);
	if (ret) {
		cik_exit_rlc_safe_mode(rdev);
		return ret;
	}
}

kv_do_enable_didt(rdev, enable);

cik_exit_rlc_safe_mode(rdev);
}

return 0;
274}

276static int kv_enable_smc_cac(struct radeon_device *rdev, bool_Bool enable)
277{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret = 0;

if (pi->caps_cac) {
if (enable) {
	ret = kv_notify_message_to_smu(rdev, PPSMC_MSG_EnableCac((uint8_t)0x53));
	if (ret)
		pi->cac_enabled = false0;
	else
		pi->cac_enabled = true1;
} else if (pi->cac_enabled) {
	kv_notify_message_to_smu(rdev, PPSMC_MSG_DisableCac((uint8_t)0x54));
	pi->cac_enabled = false0;
}
}

return ret;
295}

297static int kv_process_firmware_header(struct radeon_device *rdev)
298{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 tmp;
int ret;

ret = kv_read_smc_sram_dword(rdev, SMU7_FIRMWARE_HEADER_LOCATION0x20000 +
		     offsetof(SMU7_Firmware_Header, DpmTable)__builtin_offsetof(SMU7_Firmware_Header, DpmTable),
		     &tmp, pi->sram_end);

if (ret == 0)
pi->dpm_table_start = tmp;

ret = kv_read_smc_sram_dword(rdev, SMU7_FIRMWARE_HEADER_LOCATION0x20000 +
		     offsetof(SMU7_Firmware_Header, SoftRegisters)__builtin_offsetof(SMU7_Firmware_Header, SoftRegisters),
		     &tmp, pi->sram_end);

if (ret == 0)
pi->soft_regs_start = tmp;

return ret;
318}

320static int kv_enable_dpm_voltage_scaling(struct radeon_device *rdev)
321{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

pi->graphics_voltage_change_enable = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsVoltageChangeEnable)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsVoltageChangeEnable
),
		   &pi->graphics_voltage_change_enable,
		   sizeof(u8), pi->sram_end);

return ret;
334}

336static int kv_set_dpm_interval(struct radeon_device *rdev)
337{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

pi->graphics_interval = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsInterval)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsInterval),
		   &pi->graphics_interval,
		   sizeof(u8), pi->sram_end);

return ret;
350}

352static int kv_set_dpm_boot_state(struct radeon_device *rdev)
353{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsBootLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsBootLevel),
		   &pi->graphics_boot_level,
		   sizeof(u8), pi->sram_end);

return ret;
364}

366static void kv_program_vc(struct radeon_device *rdev)
367{
WREG32_SMC(CG_FTV_0, 0x3FFFC100)tn_smc_wreg(rdev, (0xC02001A8), (0x3FFFC100));
369}

371static void kv_clear_vc(struct radeon_device *rdev)
372{
WREG32_SMC(CG_FTV_0, 0)tn_smc_wreg(rdev, (0xC02001A8), (0));
374}

376static int kv_set_divider_value(struct radeon_device *rdev,
		u32 index, u32 sclk)
378{
struct kv_power_info *pi = kv_get_pi(rdev);
struct atom_clock_dividers dividers;
int ret;

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
			     sclk, false0, &dividers);
if (ret)
return ret;

pi->graphics_level[index].SclkDid = (u8)dividers.post_div;
pi->graphics_level[index].SclkFrequency = cpu_to_be32(sclk)(__uint32_t)(__builtin_constant_p(sclk) ? (__uint32_t)(((__uint32_t
)(sclk) & 0xff) << 24 | ((__uint32_t)(sclk) & 0xff00
) << 8 | ((__uint32_t)(sclk) & 0xff0000) >> 8
 | ((__uint32_t)(sclk) & 0xff000000) >> 24) : __swap32md
(sclk));

return 0;
392}

394static u32 kv_convert_vid2_to_vid7(struct radeon_device *rdev,
		   struct sumo_vid_mapping_table *vid_mapping_table,
		   u32 vid_2bit)
397{
struct radeon_clock_voltage_dependency_table *vddc_sclk_table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
u32 i;

if (vddc_sclk_table && vddc_sclk_table->count) {
if (vid_2bit < vddc_sclk_table->count)
	return vddc_sclk_table->entries[vid_2bit].v;
else
	return vddc_sclk_table->entries[vddc_sclk_table->count - 1].v;
} else {
for (i = 0; i < vid_mapping_table->num_entries; i++) {
	if (vid_mapping_table->entries[i].vid_2bit == vid_2bit)
		return vid_mapping_table->entries[i].vid_7bit;
}
return vid_mapping_table->entries[vid_mapping_table->num_entries - 1].vid_7bit;
}
414}

416static u32 kv_convert_vid7_to_vid2(struct radeon_device *rdev,
		   struct sumo_vid_mapping_table *vid_mapping_table,
		   u32 vid_7bit)
419{
struct radeon_clock_voltage_dependency_table *vddc_sclk_table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
u32 i;

if (vddc_sclk_table && vddc_sclk_table->count) {
for (i = 0; i < vddc_sclk_table->count; i++) {
	if (vddc_sclk_table->entries[i].v == vid_7bit)
		return i;
}
return vddc_sclk_table->count - 1;
} else {
for (i = 0; i < vid_mapping_table->num_entries; i++) {
	if (vid_mapping_table->entries[i].vid_7bit == vid_7bit)
		return vid_mapping_table->entries[i].vid_2bit;
}

return vid_mapping_table->entries[vid_mapping_table->num_entries - 1].vid_2bit;
}
438}

440static u16 kv_convert_8bit_index_to_voltage(struct radeon_device *rdev,
			    u16 voltage)
442{
return 6200 - (voltage * 25);
444}

446static u16 kv_convert_2bit_index_to_voltage(struct radeon_device *rdev,
			    u32 vid_2bit)
448{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 vid_8bit = kv_convert_vid2_to_vid7(rdev,
			       &pi->sys_info.vid_mapping_table,
			       vid_2bit);

return kv_convert_8bit_index_to_voltage(rdev, (u16)vid_8bit);
455}


458static int kv_set_vid(struct radeon_device *rdev, u32 index, u32 vid)
459{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->graphics_level[index].VoltageDownH = (u8)pi->voltage_drop_t;
pi->graphics_level[index].MinVddNb =
cpu_to_be32(kv_convert_2bit_index_to_voltage(rdev, vid))(__uint32_t)(__builtin_constant_p(kv_convert_2bit_index_to_voltage
(rdev, vid)) ? (__uint32_t)(((__uint32_t)(kv_convert_2bit_index_to_voltage
(rdev, vid)) & 0xff) << 24 | ((__uint32_t)(kv_convert_2bit_index_to_voltage
(rdev, vid)) & 0xff00) << 8 | ((__uint32_t)(kv_convert_2bit_index_to_voltage
(rdev, vid)) & 0xff0000) >> 8 | ((__uint32_t)(kv_convert_2bit_index_to_voltage
(rdev, vid)) & 0xff000000) >> 24) : __swap32md(kv_convert_2bit_index_to_voltage
(rdev, vid)));

return 0;
467}

469static int kv_set_at(struct radeon_device *rdev, u32 index, u32 at)
470{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->graphics_level[index].AT = cpu_to_be16((u16)at)(__uint16_t)(__builtin_constant_p((u16)at) ? (__uint16_t)(((__uint16_t
)((u16)at) & 0xffU) << 8 | ((__uint16_t)((u16)at) &
 0xff00U) >> 8) : __swap16md((u16)at));

return 0;
476}

478static void kv_dpm_power_level_enable(struct radeon_device *rdev,
		      u32 index, bool_Bool enable)
480{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->graphics_level[index].EnabledForActivity = enable ? 1 : 0;
484}

486static void kv_start_dpm(struct radeon_device *rdev)
487{
u32 tmp = RREG32_SMC(GENERAL_PWRMGT)tn_smc_rreg(rdev, (0xC0200000));

tmp |= GLOBAL_PWRMGT_EN(1 << 0);
WREG32_SMC(GENERAL_PWRMGT, tmp)tn_smc_wreg(rdev, (0xC0200000), (tmp));

kv_smc_dpm_enable(rdev, true1);
494}

496static void kv_stop_dpm(struct radeon_device *rdev)
497{
kv_smc_dpm_enable(rdev, false0);
499}

501static void kv_start_am(struct radeon_device *rdev)
502{
u32 sclk_pwrmgt_cntl = RREG32_SMC(SCLK_PWRMGT_CNTL)tn_smc_rreg(rdev, (0xC0200008));

sclk_pwrmgt_cntl &= ~(RESET_SCLK_CNT(1 << 5) | RESET_BUSY_CNT(1 << 4));
sclk_pwrmgt_cntl |= DYNAMIC_PM_EN(1 << 21);

WREG32_SMC(SCLK_PWRMGT_CNTL, sclk_pwrmgt_cntl)tn_smc_wreg(rdev, (0xC0200008), (sclk_pwrmgt_cntl));
509}

511static void kv_reset_am(struct radeon_device *rdev)
512{
u32 sclk_pwrmgt_cntl = RREG32_SMC(SCLK_PWRMGT_CNTL)tn_smc_rreg(rdev, (0xC0200008));

sclk_pwrmgt_cntl |= (RESET_SCLK_CNT(1 << 5) | RESET_BUSY_CNT(1 << 4));

WREG32_SMC(SCLK_PWRMGT_CNTL, sclk_pwrmgt_cntl)tn_smc_wreg(rdev, (0xC0200008), (sclk_pwrmgt_cntl));
518}

520static int kv_freeze_sclk_dpm(struct radeon_device *rdev, bool_Bool freeze)
521{
return kv_notify_message_to_smu(rdev, freeze ?
			PPSMC_MSG_SCLKDPM_FreezeLevel((uint16_t) 0x189) : PPSMC_MSG_SCLKDPM_UnfreezeLevel((uint16_t) 0x18A));
524}

526static int kv_force_lowest_valid(struct radeon_device *rdev)
527{
return kv_force_dpm_lowest(rdev);
529}

531static int kv_unforce_levels(struct radeon_device *rdev)
532{
if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
return kv_notify_message_to_smu(rdev, PPSMC_MSG_NoForcedLevel((uint8_t)0x41));
else
return kv_set_enabled_levels(rdev);
537}

539static int kv_update_sclk_t(struct radeon_device *rdev)
540{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 low_sclk_interrupt_t = 0;
int ret = 0;

if (pi->caps_sclk_throttle_low_notification) {
low_sclk_interrupt_t = cpu_to_be32(pi->low_sclk_interrupt_t)(__uint32_t)(__builtin_constant_p(pi->low_sclk_interrupt_t
) ? (__uint32_t)(((__uint32_t)(pi->low_sclk_interrupt_t) &
 0xff) << 24 | ((__uint32_t)(pi->low_sclk_interrupt_t
) & 0xff00) << 8 | ((__uint32_t)(pi->low_sclk_interrupt_t
) & 0xff0000) >> 8 | ((__uint32_t)(pi->low_sclk_interrupt_t
) & 0xff000000) >> 24) : __swap32md(pi->low_sclk_interrupt_t
));

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, LowSclkInterruptT)__builtin_offsetof(SMU7_Fusion_DpmTable, LowSclkInterruptT),
			   (u8 *)&low_sclk_interrupt_t,
			   sizeof(u32), pi->sram_end);
}
return ret;
555}

557static int kv_program_bootup_state(struct radeon_device *rdev)
558{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;

if (table && table->count) {
for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
	if (table->entries[i].clk == pi->boot_pl.sclk)
		break;
}

pi->graphics_boot_level = (u8)i;
kv_dpm_power_level_enable(rdev, i, true1);
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;

if (table->num_max_dpm_entries == 0)
	return -EINVAL22;

for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
	if (table->entries[i].sclk_frequency == pi->boot_pl.sclk)
		break;
}

pi->graphics_boot_level = (u8)i;
kv_dpm_power_level_enable(rdev, i, true1);
}
return 0;
588}

590static int kv_enable_auto_thermal_throttling(struct radeon_device *rdev)
591{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

pi->graphics_therm_throttle_enable = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsThermThrottleEnable)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsThermThrottleEnable
),
		   &pi->graphics_therm_throttle_enable,
		   sizeof(u8), pi->sram_end);

return ret;
604}

606static int kv_upload_dpm_settings(struct radeon_device *rdev)
607{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsLevel),
		   (u8 *)&pi->graphics_level,
		   sizeof(SMU7_Fusion_GraphicsLevel) * SMU7_MAX_LEVELS_GRAPHICS8,
		   pi->sram_end);

if (ret)
return ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, GraphicsDpmLevelCount)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsDpmLevelCount
),
		   &pi->graphics_dpm_level_count,
		   sizeof(u8), pi->sram_end);

return ret;
628}

630static u32 kv_get_clock_difference(u32 a, u32 b)
631{
return (a >= b) ? a - b : b - a;
633}

635static u32 kv_get_clk_bypass(struct radeon_device *rdev, u32 clk)
636{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 value;

if (pi->caps_enable_dfs_bypass) {
if (kv_get_clock_difference(clk, 40000) < 200)
	value = 3;
else if (kv_get_clock_difference(clk, 30000) < 200)
	value = 2;
else if (kv_get_clock_difference(clk, 20000) < 200)
	value = 7;
else if (kv_get_clock_difference(clk, 15000) < 200)
	value = 6;
else if (kv_get_clock_difference(clk, 10000) < 200)
	value = 8;
else
	value = 0;
} else {
value = 0;
}

return value;
658}

660static int kv_populate_uvd_table(struct radeon_device *rdev)
661{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_uvd_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
struct atom_clock_dividers dividers;
int ret;
u32 i;

if (table == NULL((void *)0) || table->count == 0)
return 0;

pi->uvd_level_count = 0;
for (i = 0; i < table->count; i++) {
if (pi->high_voltage_t &&
    (pi->high_voltage_t < table->entries[i].v))
	break;

pi->uvd_level[i].VclkFrequency = cpu_to_be32(table->entries[i].vclk)(__uint32_t)(__builtin_constant_p(table->entries[i].vclk) ?
 (__uint32_t)(((__uint32_t)(table->entries[i].vclk) & 0xff
) << 24 | ((__uint32_t)(table->entries[i].vclk) &
 0xff00) << 8 | ((__uint32_t)(table->entries[i].vclk
) & 0xff0000) >> 8 | ((__uint32_t)(table->entries
[i].vclk) & 0xff000000) >> 24) : __swap32md(table->
entries[i].vclk));
pi->uvd_level[i].DclkFrequency = cpu_to_be32(table->entries[i].dclk)(__uint32_t)(__builtin_constant_p(table->entries[i].dclk) ?
 (__uint32_t)(((__uint32_t)(table->entries[i].dclk) & 0xff
) << 24 | ((__uint32_t)(table->entries[i].dclk) &
 0xff00) << 8 | ((__uint32_t)(table->entries[i].dclk
) & 0xff0000) >> 8 | ((__uint32_t)(table->entries
[i].dclk) & 0xff000000) >> 24) : __swap32md(table->
entries[i].dclk));
pi->uvd_level[i].MinVddNb = cpu_to_be16(table->entries[i].v)(__uint16_t)(__builtin_constant_p(table->entries[i].v) ? (
__uint16_t)(((__uint16_t)(table->entries[i].v) & 0xffU
) << 8 | ((__uint16_t)(table->entries[i].v) & 0xff00U
) >> 8) : __swap16md(table->entries[i].v));

pi->uvd_level[i].VClkBypassCntl =
	(u8)kv_get_clk_bypass(rdev, table->entries[i].vclk);
pi->uvd_level[i].DClkBypassCntl =
	(u8)kv_get_clk_bypass(rdev, table->entries[i].dclk);

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
				     table->entries[i].vclk, false0, &dividers);
if (ret)
	return ret;
pi->uvd_level[i].VclkDivider = (u8)dividers.post_div;

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
				     table->entries[i].dclk, false0, &dividers);
if (ret)
	return ret;
pi->uvd_level[i].DclkDivider = (u8)dividers.post_div;

pi->uvd_level_count++;
}

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, UvdLevelCount)__builtin_offsetof(SMU7_Fusion_DpmTable, UvdLevelCount),
		   (u8 *)&pi->uvd_level_count,
		   sizeof(u8), pi->sram_end);
if (ret)
return ret;

pi->uvd_interval = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, UVDInterval)__builtin_offsetof(SMU7_Fusion_DpmTable, UVDInterval),
		   &pi->uvd_interval,
		   sizeof(u8), pi->sram_end);
if (ret)
return ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, UvdLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, UvdLevel),
		   (u8 *)&pi->uvd_level,
		   sizeof(SMU7_Fusion_UvdLevel) * SMU7_MAX_LEVELS_UVD8,
		   pi->sram_end);

return ret;

729}

731static int kv_populate_vce_table(struct radeon_device *rdev)
732{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;
u32 i;
struct radeon_vce_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
struct atom_clock_dividers dividers;

if (table == NULL((void *)0) || table->count == 0)
return 0;

pi->vce_level_count = 0;
for (i = 0; i < table->count; i++) {
if (pi->high_voltage_t &&
    pi->high_voltage_t < table->entries[i].v)
	break;

pi->vce_level[i].Frequency = cpu_to_be32(table->entries[i].evclk)(__uint32_t)(__builtin_constant_p(table->entries[i].evclk)
 ? (__uint32_t)(((__uint32_t)(table->entries[i].evclk) &
 0xff) << 24 | ((__uint32_t)(table->entries[i].evclk
) & 0xff00) << 8 | ((__uint32_t)(table->entries[
i].evclk) & 0xff0000) >> 8 | ((__uint32_t)(table->
entries[i].evclk) & 0xff000000) >> 24) : __swap32md
(table->entries[i].evclk));
pi->vce_level[i].MinVoltage = cpu_to_be16(table->entries[i].v)(__uint16_t)(__builtin_constant_p(table->entries[i].v) ? (
__uint16_t)(((__uint16_t)(table->entries[i].v) & 0xffU
) << 8 | ((__uint16_t)(table->entries[i].v) & 0xff00U
) >> 8) : __swap16md(table->entries[i].v));

pi->vce_level[i].ClkBypassCntl =
	(u8)kv_get_clk_bypass(rdev, table->entries[i].evclk);

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
				     table->entries[i].evclk, false0, &dividers);
if (ret)
	return ret;
pi->vce_level[i].Divider = (u8)dividers.post_div;

pi->vce_level_count++;
}

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, VceLevelCount)__builtin_offsetof(SMU7_Fusion_DpmTable, VceLevelCount),
		   (u8 *)&pi->vce_level_count,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

pi->vce_interval = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, VCEInterval)__builtin_offsetof(SMU7_Fusion_DpmTable, VCEInterval),
		   (u8 *)&pi->vce_interval,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, VceLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, VceLevel),
		   (u8 *)&pi->vce_level,
		   sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_VCE8,
		   pi->sram_end);

return ret;
792}

794static int kv_populate_samu_table(struct radeon_device *rdev)
795{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
struct atom_clock_dividers dividers;
int ret;
u32 i;

if (table == NULL((void *)0) || table->count == 0)
return 0;

pi->samu_level_count = 0;
for (i = 0; i < table->count; i++) {
if (pi->high_voltage_t &&
    pi->high_voltage_t < table->entries[i].v)
	break;

pi->samu_level[i].Frequency = cpu_to_be32(table->entries[i].clk)(__uint32_t)(__builtin_constant_p(table->entries[i].clk) ?
 (__uint32_t)(((__uint32_t)(table->entries[i].clk) & 0xff
) << 24 | ((__uint32_t)(table->entries[i].clk) &
 0xff00) << 8 | ((__uint32_t)(table->entries[i].clk)
 & 0xff0000) >> 8 | ((__uint32_t)(table->entries
[i].clk) & 0xff000000) >> 24) : __swap32md(table->
entries[i].clk));
pi->samu_level[i].MinVoltage = cpu_to_be16(table->entries[i].v)(__uint16_t)(__builtin_constant_p(table->entries[i].v) ? (
__uint16_t)(((__uint16_t)(table->entries[i].v) & 0xffU
) << 8 | ((__uint16_t)(table->entries[i].v) & 0xff00U
) >> 8) : __swap16md(table->entries[i].v));

pi->samu_level[i].ClkBypassCntl =
	(u8)kv_get_clk_bypass(rdev, table->entries[i].clk);

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
				     table->entries[i].clk, false0, &dividers);
if (ret)
	return ret;
pi->samu_level[i].Divider = (u8)dividers.post_div;

pi->samu_level_count++;
}

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, SamuLevelCount)__builtin_offsetof(SMU7_Fusion_DpmTable, SamuLevelCount),
		   (u8 *)&pi->samu_level_count,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

pi->samu_interval = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, SAMUInterval)__builtin_offsetof(SMU7_Fusion_DpmTable, SAMUInterval),
		   (u8 *)&pi->samu_interval,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, SamuLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, SamuLevel),
		   (u8 *)&pi->samu_level,
		   sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_SAMU8,
		   pi->sram_end);
if (ret)
return ret;

return ret;
857}


860static int kv_populate_acp_table(struct radeon_device *rdev)
861{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
struct atom_clock_dividers dividers;
int ret;
u32 i;

if (table == NULL((void *)0) || table->count == 0)
return 0;

pi->acp_level_count = 0;
for (i = 0; i < table->count; i++) {
pi->acp_level[i].Frequency = cpu_to_be32(table->entries[i].clk)(__uint32_t)(__builtin_constant_p(table->entries[i].clk) ?
 (__uint32_t)(((__uint32_t)(table->entries[i].clk) & 0xff
) << 24 | ((__uint32_t)(table->entries[i].clk) &
 0xff00) << 8 | ((__uint32_t)(table->entries[i].clk)
 & 0xff0000) >> 8 | ((__uint32_t)(table->entries
[i].clk) & 0xff000000) >> 24) : __swap32md(table->
entries[i].clk));
pi->acp_level[i].MinVoltage = cpu_to_be16(table->entries[i].v)(__uint16_t)(__builtin_constant_p(table->entries[i].v) ? (
__uint16_t)(((__uint16_t)(table->entries[i].v) & 0xffU
) << 8 | ((__uint16_t)(table->entries[i].v) & 0xff00U
) >> 8) : __swap16md(table->entries[i].v));

ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM2,
				     table->entries[i].clk, false0, &dividers);
if (ret)
	return ret;
pi->acp_level[i].Divider = (u8)dividers.post_div;

pi->acp_level_count++;
}

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, AcpLevelCount)__builtin_offsetof(SMU7_Fusion_DpmTable, AcpLevelCount),
		   (u8 *)&pi->acp_level_count,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

pi->acp_interval = 1;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, ACPInterval)__builtin_offsetof(SMU7_Fusion_DpmTable, ACPInterval),
		   (u8 *)&pi->acp_interval,
		   sizeof(u8),
		   pi->sram_end);
if (ret)
return ret;

ret = kv_copy_bytes_to_smc(rdev,
		   pi->dpm_table_start +
		   offsetof(SMU7_Fusion_DpmTable, AcpLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, AcpLevel),
		   (u8 *)&pi->acp_level,
		   sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_ACP8,
		   pi->sram_end);
if (ret)
return ret;

return ret;
916}

918static void kv_calculate_dfs_bypass_settings(struct radeon_device *rdev)
919{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;

if (table && table->count) {
for (i = 0; i < pi->graphics_dpm_level_count; i++) {
	if (pi->caps_enable_dfs_bypass) {
		if (kv_get_clock_difference(table->entries[i].clk, 40000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 3;
		else if (kv_get_clock_difference(table->entries[i].clk, 30000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 2;
		else if (kv_get_clock_difference(table->entries[i].clk, 26600) < 200)
			pi->graphics_level[i].ClkBypassCntl = 7;
		else if (kv_get_clock_difference(table->entries[i].clk , 20000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 6;
		else if (kv_get_clock_difference(table->entries[i].clk , 10000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 8;
		else
			pi->graphics_level[i].ClkBypassCntl = 0;
	} else {
		pi->graphics_level[i].ClkBypassCntl = 0;
	}
}
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;
for (i = 0; i < pi->graphics_dpm_level_count; i++) {
	if (pi->caps_enable_dfs_bypass) {
		if (kv_get_clock_difference(table->entries[i].sclk_frequency, 40000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 3;
		else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 30000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 2;
		else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 26600) < 200)
			pi->graphics_level[i].ClkBypassCntl = 7;
		else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 20000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 6;
		else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 10000) < 200)
			pi->graphics_level[i].ClkBypassCntl = 8;
		else
			pi->graphics_level[i].ClkBypassCntl = 0;
	} else {
		pi->graphics_level[i].ClkBypassCntl = 0;
	}
}
}
966}

968static int kv_enable_ulv(struct radeon_device *rdev, bool_Bool enable)
969{
return kv_notify_message_to_smu(rdev, enable ?
			PPSMC_MSG_EnableULV((uint8_t)0x62) : PPSMC_MSG_DisableULV((uint8_t)0x63));
972}

974static void kv_reset_acp_boot_level(struct radeon_device *rdev)
975{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->acp_boot_level = 0xff;
979}

981static void kv_update_current_ps(struct radeon_device *rdev,
		 struct radeon_ps *rps)
983{
struct kv_ps *new_ps = kv_get_ps(rps);
struct kv_power_info *pi = kv_get_pi(rdev);

pi->current_rps = *rps;
pi->current_ps = *new_ps;
pi->current_rps.ps_priv = &pi->current_ps;
990}

992static void kv_update_requested_ps(struct radeon_device *rdev,
		   struct radeon_ps *rps)
994{
struct kv_ps *new_ps = kv_get_ps(rps);
struct kv_power_info *pi = kv_get_pi(rdev);

pi->requested_rps = *rps;
pi->requested_ps = *new_ps;
pi->requested_rps.ps_priv = &pi->requested_ps;
1001}

1003void kv_dpm_enable_bapm(struct radeon_device *rdev, bool_Bool enable)
1004{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

if (pi->bapm_enable) {
ret = kv_smc_bapm_enable(rdev, enable);
if (ret)
	DRM_ERROR("kv_smc_bapm_enable failed\n")__drm_err("kv_smc_bapm_enable failed\n");
}
1013}

1015static void kv_enable_thermal_int(struct radeon_device *rdev, bool_Bool enable)
1016{
u32 thermal_int;

thermal_int = RREG32_SMC(CG_THERMAL_INT_CTRL)tn_smc_rreg(rdev, (0xC2100028));
if (enable)
thermal_int |= THERM_INTH_MASK(1 << 24) | THERM_INTL_MASK(1 << 25);
else
thermal_int &= ~(THERM_INTH_MASK(1 << 24) | THERM_INTL_MASK(1 << 25));
WREG32_SMC(CG_THERMAL_INT_CTRL, thermal_int)tn_smc_wreg(rdev, (0xC2100028), (thermal_int));

1026}

1028int kv_dpm_enable(struct radeon_device *rdev)
1029{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret;

ret = kv_process_firmware_header(rdev);
if (ret) {
DRM_ERROR("kv_process_firmware_header failed\n")__drm_err("kv_process_firmware_header failed\n");
return ret;
}
kv_init_fps_limits(rdev);
kv_init_graphics_levels(rdev);
ret = kv_program_bootup_state(rdev);
if (ret) {
DRM_ERROR("kv_program_bootup_state failed\n")__drm_err("kv_program_bootup_state failed\n");
return ret;
}
kv_calculate_dfs_bypass_settings(rdev);
ret = kv_upload_dpm_settings(rdev);
if (ret) {
DRM_ERROR("kv_upload_dpm_settings failed\n")__drm_err("kv_upload_dpm_settings failed\n");
return ret;
}
ret = kv_populate_uvd_table(rdev);
if (ret) {
DRM_ERROR("kv_populate_uvd_table failed\n")__drm_err("kv_populate_uvd_table failed\n");
return ret;
}
ret = kv_populate_vce_table(rdev);
if (ret) {
DRM_ERROR("kv_populate_vce_table failed\n")__drm_err("kv_populate_vce_table failed\n");
return ret;
}
ret = kv_populate_samu_table(rdev);
if (ret) {
DRM_ERROR("kv_populate_samu_table failed\n")__drm_err("kv_populate_samu_table failed\n");
return ret;
}
ret = kv_populate_acp_table(rdev);
if (ret) {
DRM_ERROR("kv_populate_acp_table failed\n")__drm_err("kv_populate_acp_table failed\n");
return ret;
}
kv_program_vc(rdev);

kv_start_am(rdev);
if (pi->enable_auto_thermal_throttling) {
ret = kv_enable_auto_thermal_throttling(rdev);
if (ret) {
	DRM_ERROR("kv_enable_auto_thermal_throttling failed\n")__drm_err("kv_enable_auto_thermal_throttling failed\n");
	return ret;
}
}
ret = kv_enable_dpm_voltage_scaling(rdev);
if (ret) {
DRM_ERROR("kv_enable_dpm_voltage_scaling failed\n")__drm_err("kv_enable_dpm_voltage_scaling failed\n");
return ret;
}
ret = kv_set_dpm_interval(rdev);
if (ret) {
DRM_ERROR("kv_set_dpm_interval failed\n")__drm_err("kv_set_dpm_interval failed\n");
return ret;
}
ret = kv_set_dpm_boot_state(rdev);
if (ret) {
DRM_ERROR("kv_set_dpm_boot_state failed\n")__drm_err("kv_set_dpm_boot_state failed\n");
return ret;
}
ret = kv_enable_ulv(rdev, true1);
if (ret) {
DRM_ERROR("kv_enable_ulv failed\n")__drm_err("kv_enable_ulv failed\n");
return ret;
}
kv_start_dpm(rdev);
ret = kv_enable_didt(rdev, true1);
if (ret) {
DRM_ERROR("kv_enable_didt failed\n")__drm_err("kv_enable_didt failed\n");
return ret;
}
ret = kv_enable_smc_cac(rdev, true1);
if (ret) {
DRM_ERROR("kv_enable_smc_cac failed\n")__drm_err("kv_enable_smc_cac failed\n");
return ret;
}

kv_reset_acp_boot_level(rdev);

ret = kv_smc_bapm_enable(rdev, false0);
if (ret) {
DRM_ERROR("kv_smc_bapm_enable failed\n")__drm_err("kv_smc_bapm_enable failed\n");
return ret;
}

kv_update_current_ps(rdev, rdev->pm.dpm.boot_ps);

return ret;
1124}

1126int kv_dpm_late_enable(struct radeon_device *rdev)
1127{
int ret = 0;

if (rdev->irq.installed &&
   r600_is_internal_thermal_sensor(rdev->pm.int_thermal_type)) {
ret = kv_set_thermal_temperature_range(rdev, R600_TEMP_RANGE_MIN(90 * 1000), R600_TEMP_RANGE_MAX(120 * 1000));
if (ret) {
	DRM_ERROR("kv_set_thermal_temperature_range failed\n")__drm_err("kv_set_thermal_temperature_range failed\n");
	return ret;
}
kv_enable_thermal_int(rdev, true1);
}

/* powerdown unused blocks for now */
kv_dpm_powergate_acp(rdev, true1);
kv_dpm_powergate_samu(rdev, true1);
kv_dpm_powergate_vce(rdev, true1);
kv_dpm_powergate_uvd(rdev, true1);

return ret;
1147}

1149void kv_dpm_disable(struct radeon_device *rdev)
1150{
kv_smc_bapm_enable(rdev, false0);

if (rdev->family == CHIP_MULLINS)
kv_enable_nb_dpm(rdev, false0);

/* powerup blocks */
kv_dpm_powergate_acp(rdev, false0);
kv_dpm_powergate_samu(rdev, false0);
kv_dpm_powergate_vce(rdev, false0);
kv_dpm_powergate_uvd(rdev, false0);

kv_enable_smc_cac(rdev, false0);
kv_enable_didt(rdev, false0);
kv_clear_vc(rdev);
kv_stop_dpm(rdev);
kv_enable_ulv(rdev, false0);
kv_reset_am(rdev);
kv_enable_thermal_int(rdev, false0);

kv_update_current_ps(rdev, rdev->pm.dpm.boot_ps);
1171}

1173static void kv_init_sclk_t(struct radeon_device *rdev)
1174{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->low_sclk_interrupt_t = 0;
1178}

1180static int kv_init_fps_limits(struct radeon_device *rdev)
1181{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret = 0;

if (pi->caps_fps) {
u16 tmp;

tmp = 45;
pi->fps_high_t = cpu_to_be16(tmp)(__uint16_t)(__builtin_constant_p(tmp) ? (__uint16_t)(((__uint16_t
)(tmp) & 0xffU) << 8 | ((__uint16_t)(tmp) & 0xff00U
) >> 8) : __swap16md(tmp));
ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, FpsHighT)__builtin_offsetof(SMU7_Fusion_DpmTable, FpsHighT),
			   (u8 *)&pi->fps_high_t,
			   sizeof(u16), pi->sram_end);

tmp = 30;
pi->fps_low_t = cpu_to_be16(tmp)(__uint16_t)(__builtin_constant_p(tmp) ? (__uint16_t)(((__uint16_t
)(tmp) & 0xffU) << 8 | ((__uint16_t)(tmp) & 0xff00U
) >> 8) : __swap16md(tmp));

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, FpsLowT)__builtin_offsetof(SMU7_Fusion_DpmTable, FpsLowT),
			   (u8 *)&pi->fps_low_t,
			   sizeof(u16), pi->sram_end);

}
return ret;
1207}

1209static void kv_init_powergate_state(struct radeon_device *rdev)
1210{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->uvd_power_gated = false0;
pi->vce_power_gated = false0;
pi->samu_power_gated = false0;
pi->acp_power_gated = false0;

1218}

1220static int kv_enable_uvd_dpm(struct radeon_device *rdev, bool_Bool enable)
1221{
return kv_notify_message_to_smu(rdev, enable ?
			PPSMC_MSG_UVDDPM_Enable((uint16_t) 0x154) : PPSMC_MSG_UVDDPM_Disable((uint16_t) 0x155));
1224}

1226static int kv_enable_vce_dpm(struct radeon_device *rdev, bool_Bool enable)
1227{
return kv_notify_message_to_smu(rdev, enable ?
			PPSMC_MSG_VCEDPM_Enable((uint16_t) 0x15a) : PPSMC_MSG_VCEDPM_Disable((uint16_t) 0x15b));
1230}

1232static int kv_enable_samu_dpm(struct radeon_device *rdev, bool_Bool enable)
1233{
return kv_notify_message_to_smu(rdev, enable ?
			PPSMC_MSG_SAMUDPM_Enable((uint16_t) 0x156) : PPSMC_MSG_SAMUDPM_Disable((uint16_t) 0x157));
1236}

1238static int kv_enable_acp_dpm(struct radeon_device *rdev, bool_Bool enable)
1239{
return kv_notify_message_to_smu(rdev, enable ?
			PPSMC_MSG_ACPDPM_Enable((uint16_t) 0x158) : PPSMC_MSG_ACPDPM_Disable((uint16_t) 0x159));
1242}

1244static int kv_update_uvd_dpm(struct radeon_device *rdev, bool_Bool gate)
1245{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_uvd_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
int ret;
u32 mask;

if (!gate) {
if (table->count)
	pi->uvd_boot_level = table->count - 1;
else
	pi->uvd_boot_level = 0;

if (!pi->caps_uvd_dpm || pi->caps_stable_p_state) {
	mask = 1 << pi->uvd_boot_level;
} else {
	mask = 0x1f;
}

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, UvdBootLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, UvdBootLevel),
			   (uint8_t *)&pi->uvd_boot_level,
			   sizeof(u8), pi->sram_end);
if (ret)
	return ret;

kv_send_msg_to_smc_with_parameter(rdev,
				  PPSMC_MSG_UVDDPM_SetEnabledMask((uint16_t) 0x12D),
				  mask);
}

return kv_enable_uvd_dpm(rdev, !gate);
1278}

1280static u8 kv_get_vce_boot_level(struct radeon_device *rdev, u32 evclk)
1281{
u8 i;
struct radeon_vce_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;

for (i = 0; i < table->count; i++) {
if (table->entries[i].evclk >= evclk)
	break;
}

return i;
1292}

1294static int kv_update_vce_dpm(struct radeon_device *rdev,
	     struct radeon_ps *radeon_new_state,
	     struct radeon_ps *radeon_current_state)
1297{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_vce_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
int ret;

if (radeon_new_state->evclk > 0 && radeon_current_state->evclk == 0) {
kv_dpm_powergate_vce(rdev, false0);
/* turn the clocks on when encoding */
cik_update_cg(rdev, RADEON_CG_BLOCK_VCE(1 << 4), false0);
if (pi->caps_stable_p_state)
	pi->vce_boot_level = table->count - 1;
else
	pi->vce_boot_level = kv_get_vce_boot_level(rdev, radeon_new_state->evclk);

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, VceBootLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, VceBootLevel),
			   (u8 *)&pi->vce_boot_level,
			   sizeof(u8),
			   pi->sram_end);
if (ret)
	return ret;

if (pi->caps_stable_p_state)
	kv_send_msg_to_smc_with_parameter(rdev,
					  PPSMC_MSG_VCEDPM_SetEnabledMask((uint16_t) 0x12E),
					  (1 << pi->vce_boot_level));

kv_enable_vce_dpm(rdev, true1);
} else if (radeon_new_state->evclk == 0 && radeon_current_state->evclk > 0) {
kv_enable_vce_dpm(rdev, false0);
/* turn the clocks off when not encoding */
cik_update_cg(rdev, RADEON_CG_BLOCK_VCE(1 << 4), true1);
kv_dpm_powergate_vce(rdev, true1);
}

return 0;
1335}

1337static int kv_update_samu_dpm(struct radeon_device *rdev, bool_Bool gate)
1338{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
int ret;

if (!gate) {
if (pi->caps_stable_p_state)
	pi->samu_boot_level = table->count - 1;
else
	pi->samu_boot_level = 0;

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, SamuBootLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, SamuBootLevel),
			   (u8 *)&pi->samu_boot_level,
			   sizeof(u8),
			   pi->sram_end);
if (ret)
	return ret;

if (pi->caps_stable_p_state)
	kv_send_msg_to_smc_with_parameter(rdev,
					  PPSMC_MSG_SAMUDPM_SetEnabledMask((uint16_t) 0x130),
					  (1 << pi->samu_boot_level));
}

return kv_enable_samu_dpm(rdev, !gate);
1366}

1368static u8 kv_get_acp_boot_level(struct radeon_device *rdev)
1369{
u8 i;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;

for (i = 0; i < table->count; i++) {
14
←
Assuming 'i' is >= field 'count'→
15
←
Loop condition is false. Execution continues on line 1379→
if (table->entries[i].clk >= 0) /* XXX */
	break;
}

if (i15.1
'i' is >= field 'count'
 >= table->count)
16
←
Taking true branch→
i = table->count - 1;
17
←
The value 255 is assigned to 'i'→

return i;
18
←
Returning the value 255 (loaded from 'i')→
1383}

1385static void kv_update_acp_boot_level(struct radeon_device *rdev)
1386{
struct kv_power_info *pi = kv_get_pi(rdev);
u8 acp_boot_level;

if (!pi->caps_stable_p_state) {
11
←
Assuming field 'caps_stable_p_state' is false→
12
←
Taking true branch→
acp_boot_level = kv_get_acp_boot_level(rdev);
13
←
Calling 'kv_get_acp_boot_level'→
19
←
Returning from 'kv_get_acp_boot_level'→
20
←
The value 255 is assigned to 'acp_boot_level'→
if (acp_boot_level != pi->acp_boot_level) {
21
←
Assuming 'acp_boot_level' is not equal to field 'acp_boot_level'→
22
←
Taking true branch→
	pi->acp_boot_level = acp_boot_level;
23
←
The value 255 is assigned to field 'acp_boot_level'→
	kv_send_msg_to_smc_with_parameter(rdev,
					  PPSMC_MSG_ACPDPM_SetEnabledMask((uint16_t) 0x12F),
					  (1 << pi->acp_boot_level));
24
←
The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'int'
}
}
1399}

1401static int kv_update_acp_dpm(struct radeon_device *rdev, bool_Bool gate)
1402{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
int ret;

if (!gate) {
if (pi->caps_stable_p_state)
	pi->acp_boot_level = table->count - 1;
else
	pi->acp_boot_level = kv_get_acp_boot_level(rdev);

ret = kv_copy_bytes_to_smc(rdev,
			   pi->dpm_table_start +
			   offsetof(SMU7_Fusion_DpmTable, AcpBootLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, AcpBootLevel),
			   (u8 *)&pi->acp_boot_level,
			   sizeof(u8),
			   pi->sram_end);
if (ret)
	return ret;

if (pi->caps_stable_p_state)
	kv_send_msg_to_smc_with_parameter(rdev,
					  PPSMC_MSG_ACPDPM_SetEnabledMask((uint16_t) 0x12F),
					  (1 << pi->acp_boot_level));
}

return kv_enable_acp_dpm(rdev, !gate);
1430}

1432void kv_dpm_powergate_uvd(struct radeon_device *rdev, bool_Bool gate)
1433{
struct kv_power_info *pi = kv_get_pi(rdev);

if (pi->uvd_power_gated == gate)
return;

pi->uvd_power_gated = gate;

if (gate) {
if (pi->caps_uvd_pg) {
	uvd_v1_0_stop(rdev);
	cik_update_cg(rdev, RADEON_CG_BLOCK_UVD(1 << 3), false0);
}
kv_update_uvd_dpm(rdev, gate);
if (pi->caps_uvd_pg)
	kv_notify_message_to_smu(rdev, PPSMC_MSG_UVDPowerOFF((uint8_t)0x60));
} else {
if (pi->caps_uvd_pg) {
	kv_notify_message_to_smu(rdev, PPSMC_MSG_UVDPowerON((uint8_t)0x61));
	uvd_v4_2_resume(rdev);
	uvd_v1_0_start(rdev);
	cik_update_cg(rdev, RADEON_CG_BLOCK_UVD(1 << 3), true1);
}
kv_update_uvd_dpm(rdev, gate);
}
1458}

1460static void kv_dpm_powergate_vce(struct radeon_device *rdev, bool_Bool gate)
1461{
struct kv_power_info *pi = kv_get_pi(rdev);

if (pi->vce_power_gated == gate)
return;

pi->vce_power_gated = gate;

if (gate) {
if (pi->caps_vce_pg) {
	/* XXX do we need a vce_v1_0_stop() ?  */
	kv_notify_message_to_smu(rdev, PPSMC_MSG_VCEPowerOFF((uint32_t) 0x10e));
}
} else {
if (pi->caps_vce_pg) {
	kv_notify_message_to_smu(rdev, PPSMC_MSG_VCEPowerON((uint32_t) 0x10f));
	vce_v2_0_resume(rdev);
	vce_v1_0_start(rdev);
}
}
1481}

1483static void kv_dpm_powergate_samu(struct radeon_device *rdev, bool_Bool gate)
1484{
struct kv_power_info *pi = kv_get_pi(rdev);

if (pi->samu_power_gated == gate)
return;

pi->samu_power_gated = gate;

if (gate) {
kv_update_samu_dpm(rdev, true1);
if (pi->caps_samu_pg)
	kv_notify_message_to_smu(rdev, PPSMC_MSG_SAMPowerOFF((uint16_t) 0x139));
} else {
if (pi->caps_samu_pg)
	kv_notify_message_to_smu(rdev, PPSMC_MSG_SAMPowerON((uint16_t) 0x13a));
kv_update_samu_dpm(rdev, false0);
}
1501}

1503static void kv_dpm_powergate_acp(struct radeon_device *rdev, bool_Bool gate)
1504{
struct kv_power_info *pi = kv_get_pi(rdev);

if (pi->acp_power_gated == gate)
return;

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
return;

pi->acp_power_gated = gate;

if (gate) {
kv_update_acp_dpm(rdev, true1);
if (pi->caps_acp_pg)
	kv_notify_message_to_smu(rdev, PPSMC_MSG_ACPPowerOFF((uint16_t) 0x137));
} else {
if (pi->caps_acp_pg)
	kv_notify_message_to_smu(rdev, PPSMC_MSG_ACPPowerON((uint16_t) 0x138));
kv_update_acp_dpm(rdev, false0);
}
1524}

1526static void kv_set_valid_clock_range(struct radeon_device *rdev,
		     struct radeon_ps *new_rps)
1528{
struct kv_ps *new_ps = kv_get_ps(new_rps);
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;

if (table && table->count) {
for (i = 0; i < pi->graphics_dpm_level_count; i++) {
	if ((table->entries[i].clk >= new_ps->levels[0].sclk) ||
	    (i == (pi->graphics_dpm_level_count - 1))) {
		pi->lowest_valid = i;
		break;
	}
}

for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
	if (table->entries[i].clk <= new_ps->levels[new_ps->num_levels - 1].sclk)
		break;
}
pi->highest_valid = i;

if (pi->lowest_valid > pi->highest_valid) {
	if ((new_ps->levels[0].sclk - table->entries[pi->highest_valid].clk) >
	    (table->entries[pi->lowest_valid].clk - new_ps->levels[new_ps->num_levels - 1].sclk))
		pi->highest_valid = pi->lowest_valid;
	else
		pi->lowest_valid =  pi->highest_valid;
}
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;

for (i = 0; i < (int)pi->graphics_dpm_level_count; i++) {
	if (table->entries[i].sclk_frequency >= new_ps->levels[0].sclk ||
	    i == (int)(pi->graphics_dpm_level_count - 1)) {
		pi->lowest_valid = i;
		break;
	}
}

for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
	if (table->entries[i].sclk_frequency <=
	    new_ps->levels[new_ps->num_levels - 1].sclk)
		break;
}
pi->highest_valid = i;

if (pi->lowest_valid > pi->highest_valid) {
	if ((new_ps->levels[0].sclk -
	     table->entries[pi->highest_valid].sclk_frequency) >
	    (table->entries[pi->lowest_valid].sclk_frequency -
	     new_ps->levels[new_ps->num_levels -1].sclk))
		pi->highest_valid = pi->lowest_valid;
	else
		pi->lowest_valid =  pi->highest_valid;
}
}
1586}

1588static int kv_update_dfs_bypass_settings(struct radeon_device *rdev,
			 struct radeon_ps *new_rps)
1590{
struct kv_ps *new_ps = kv_get_ps(new_rps);
struct kv_power_info *pi = kv_get_pi(rdev);
int ret = 0;
u8 clk_bypass_cntl;

if (pi->caps_enable_dfs_bypass) {
clk_bypass_cntl = new_ps->need_dfs_bypass ?
	pi->graphics_level[pi->graphics_boot_level].ClkBypassCntl : 0;
ret = kv_copy_bytes_to_smc(rdev,
			   (pi->dpm_table_start +
			    offsetof(SMU7_Fusion_DpmTable, GraphicsLevel)__builtin_offsetof(SMU7_Fusion_DpmTable, GraphicsLevel) +
			    (pi->graphics_boot_level * sizeof(SMU7_Fusion_GraphicsLevel)) +
			    offsetof(SMU7_Fusion_GraphicsLevel, ClkBypassCntl)__builtin_offsetof(SMU7_Fusion_GraphicsLevel, ClkBypassCntl)),
			   &clk_bypass_cntl,
			   sizeof(u8), pi->sram_end);
}

return ret;
1609}

1611static int kv_enable_nb_dpm(struct radeon_device *rdev,
	    bool_Bool enable)
1613{
struct kv_power_info *pi = kv_get_pi(rdev);
int ret = 0;

if (enable) {
if (pi->enable_nb_dpm && !pi->nb_dpm_enabled) {
	ret = kv_notify_message_to_smu(rdev, PPSMC_MSG_NBDPM_Enable((uint16_t) 0x140));
	if (ret == 0)
		pi->nb_dpm_enabled = true1;
}
} else {
if (pi->enable_nb_dpm && pi->nb_dpm_enabled) {
	ret = kv_notify_message_to_smu(rdev, PPSMC_MSG_NBDPM_Disable((uint16_t) 0x141));
	if (ret == 0)
		pi->nb_dpm_enabled = false0;
}
}

return ret;
1632}

1634int kv_dpm_force_performance_level(struct radeon_device *rdev,
		   enum radeon_dpm_forced_level level)
1636{
int ret;

if (level == RADEON_DPM_FORCED_LEVEL_HIGH) {
ret = kv_force_dpm_highest(rdev);
if (ret)
	return ret;
} else if (level == RADEON_DPM_FORCED_LEVEL_LOW) {
ret = kv_force_dpm_lowest(rdev);
if (ret)
	return ret;
} else if (level == RADEON_DPM_FORCED_LEVEL_AUTO) {
ret = kv_unforce_levels(rdev);
if (ret)
	return ret;
}

rdev->pm.dpm.forced_level = level;

return 0;
1656}

1658int kv_dpm_pre_set_power_state(struct radeon_device *rdev)
1659{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_ps requested_ps = *rdev->pm.dpm.requested_ps;
struct radeon_ps *new_ps = &requested_ps;

kv_update_requested_ps(rdev, new_ps);

kv_apply_state_adjust_rules(rdev,
		    &pi->requested_rps,
		    &pi->current_rps);

return 0;
1671}

1673int kv_dpm_set_power_state(struct radeon_device *rdev)
1674{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_ps *new_ps = &pi->requested_rps;
struct radeon_ps *old_ps = &pi->current_rps;
int ret;

if (pi->bapm_enable) {
1
Assuming field 'bapm_enable' is false→
ret = kv_smc_bapm_enable(rdev, rdev->pm.dpm.ac_power);
if (ret) {
	DRM_ERROR("kv_smc_bapm_enable failed\n")__drm_err("kv_smc_bapm_enable failed\n");
	return ret;
}
}

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS) {
2
←
Assuming field 'family' is not equal to CHIP_KABINI→
3
←
Assuming field 'family' is not equal to CHIP_MULLINS→
4
←
Taking false branch→
if (pi->enable_dpm) {
	kv_set_valid_clock_range(rdev, new_ps);
	kv_update_dfs_bypass_settings(rdev, new_ps);
	ret = kv_calculate_ds_divider(rdev);
	if (ret) {
		DRM_ERROR("kv_calculate_ds_divider failed\n")__drm_err("kv_calculate_ds_divider failed\n");
		return ret;
	}
	kv_calculate_nbps_level_settings(rdev);
	kv_calculate_dpm_settings(rdev);
	kv_force_lowest_valid(rdev);
	kv_enable_new_levels(rdev);
	kv_upload_dpm_settings(rdev);
	kv_program_nbps_index_settings(rdev, new_ps);
	kv_unforce_levels(rdev);
	kv_set_enabled_levels(rdev);
	kv_force_lowest_valid(rdev);
	kv_unforce_levels(rdev);

	ret = kv_update_vce_dpm(rdev, new_ps, old_ps);
	if (ret) {
		DRM_ERROR("kv_update_vce_dpm failed\n")__drm_err("kv_update_vce_dpm failed\n");
		return ret;
	}
	kv_update_sclk_t(rdev);
	if (rdev->family == CHIP_MULLINS)
		kv_enable_nb_dpm(rdev, true1);
}
} else {
if (pi->enable_dpm) {
5
←
Assuming field 'enable_dpm' is true→
6
←
Taking true branch→
	kv_set_valid_clock_range(rdev, new_ps);
	kv_update_dfs_bypass_settings(rdev, new_ps);
	ret = kv_calculate_ds_divider(rdev);
	if (ret) {
7
←
Assuming 'ret' is 0→
8
←
Taking false branch→
		DRM_ERROR("kv_calculate_ds_divider failed\n")__drm_err("kv_calculate_ds_divider failed\n");
		return ret;
	}
	kv_calculate_nbps_level_settings(rdev);
	kv_calculate_dpm_settings(rdev);
	kv_freeze_sclk_dpm(rdev, true1);
	kv_upload_dpm_settings(rdev);
	kv_program_nbps_index_settings(rdev, new_ps);
	kv_freeze_sclk_dpm(rdev, false0);
	kv_set_enabled_levels(rdev);
	ret = kv_update_vce_dpm(rdev, new_ps, old_ps);
	if (ret8.1
'ret' is 0
) {
9
←
Taking false branch→
		DRM_ERROR("kv_update_vce_dpm failed\n")__drm_err("kv_update_vce_dpm failed\n");
		return ret;
	}
	kv_update_acp_boot_level(rdev);
10
←
Calling 'kv_update_acp_boot_level'→
	kv_update_sclk_t(rdev);
	kv_enable_nb_dpm(rdev, true1);
}
}

return 0;
1745}

1747void kv_dpm_post_set_power_state(struct radeon_device *rdev)
1748{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_ps *new_ps = &pi->requested_rps;

kv_update_current_ps(rdev, new_ps);
1753}

1755void kv_dpm_setup_asic(struct radeon_device *rdev)
1756{
sumo_take_smu_control(rdev, true1);
kv_init_powergate_state(rdev);
kv_init_sclk_t(rdev);
1760}

1762//XXX use sumo_dpm_display_configuration_changed

1764static void kv_construct_max_power_limits_table(struct radeon_device *rdev,
				struct radeon_clock_and_voltage_limits *table)
1766{
struct kv_power_info *pi = kv_get_pi(rdev);

if (pi->sys_info.sclk_voltage_mapping_table.num_max_dpm_entries > 0) {
int idx = pi->sys_info.sclk_voltage_mapping_table.num_max_dpm_entries - 1;
table->sclk =
	pi->sys_info.sclk_voltage_mapping_table.entries[idx].sclk_frequency;
table->vddc =
	kv_convert_2bit_index_to_voltage(rdev,
					 pi->sys_info.sclk_voltage_mapping_table.entries[idx].vid_2bit);
}

table->mclk = pi->sys_info.nbp_memory_clock[0];
1779}

1781static void kv_patch_voltage_values(struct radeon_device *rdev)
1782{
int i;
struct radeon_uvd_clock_voltage_dependency_table *uvd_table =
&rdev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
struct radeon_vce_clock_voltage_dependency_table *vce_table =
&rdev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
struct radeon_clock_voltage_dependency_table *samu_table =
&rdev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
struct radeon_clock_voltage_dependency_table *acp_table =
&rdev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;

if (uvd_table->count) {
for (i = 0; i < uvd_table->count; i++)
	uvd_table->entries[i].v =
		kv_convert_8bit_index_to_voltage(rdev,
						 uvd_table->entries[i].v);
}

if (vce_table->count) {
for (i = 0; i < vce_table->count; i++)
	vce_table->entries[i].v =
		kv_convert_8bit_index_to_voltage(rdev,
						 vce_table->entries[i].v);
}

if (samu_table->count) {
for (i = 0; i < samu_table->count; i++)
	samu_table->entries[i].v =
		kv_convert_8bit_index_to_voltage(rdev,
						 samu_table->entries[i].v);
}

if (acp_table->count) {
for (i = 0; i < acp_table->count; i++)
	acp_table->entries[i].v =
		kv_convert_8bit_index_to_voltage(rdev,
						 acp_table->entries[i].v);
}

1821}

1823static void kv_construct_boot_state(struct radeon_device *rdev)
1824{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->boot_pl.sclk = pi->sys_info.bootup_sclk;
pi->boot_pl.vddc_index = pi->sys_info.bootup_nb_voltage_index;
pi->boot_pl.ds_divider_index = 0;
pi->boot_pl.ss_divider_index = 0;
pi->boot_pl.allow_gnb_slow = 1;
pi->boot_pl.force_nbp_state = 0;
pi->boot_pl.display_wm = 0;
pi->boot_pl.vce_wm = 0;
1835}

1837static int kv_force_dpm_highest(struct radeon_device *rdev)
1838{
int ret;
u32 enable_mask, i;

ret = kv_dpm_get_enable_mask(rdev, &enable_mask);
if (ret)
return ret;

for (i = SMU7_MAX_LEVELS_GRAPHICS8 - 1; i > 0; i--) {
if (enable_mask & (1 << i))
	break;
}

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
return kv_send_msg_to_smc_with_parameter(rdev, PPSMC_MSG_DPM_ForceState((uint32_t) 0x104), i);
else
return kv_set_enabled_level(rdev, i);
1855}

1857static int kv_force_dpm_lowest(struct radeon_device *rdev)
1858{
int ret;
u32 enable_mask, i;

ret = kv_dpm_get_enable_mask(rdev, &enable_mask);
if (ret)
return ret;

for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS8; i++) {
if (enable_mask & (1 << i))
	break;
}

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
return kv_send_msg_to_smc_with_parameter(rdev, PPSMC_MSG_DPM_ForceState((uint32_t) 0x104), i);
else
return kv_set_enabled_level(rdev, i);
1875}

1877static u8 kv_get_sleep_divider_id_from_clock(struct radeon_device *rdev,
			     u32 sclk, u32 min_sclk_in_sr)
1879{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
u32 temp;
u32 min = (min_sclk_in_sr > KV_MINIMUM_ENGINE_CLOCK800) ?
min_sclk_in_sr : KV_MINIMUM_ENGINE_CLOCK800;

if (sclk < min)
return 0;

if (!pi->caps_sclk_ds)
return 0;

for (i = KV_MAX_DEEPSLEEP_DIVIDER_ID5; i > 0; i--) {
temp = sclk / sumo_get_sleep_divider_from_id(i);
if (temp >= min)
	break;
}

return (u8)i;
1899}

1901static int kv_get_high_voltage_limit(struct radeon_device *rdev, int *limit)
1902{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
int i;

if (table && table->count) {
for (i = table->count - 1; i >= 0; i--) {
	if (pi->high_voltage_t &&
	    (kv_convert_8bit_index_to_voltage(rdev, table->entries[i].v) <=
	     pi->high_voltage_t)) {
		*limit = i;
		return 0;
	}
}
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;

for (i = table->num_max_dpm_entries - 1; i >= 0; i--) {
	if (pi->high_voltage_t &&
	    (kv_convert_2bit_index_to_voltage(rdev, table->entries[i].vid_2bit) <=
	     pi->high_voltage_t)) {
		*limit = i;
		return 0;
	}
}
}

*limit = 0;
return 0;
1933}

1935static void kv_apply_state_adjust_rules(struct radeon_device *rdev,
			struct radeon_ps *new_rps,
			struct radeon_ps *old_rps)
1938{
struct kv_ps *ps = kv_get_ps(new_rps);
struct kv_power_info *pi = kv_get_pi(rdev);
u32 min_sclk = 10000; /* ??? */
u32 sclk, mclk = 0;
int i, limit;
bool_Bool force_high;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
u32 stable_p_state_sclk = 0;
struct radeon_clock_and_voltage_limits *max_limits =
&rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac;

if (new_rps->vce_active) {
new_rps->evclk = rdev->pm.dpm.vce_states[rdev->pm.dpm.vce_level].evclk;
new_rps->ecclk = rdev->pm.dpm.vce_states[rdev->pm.dpm.vce_level].ecclk;
} else {
new_rps->evclk = 0;
new_rps->ecclk = 0;
}

mclk = max_limits->mclk;
sclk = min_sclk;

if (pi->caps_stable_p_state) {
stable_p_state_sclk = (max_limits->sclk * 75) / 100;

for (i = table->count - 1; i >= 0; i--) {
	if (stable_p_state_sclk >= table->entries[i].clk) {
		stable_p_state_sclk = table->entries[i].clk;
		break;
	}
}

if (i > 0)
	stable_p_state_sclk = table->entries[0].clk;

sclk = stable_p_state_sclk;
}

if (new_rps->vce_active) {
if (sclk < rdev->pm.dpm.vce_states[rdev->pm.dpm.vce_level].sclk)
	sclk = rdev->pm.dpm.vce_states[rdev->pm.dpm.vce_level].sclk;
}

ps->need_dfs_bypass = true1;

for (i = 0; i < ps->num_levels; i++) {
if (ps->levels[i].sclk < sclk)
	ps->levels[i].sclk = sclk;
}

if (table && table->count) {
for (i = 0; i < ps->num_levels; i++) {
	if (pi->high_voltage_t &&
	    (pi->high_voltage_t <
	     kv_convert_8bit_index_to_voltage(rdev, ps->levels[i].vddc_index))) {
		kv_get_high_voltage_limit(rdev, &limit);
		ps->levels[i].sclk = table->entries[limit].clk;
	}
}
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;

for (i = 0; i < ps->num_levels; i++) {
	if (pi->high_voltage_t &&
	    (pi->high_voltage_t <
	     kv_convert_8bit_index_to_voltage(rdev, ps->levels[i].vddc_index))) {
		kv_get_high_voltage_limit(rdev, &limit);
		ps->levels[i].sclk = table->entries[limit].sclk_frequency;
	}
}
}

if (pi->caps_stable_p_state) {
for (i = 0; i < ps->num_levels; i++) {
	ps->levels[i].sclk = stable_p_state_sclk;
}
}

pi->video_start = new_rps->dclk || new_rps->vclk ||
new_rps->evclk || new_rps->ecclk;

if ((new_rps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK0x0007) ==
   ATOM_PPLIB_CLASSIFICATION_UI_BATTERY1)
pi->battery_state = true1;
else
pi->battery_state = false0;

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS) {
ps->dpm0_pg_nb_ps_lo = 0x1;
ps->dpm0_pg_nb_ps_hi = 0x0;
ps->dpmx_nb_ps_lo = 0x1;
ps->dpmx_nb_ps_hi = 0x0;
} else {
ps->dpm0_pg_nb_ps_lo = 0x3;
ps->dpm0_pg_nb_ps_hi = 0x0;
ps->dpmx_nb_ps_lo = 0x3;
ps->dpmx_nb_ps_hi = 0x0;

if (pi->sys_info.nb_dpm_enable) {
	force_high = (mclk >= pi->sys_info.nbp_memory_clock[3]) ||
		pi->video_start || (rdev->pm.dpm.new_active_crtc_count >= 3) ||
		pi->disable_nb_ps3_in_battery;
	ps->dpm0_pg_nb_ps_lo = force_high ? 0x2 : 0x3;
	ps->dpm0_pg_nb_ps_hi = 0x2;
	ps->dpmx_nb_ps_lo = force_high ? 0x2 : 0x3;
	ps->dpmx_nb_ps_hi = 0x2;
}
}
2049}

2051static void kv_dpm_power_level_enabled_for_throttle(struct radeon_device *rdev,
				    u32 index, bool_Bool enable)
2053{
struct kv_power_info *pi = kv_get_pi(rdev);

pi->graphics_level[index].EnabledForThrottle = enable ? 1 : 0;
2057}

2059static int kv_calculate_ds_divider(struct radeon_device *rdev)
2060{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 sclk_in_sr = 10000; /* ??? */
u32 i;

if (pi->lowest_valid > pi->highest_valid)
return -EINVAL22;

for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
pi->graphics_level[i].DeepSleepDivId =
	kv_get_sleep_divider_id_from_clock(rdev,
					   be32_to_cpu(pi->graphics_level[i].SclkFrequency)(__uint32_t)(__builtin_constant_p(pi->graphics_level[i].SclkFrequency
) ? (__uint32_t)(((__uint32_t)(pi->graphics_level[i].SclkFrequency
) & 0xff) << 24 | ((__uint32_t)(pi->graphics_level
[i].SclkFrequency) & 0xff00) << 8 | ((__uint32_t)(pi
->graphics_level[i].SclkFrequency) & 0xff0000) >>
| ((__uint32_t)(pi->graphics_level[i].SclkFrequency) &
 0xff000000) >> 24) : __swap32md(pi->graphics_level[
i].SclkFrequency)),
					   sclk_in_sr);
}
return 0;
2075}

2077static int kv_calculate_nbps_level_settings(struct radeon_device *rdev)
2078{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
bool_Bool force_high;
struct radeon_clock_and_voltage_limits *max_limits =
&rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac;
u32 mclk = max_limits->mclk;

if (pi->lowest_valid > pi->highest_valid)
return -EINVAL22;

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS) {
for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
	pi->graphics_level[i].GnbSlow = 1;
	pi->graphics_level[i].ForceNbPs1 = 0;
	pi->graphics_level[i].UpH = 0;
}

if (!pi->sys_info.nb_dpm_enable)
	return 0;

force_high = ((mclk >= pi->sys_info.nbp_memory_clock[3]) ||
	      (rdev->pm.dpm.new_active_crtc_count >= 3) || pi->video_start);

if (force_high) {
	for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
		pi->graphics_level[i].GnbSlow = 0;
} else {
	if (pi->battery_state)
		pi->graphics_level[0].ForceNbPs1 = 1;

	pi->graphics_level[1].GnbSlow = 0;
	pi->graphics_level[2].GnbSlow = 0;
	pi->graphics_level[3].GnbSlow = 0;
	pi->graphics_level[4].GnbSlow = 0;
}
} else {
for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
	pi->graphics_level[i].GnbSlow = 1;
	pi->graphics_level[i].ForceNbPs1 = 0;
	pi->graphics_level[i].UpH = 0;
}

if (pi->sys_info.nb_dpm_enable && pi->battery_state) {
	pi->graphics_level[pi->lowest_valid].UpH = 0x28;
	pi->graphics_level[pi->lowest_valid].GnbSlow = 0;
	if (pi->lowest_valid != pi->highest_valid)
		pi->graphics_level[pi->lowest_valid].ForceNbPs1 = 1;
}
}
return 0;
2129}

2131static int kv_calculate_dpm_settings(struct radeon_device *rdev)
2132{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;

if (pi->lowest_valid > pi->highest_valid)
return -EINVAL22;

for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
pi->graphics_level[i].DisplayWatermark = (i == pi->highest_valid) ? 1 : 0;

return 0;
2143}

2145static void kv_init_graphics_levels(struct radeon_device *rdev)
2146{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;
struct radeon_clock_voltage_dependency_table *table =
&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk;

if (table && table->count) {
u32 vid_2bit;

pi->graphics_dpm_level_count = 0;
for (i = 0; i < table->count; i++) {
	if (pi->high_voltage_t &&
	    (pi->high_voltage_t <
	     kv_convert_8bit_index_to_voltage(rdev, table->entries[i].v)))
		break;

	kv_set_divider_value(rdev, i, table->entries[i].clk);
	vid_2bit = kv_convert_vid7_to_vid2(rdev,
					   &pi->sys_info.vid_mapping_table,
					   table->entries[i].v);
	kv_set_vid(rdev, i, vid_2bit);
	kv_set_at(rdev, i, pi->at[i]);
	kv_dpm_power_level_enabled_for_throttle(rdev, i, true1);
	pi->graphics_dpm_level_count++;
}
} else {
struct sumo_sclk_voltage_mapping_table *table =
	&pi->sys_info.sclk_voltage_mapping_table;

pi->graphics_dpm_level_count = 0;
for (i = 0; i < table->num_max_dpm_entries; i++) {
	if (pi->high_voltage_t &&
	    pi->high_voltage_t <
	    kv_convert_2bit_index_to_voltage(rdev, table->entries[i].vid_2bit))
		break;

	kv_set_divider_value(rdev, i, table->entries[i].sclk_frequency);
	kv_set_vid(rdev, i, table->entries[i].vid_2bit);
	kv_set_at(rdev, i, pi->at[i]);
	kv_dpm_power_level_enabled_for_throttle(rdev, i, true1);
	pi->graphics_dpm_level_count++;
}
}

for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS8; i++)
kv_dpm_power_level_enable(rdev, i, false0);
2192}

2194static void kv_enable_new_levels(struct radeon_device *rdev)
2195{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i;

for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS8; i++) {
if (i >= pi->lowest_valid && i <= pi->highest_valid)
	kv_dpm_power_level_enable(rdev, i, true1);
}
2203}

2205static int kv_set_enabled_level(struct radeon_device *rdev, u32 level)
2206{
u32 new_mask = (1 << level);

return kv_send_msg_to_smc_with_parameter(rdev,
				 PPSMC_MSG_SCLKDPM_SetEnabledMask((uint16_t) 0x145),
				 new_mask);
2212}

2214static int kv_set_enabled_levels(struct radeon_device *rdev)
2215{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 i, new_mask = 0;

for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
new_mask |= (1 << i);

return kv_send_msg_to_smc_with_parameter(rdev,
				 PPSMC_MSG_SCLKDPM_SetEnabledMask((uint16_t) 0x145),
				 new_mask);
2225}

2227static void kv_program_nbps_index_settings(struct radeon_device *rdev,
			   struct radeon_ps *new_rps)
2229{
struct kv_ps *new_ps = kv_get_ps(new_rps);
struct kv_power_info *pi = kv_get_pi(rdev);
u32 nbdpmconfig1;

if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
return;

if (pi->sys_info.nb_dpm_enable) {
nbdpmconfig1 = RREG32_SMC(NB_DPM_CONFIG_1)tn_smc_rreg(rdev, (0x3F9E8));
nbdpmconfig1 &= ~(Dpm0PgNbPsLo_MASK0x000000ff | Dpm0PgNbPsHi_MASK0x0000ff00 |
		  DpmXNbPsLo_MASK0x00ff0000 | DpmXNbPsHi_MASK0xff000000);
nbdpmconfig1 |= (Dpm0PgNbPsLo(new_ps->dpm0_pg_nb_ps_lo)((new_ps->dpm0_pg_nb_ps_lo) << 0) |
		 Dpm0PgNbPsHi(new_ps->dpm0_pg_nb_ps_hi)((new_ps->dpm0_pg_nb_ps_hi) << 8) |
		 DpmXNbPsLo(new_ps->dpmx_nb_ps_lo)((new_ps->dpmx_nb_ps_lo) << 16) |
		 DpmXNbPsHi(new_ps->dpmx_nb_ps_hi)((new_ps->dpmx_nb_ps_hi) << 24));
WREG32_SMC(NB_DPM_CONFIG_1, nbdpmconfig1)tn_smc_wreg(rdev, (0x3F9E8), (nbdpmconfig1));
}
2247}

2249static int kv_set_thermal_temperature_range(struct radeon_device *rdev,
			    int min_temp, int max_temp)
2251{
int low_temp = 0 * 1000;
int high_temp = 255 * 1000;
u32 tmp;

if (low_temp < min_temp)
low_temp = min_temp;
if (high_temp > max_temp)
high_temp = max_temp;
if (high_temp < low_temp) {
DRM_ERROR("invalid thermal range: %d - %d\n", low_temp, high_temp)__drm_err("invalid thermal range: %d - %d\n", low_temp, high_temp
);
return -EINVAL22;
}

tmp = RREG32_SMC(CG_THERMAL_INT_CTRL)tn_smc_rreg(rdev, (0xC2100028));
tmp &= ~(DIG_THERM_INTH_MASK0x000000FF | DIG_THERM_INTL_MASK0x0000FF00);
tmp |= (DIG_THERM_INTH(49 + (high_temp / 1000))((49 + (high_temp / 1000)) << 0) |
DIG_THERM_INTL(49 + (low_temp / 1000))((49 + (low_temp / 1000)) << 8));
WREG32_SMC(CG_THERMAL_INT_CTRL, tmp)tn_smc_wreg(rdev, (0xC2100028), (tmp));

rdev->pm.dpm.thermal.min_temp = low_temp;
rdev->pm.dpm.thermal.max_temp = high_temp;

return 0;
2275}

2277union igp_info {
struct _ATOM_INTEGRATED_SYSTEM_INFO info;
struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
struct _ATOM_INTEGRATED_SYSTEM_INFO_V5 info_5;
struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 info_6;
struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_7 info_7;
struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_8 info_8;
2284};

2286static int kv_parse_sys_info_table(struct radeon_device *rdev)
2287{
struct kv_power_info *pi = kv_get_pi(rdev);
struct radeon_mode_info *mode_info = &rdev->mode_info;
int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo)(__builtin_offsetof(ATOM_MASTER_LIST_OF_DATA_TABLES, IntegratedSystemInfo
)/sizeof(USHORT));
union igp_info *igp_info;
u8 frev, crev;
u16 data_offset;
int i;

if (atom_parse_data_header(mode_info->atom_context, index, NULL((void *)0),
		   &frev, &crev, &data_offset)) {
igp_info = (union igp_info *)(mode_info->atom_context->bios +
			      data_offset);

if (crev != 8) {
	DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev)__drm_err("Unsupported IGP table: %d %d\n", frev, crev);
	return -EINVAL22;
}
pi->sys_info.bootup_sclk = le32_to_cpu(igp_info->info_8.ulBootUpEngineClock)((__uint32_t)(igp_info->info_8.ulBootUpEngineClock));
pi->sys_info.bootup_uma_clk = le32_to_cpu(igp_info->info_8.ulBootUpUMAClock)((__uint32_t)(igp_info->info_8.ulBootUpUMAClock));
pi->sys_info.bootup_nb_voltage_index =
	le16_to_cpu(igp_info->info_8.usBootUpNBVoltage)((__uint16_t)(igp_info->info_8.usBootUpNBVoltage));
if (igp_info->info_8.ucHtcTmpLmt == 0)
	pi->sys_info.htc_tmp_lmt = 203;
else
	pi->sys_info.htc_tmp_lmt = igp_info->info_8.ucHtcTmpLmt;
if (igp_info->info_8.ucHtcHystLmt == 0)
	pi->sys_info.htc_hyst_lmt = 5;
else
	pi->sys_info.htc_hyst_lmt = igp_info->info_8.ucHtcHystLmt;
if (pi->sys_info.htc_tmp_lmt <= pi->sys_info.htc_hyst_lmt) {
	DRM_ERROR("The htcTmpLmt should be larger than htcHystLmt.\n")__drm_err("The htcTmpLmt should be larger than htcHystLmt.\n"
);
}

if (le32_to_cpu(igp_info->info_8.ulSystemConfig)((__uint32_t)(igp_info->info_8.ulSystemConfig)) & (1 << 3))
	pi->sys_info.nb_dpm_enable = true1;
else
	pi->sys_info.nb_dpm_enable = false0;

for (i = 0; i < KV_NUM_NBPSTATES4; i++) {
	pi->sys_info.nbp_memory_clock[i] =
		le32_to_cpu(igp_info->info_8.ulNbpStateMemclkFreq[i])((__uint32_t)(igp_info->info_8.ulNbpStateMemclkFreq[i]));
	pi->sys_info.nbp_n_clock[i] =
		le32_to_cpu(igp_info->info_8.ulNbpStateNClkFreq[i])((__uint32_t)(igp_info->info_8.ulNbpStateNClkFreq[i]));
}
if (le32_to_cpu(igp_info->info_8.ulGPUCapInfo)((__uint32_t)(igp_info->info_8.ulGPUCapInfo)) &
    SYS_INFO_GPUCAPS__ENABEL_DFS_BYPASS0x10)
	pi->caps_enable_dfs_bypass = true1;

sumo_construct_sclk_voltage_mapping_table(rdev,
					  &pi->sys_info.sclk_voltage_mapping_table,
					  igp_info->info_8.sAvail_SCLK);

sumo_construct_vid_mapping_table(rdev,
				 &pi->sys_info.vid_mapping_table,
				 igp_info->info_8.sAvail_SCLK);

kv_construct_max_power_limits_table(rdev,
				    &rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac);
}
return 0;
2348}

2350union power_info {
struct _ATOM_POWERPLAY_INFO info;
struct _ATOM_POWERPLAY_INFO_V2 info_2;
struct _ATOM_POWERPLAY_INFO_V3 info_3;
struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
2357};

2359union pplib_clock_info {
struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
2364};

2366union pplib_power_state {
struct _ATOM_PPLIB_STATE v1;
struct _ATOM_PPLIB_STATE_V2 v2;
2369};

2371static void kv_patch_boot_state(struct radeon_device *rdev,
		struct kv_ps *ps)
2373{
struct kv_power_info *pi = kv_get_pi(rdev);

ps->num_levels = 1;
ps->levels[0] = pi->boot_pl;
2378}

2380static void kv_parse_pplib_non_clock_info(struct radeon_device *rdev,
			  struct radeon_ps *rps,
			  struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info,
			  u8 table_rev)
2384{
struct kv_ps *ps = kv_get_ps(rps);

rps->caps = le32_to_cpu(non_clock_info->ulCapsAndSettings)((__uint32_t)(non_clock_info->ulCapsAndSettings));
rps->class = le16_to_cpu(non_clock_info->usClassification)((__uint16_t)(non_clock_info->usClassification));
rps->class2 = le16_to_cpu(non_clock_info->usClassification2)((__uint16_t)(non_clock_info->usClassification2));

if (ATOM_PPLIB_NONCLOCKINFO_VER112 < table_rev) {
rps->vclk = le32_to_cpu(non_clock_info->ulVCLK)((__uint32_t)(non_clock_info->ulVCLK));
rps->dclk = le32_to_cpu(non_clock_info->ulDCLK)((__uint32_t)(non_clock_info->ulDCLK));
} else {
rps->vclk = 0;
rps->dclk = 0;
}

if (rps->class & ATOM_PPLIB_CLASSIFICATION_BOOT0x0008) {
rdev->pm.dpm.boot_ps = rps;
kv_patch_boot_state(rdev, ps);
}
if (rps->class & ATOM_PPLIB_CLASSIFICATION_UVDSTATE0x0400)
rdev->pm.dpm.uvd_ps = rps;
2405}

2407static void kv_parse_pplib_clock_info(struct radeon_device *rdev,
		      struct radeon_ps *rps, int index,
			union pplib_clock_info *clock_info)
2410{
struct kv_power_info *pi = kv_get_pi(rdev);
struct kv_ps *ps = kv_get_ps(rps);
struct kv_pl *pl = &ps->levels[index];
u32 sclk;

sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow)((__uint16_t)(clock_info->sumo.usEngineClockLow));
sclk |= clock_info->sumo.ucEngineClockHigh << 16;
pl->sclk = sclk;
pl->vddc_index = clock_info->sumo.vddcIndex;

ps->num_levels = index + 1;

if (pi->caps_sclk_ds) {
pl->ds_divider_index = 5;
pl->ss_divider_index = 5;
}
2427}

2429static int kv_parse_power_table(struct radeon_device *rdev)
2430{
struct radeon_mode_info *mode_info = &rdev->mode_info;
struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
union pplib_power_state *power_state;
int i, j, k, non_clock_array_index, clock_array_index;
union pplib_clock_info *clock_info;
struct _StateArray *state_array;
struct _ClockInfoArray *clock_info_array;
struct _NonClockInfoArray *non_clock_info_array;
union power_info *power_info;
int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo)(__builtin_offsetof(ATOM_MASTER_LIST_OF_DATA_TABLES, PowerPlayInfo
)/sizeof(USHORT));
u16 data_offset;
u8 frev, crev;
u8 *power_state_offset;
struct kv_ps *ps;

if (!atom_parse_data_header(mode_info->atom_context, index, NULL((void *)0),
		   &frev, &crev, &data_offset))
return -EINVAL22;
power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);

state_array = (struct _StateArray *)
(mode_info->atom_context->bios + data_offset +
 le16_to_cpu(power_info->pplib.usStateArrayOffset)((__uint16_t)(power_info->pplib.usStateArrayOffset)));
clock_info_array = (struct _ClockInfoArray *)
(mode_info->atom_context->bios + data_offset +
 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset)((__uint16_t)(power_info->pplib.usClockInfoArrayOffset)));
non_clock_info_array = (struct _NonClockInfoArray *)
(mode_info->atom_context->bios + data_offset +
 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)((__uint16_t)(power_info->pplib.usNonClockInfoArrayOffset)
));

rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries,
		  sizeof(struct radeon_ps),
		  GFP_KERNEL(0x0001 | 0x0004));
if (!rdev->pm.dpm.ps)
return -ENOMEM12;
power_state_offset = (u8 *)state_array->states;
for (i = 0; i < state_array->ucNumEntries; i++) {
u8 *idx;
power_state = (union pplib_power_state *)power_state_offset;
non_clock_array_index = power_state->v2.nonClockInfoIndex;
non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
	&non_clock_info_array->nonClockInfo[non_clock_array_index];
if (!rdev->pm.power_state[i].clock_info)
	return -EINVAL22;
ps = kzalloc(sizeof(struct kv_ps), GFP_KERNEL(0x0001 | 0x0004));
if (ps == NULL((void *)0)) {
	kfree(rdev->pm.dpm.ps);
	return -ENOMEM12;
}
rdev->pm.dpm.ps[i].ps_priv = ps;
k = 0;
idx = (u8 *)&power_state->v2.clockInfoIndex[0];
for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
	clock_array_index = idx[j];
	if (clock_array_index >= clock_info_array->ucNumEntries)
		continue;
	if (k >= SUMO_MAX_HARDWARE_POWERLEVELS5)
		break;
	clock_info = (union pplib_clock_info *)
		((u8 *)&clock_info_array->clockInfo[0] +
		 (clock_array_index * clock_info_array->ucEntrySize));
	kv_parse_pplib_clock_info(rdev,
				  &rdev->pm.dpm.ps[i], k,
				  clock_info);
	k++;
}
kv_parse_pplib_non_clock_info(rdev, &rdev->pm.dpm.ps[i],
			      non_clock_info,
			      non_clock_info_array->ucEntrySize);
power_state_offset += 2 + power_state->v2.ucNumDPMLevels;
}
rdev->pm.dpm.num_ps = state_array->ucNumEntries;

/* fill in the vce power states */
for (i = 0; i < RADEON_MAX_VCE_LEVELS6; i++) {
u32 sclk;
clock_array_index = rdev->pm.dpm.vce_states[i].clk_idx;
clock_info = (union pplib_clock_info *)
	&clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow)((__uint16_t)(clock_info->sumo.usEngineClockLow));
sclk |= clock_info->sumo.ucEngineClockHigh << 16;
rdev->pm.dpm.vce_states[i].sclk = sclk;
rdev->pm.dpm.vce_states[i].mclk = 0;
}

return 0;
2517}

2519int kv_dpm_init(struct radeon_device *rdev)
2520{
struct kv_power_info *pi;
int ret, i;

pi = kzalloc(sizeof(struct kv_power_info), GFP_KERNEL(0x0001 | 0x0004));
if (pi == NULL((void *)0))
return -ENOMEM12;
rdev->pm.dpm.priv = pi;

ret = r600_get_platform_caps(rdev);
if (ret)
return ret;

ret = r600_parse_extended_power_table(rdev);
if (ret)
return ret;

for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS5; i++)
pi->at[i] = TRINITY_AT_DFLT30;

pi->sram_end = SMC_RAM_END0x40000;

/* Enabling nb dpm on an asrock system prevents dpm from working */
if (rdev->pdev->subsystem_vendor == 0x1849)
pi->enable_nb_dpm = false0;
else
pi->enable_nb_dpm = true1;

pi->caps_power_containment = true1;
pi->caps_cac = true1;
pi->enable_didt = false0;
if (pi->enable_didt) {
pi->caps_sq_ramping = true1;
pi->caps_db_ramping = true1;
pi->caps_td_ramping = true1;
pi->caps_tcp_ramping = true1;
}

pi->caps_sclk_ds = true1;
pi->enable_auto_thermal_throttling = true1;
pi->disable_nb_ps3_in_battery = false0;
if (radeon_bapm == -1) {
/* only enable bapm on KB, ML by default */
if (rdev->family == CHIP_KABINI || rdev->family == CHIP_MULLINS)
	pi->bapm_enable = true1;
else
	pi->bapm_enable = false0;
} else if (radeon_bapm == 0) {
pi->bapm_enable = false0;
} else {
pi->bapm_enable = true1;
}
pi->voltage_drop_t = 0;
pi->caps_sclk_throttle_low_notification = false0;
pi->caps_fps = false0; /* true? */
pi->caps_uvd_pg = true1;
pi->caps_uvd_dpm = true1;
pi->caps_vce_pg = false0; /* XXX true */
pi->caps_samu_pg = false0;
pi->caps_acp_pg = false0;
pi->caps_stable_p_state = false0;

ret = kv_parse_sys_info_table(rdev);
if (ret)
return ret;

kv_patch_voltage_values(rdev);
kv_construct_boot_state(rdev);

ret = kv_parse_power_table(rdev);
if (ret)
return ret;

pi->enable_dpm = true1;

return 0;
2596}

2598void kv_dpm_debugfs_print_current_performance_level(struct radeon_device *rdev,
				    struct seq_file *m)
2600{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 current_index =
(RREG32_SMC(TARGET_AND_CURRENT_PROFILE_INDEX)tn_smc_rreg(rdev, (0xC0200014)) & CURR_SCLK_INDEX_MASK(0x1f << 16)) >>
CURR_SCLK_INDEX_SHIFT16;
u32 sclk, tmp;
u16 vddc;

if (current_index >= SMU__NUM_SCLK_DPM_STATE8) {
seq_printf(m, "invalid dpm profile %d\n", current_index);
} else {
sclk = be32_to_cpu(pi->graphics_level[current_index].SclkFrequency)(__uint32_t)(__builtin_constant_p(pi->graphics_level[current_index
].SclkFrequency) ? (__uint32_t)(((__uint32_t)(pi->graphics_level
[current_index].SclkFrequency) & 0xff) << 24 | ((__uint32_t
)(pi->graphics_level[current_index].SclkFrequency) & 0xff00
) << 8 | ((__uint32_t)(pi->graphics_level[current_index
].SclkFrequency) & 0xff0000) >> 8 | ((__uint32_t)(pi
->graphics_level[current_index].SclkFrequency) & 0xff000000
) >> 24) : __swap32md(pi->graphics_level[current_index
].SclkFrequency));
tmp = (RREG32_SMC(SMU_VOLTAGE_STATUS)tn_smc_rreg(rdev, (0xC0200094)) & SMU_VOLTAGE_CURRENT_LEVEL_MASK(0xff << 1)) >>
	SMU_VOLTAGE_CURRENT_LEVEL_SHIFT1;
vddc = kv_convert_8bit_index_to_voltage(rdev, (u16)tmp);
seq_printf(m, "uvd    %sabled\n", pi->uvd_power_gated ? "dis" : "en");
seq_printf(m, "vce    %sabled\n", pi->vce_power_gated ? "dis" : "en");
seq_printf(m, "power level %d    sclk: %u vddc: %u\n",
	   current_index, sclk, vddc);
}
2620}

2622u32 kv_dpm_get_current_sclk(struct radeon_device *rdev)
2623{
struct kv_power_info *pi = kv_get_pi(rdev);
u32 current_index =
(RREG32_SMC(TARGET_AND_CURRENT_PROFILE_INDEX)tn_smc_rreg(rdev, (0xC0200014)) & CURR_SCLK_INDEX_MASK(0x1f << 16)) >>
CURR_SCLK_INDEX_SHIFT16;
u32 sclk;

if (current_index >= SMU__NUM_SCLK_DPM_STATE8) {
return 0;
} else {
sclk = be32_to_cpu(pi->graphics_level[current_index].SclkFrequency)(__uint32_t)(__builtin_constant_p(pi->graphics_level[current_index
].SclkFrequency) ? (__uint32_t)(((__uint32_t)(pi->graphics_level
[current_index].SclkFrequency) & 0xff) << 24 | ((__uint32_t
)(pi->graphics_level[current_index].SclkFrequency) & 0xff00
) << 8 | ((__uint32_t)(pi->graphics_level[current_index
].SclkFrequency) & 0xff0000) >> 8 | ((__uint32_t)(pi
->graphics_level[current_index].SclkFrequency) & 0xff000000
) >> 24) : __swap32md(pi->graphics_level[current_index
].SclkFrequency));
return sclk;
}
2636}

2638u32 kv_dpm_get_current_mclk(struct radeon_device *rdev)
2639{
struct kv_power_info *pi = kv_get_pi(rdev);

return pi->sys_info.bootup_uma_clk;
2643}

2645void kv_dpm_print_power_state(struct radeon_device *rdev,
	      struct radeon_ps *rps)
2647{
int i;
struct kv_ps *ps = kv_get_ps(rps);

r600_dpm_print_class_info(rps->class, rps->class2);
r600_dpm_print_cap_info(rps->caps);
printk("\tuvd    vclk: %d dclk: %d\n", rps->vclk, rps->dclk);
for (i = 0; i < ps->num_levels; i++) {
struct kv_pl *pl = &ps->levels[i];
printk("\t\tpower level %d    sclk: %u vddc: %u\n",
       i, pl->sclk,
       kv_convert_8bit_index_to_voltage(rdev, pl->vddc_index));
}
r600_dpm_print_ps_status(rdev, rps);
2661}

2663void kv_dpm_fini(struct radeon_device *rdev)
2664{
int i;

for (i = 0; i < rdev->pm.dpm.num_ps; i++) {
kfree(rdev->pm.dpm.ps[i].ps_priv);
}
kfree(rdev->pm.dpm.ps);
kfree(rdev->pm.dpm.priv);
r600_free_extended_power_table(rdev);
2673}

2675void kv_dpm_display_configuration_changed(struct radeon_device *rdev)
2676{

2678}

2680u32 kv_dpm_get_sclk(struct radeon_device *rdev, bool_Bool low)
2681{
struct kv_power_info *pi = kv_get_pi(rdev);
struct kv_ps *requested_state = kv_get_ps(&pi->requested_rps);

if (low)
return requested_state->levels[0].sclk;
else
return requested_state->levels[requested_state->num_levels - 1].sclk;
2689}

2691u32 kv_dpm_get_mclk(struct radeon_device *rdev, bool_Bool low)
2692{
struct kv_power_info *pi = kv_get_pi(rdev);

return pi->sys_info.bootup_uma_clk;
2696}
