UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

drm/amd/powerplay: fix Smatch static checker warnings with indenting (v2) 

v2: AGD: rebase on upstream

Signed-off-by: Rex Zhu <Rex.Zhu@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Reviewed-by: Ken Wang  <Qingqing.Wang@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Rex Zhu 2016-01-06 16:38:48 +08:00 committed by Alex Deucher
parent 53d3de140b
commit 75ac63dbc3
6 changed files with 298 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
View File

@ -807,7 +807,7 @@ void amdgpu_pm_compute_clocks(struct amdgpu_device *adev)
struct amdgpu_ring *ring = adev->rings[i]; struct amdgpu_ring *ring = adev->rings[i];
if (ring && ring->ready) if (ring && ring->ready)
amdgpu_fence_wait_empty(ring); amdgpu_fence_wait_empty(ring);
} }
mutex_unlock(&adev->ring_lock); mutex_unlock(&adev->ring_lock);
amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE, NULL, NULL); amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE, NULL, NULL);

51
drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
View File

@ -941,8 +941,9 @@ static int fiji_trim_voltage_table(struct pp_hwmgr *hwmgr,
memcpy(vol_table, table, sizeof(struct pp_atomctrl_voltage_table)); memcpy(vol_table, table, sizeof(struct pp_atomctrl_voltage_table));
kfree(table); kfree(table);
return 0; return 0;
} }
static int fiji_get_svi2_mvdd_voltage_table(struct pp_hwmgr *hwmgr, static int fiji_get_svi2_mvdd_voltage_table(struct pp_hwmgr *hwmgr,
phm_ppt_v1_clock_voltage_dependency_table *dep_table) phm_ppt_v1_clock_voltage_dependency_table *dep_table)
{ {
@ -1112,7 +1113,7 @@ static int fiji_construct_voltage_tables(struct pp_hwmgr *hwmgr)
fiji_trim_voltage_table_to_fit_state_table(hwmgr, fiji_trim_voltage_table_to_fit_state_table(hwmgr,
SMU73_MAX_LEVELS_MVDD, &(data->mvdd_voltage_table))); SMU73_MAX_LEVELS_MVDD, &(data->mvdd_voltage_table)));
return 0; return 0;
} }
static int fiji_initialize_mc_reg_table(struct pp_hwmgr *hwmgr) static int fiji_initialize_mc_reg_table(struct pp_hwmgr *hwmgr)
@ -1158,7 +1159,7 @@ static int fiji_program_static_screen_threshold_parameters(
CG_STATIC_SCREEN_PARAMETER, STATIC_SCREEN_THRESHOLD, CG_STATIC_SCREEN_PARAMETER, STATIC_SCREEN_THRESHOLD,
data->static_screen_threshold); data->static_screen_threshold);
return 0; return 0;
} }
/** /**
@ -1295,7 +1296,7 @@ static int fiji_process_firmware_header(struct pp_hwmgr *hwmgr)
error |= (0 != result); error |= (0 != result);
return error ? -1 : 0; return error ? -1 : 0;
} }
/* Copy one arb setting to another and then switch the active set. /* Copy one arb setting to another and then switch the active set.
@ -1339,12 +1340,12 @@ static int fiji_copy_and_switch_arb_sets(struct pp_hwmgr *hwmgr,
return -EINVAL; return -EINVAL;
} }
mc_cg_config = cgs_read_register(hwmgr->device, mmMC_CG_CONFIG); mc_cg_config = cgs_read_register(hwmgr->device, mmMC_CG_CONFIG);
mc_cg_config |= 0x0000000F; mc_cg_config |= 0x0000000F;
cgs_write_register(hwmgr->device, mmMC_CG_CONFIG, mc_cg_config); cgs_write_register(hwmgr->device, mmMC_CG_CONFIG, mc_cg_config);
PHM_WRITE_FIELD(hwmgr->device, MC_ARB_CG, CG_ARB_REQ, arb_dest); PHM_WRITE_FIELD(hwmgr->device, MC_ARB_CG, CG_ARB_REQ, arb_dest);
return 0; return 0;
} }
/** /**
@ -1927,17 +1928,17 @@ static int fiji_populate_single_graphic_level(struct pp_hwmgr *hwmgr,
threshold = clock * data->fast_watermark_threshold / 100; threshold = clock * data->fast_watermark_threshold / 100;
/* /*
* TODO: get minimum clocks from dal configaration * TODO: get minimum clocks from dal configaration
* PECI_GetMinClockSettings(hwmgr->pPECI, &minClocks); * PECI_GetMinClockSettings(hwmgr->pPECI, &minClocks);
*/ */
/* data->DisplayTiming.minClockInSR = minClocks.engineClockInSR; */ /* data->DisplayTiming.minClockInSR = minClocks.engineClockInSR; */
/* get level->DeepSleepDivId /* get level->DeepSleepDivId
if (phm_cap_enabled(hwmgr->platformDescriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep)) if (phm_cap_enabled(hwmgr->platformDescriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep))
{ {
level->DeepSleepDivId = PhwFiji_GetSleepDividerIdFromClock(hwmgr, clock, minClocks.engineClockInSR); level->DeepSleepDivId = PhwFiji_GetSleepDividerIdFromClock(hwmgr, clock, minClocks.engineClockInSR);
} */ } */
/* Default to slow, highest DPM level will be /* Default to slow, highest DPM level will be
* set to PPSMC_DISPLAY_WATERMARK_LOW later. * set to PPSMC_DISPLAY_WATERMARK_LOW later.
@ -2756,7 +2757,7 @@ static int fiji_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
SclkFrequency) / 100); SclkFrequency) / 100);
if (fiji_clock_stretcher_lookup_table[stretch_amount2][0] < if (fiji_clock_stretcher_lookup_table[stretch_amount2][0] <
clock_freq_u16 && clock_freq_u16 &&
fiji_clock_stretcher_lookup_table[stretch_amount2][1] > fiji_clock_stretcher_lookup_table[stretch_amount2][1] >
clock_freq_u16) { clock_freq_u16) {
/* Program PWR_CKS_CNTL. CKS_USE_FOR_LOW_FREQ */ /* Program PWR_CKS_CNTL. CKS_USE_FOR_LOW_FREQ */
value |= (fiji_clock_stretcher_lookup_table[stretch_amount2][3]) << 16; value |= (fiji_clock_stretcher_lookup_table[stretch_amount2][3]) << 16;
@ -3172,9 +3173,9 @@ static int fiji_enable_sclk_mclk_dpm(struct pp_hwmgr *hwmgr)
/* enable SCLK dpm */ /* enable SCLK dpm */
if(!data->sclk_dpm_key_disabled) if(!data->sclk_dpm_key_disabled)
PP_ASSERT_WITH_CODE( PP_ASSERT_WITH_CODE(
(0 == smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_DPM_Enable)), (0 == smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_DPM_Enable)),
"Failed to enable SCLK DPM during DPM Start Function!", "Failed to enable SCLK DPM during DPM Start Function!",
return -1); return -1);
/* enable MCLK dpm */ /* enable MCLK dpm */
if(0 == data->mclk_dpm_key_disabled) { if(0 == data->mclk_dpm_key_disabled) {
@ -3320,7 +3321,7 @@ static int fiji_start_dpm(struct pp_hwmgr *hwmgr)
return -1); return -1);
} }
return 0; return 0;
} }
static void fiji_set_dpm_event_sources(struct pp_hwmgr *hwmgr, static void fiji_set_dpm_event_sources(struct pp_hwmgr *hwmgr,
@ -3378,7 +3379,7 @@ static int fiji_enable_auto_throttle_source(struct pp_hwmgr *hwmgr,
static int fiji_enable_thermal_auto_throttle(struct pp_hwmgr *hwmgr) static int fiji_enable_thermal_auto_throttle(struct pp_hwmgr *hwmgr)
{ {
return fiji_enable_auto_throttle_source(hwmgr, PHM_AutoThrottleSource_Thermal); return fiji_enable_auto_throttle_source(hwmgr, PHM_AutoThrottleSource_Thermal);
} }
static int fiji_enable_dpm_tasks(struct pp_hwmgr *hwmgr) static int fiji_enable_dpm_tasks(struct pp_hwmgr *hwmgr)

12
drivers/gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c
View File

@ -93,9 +93,9 @@ void fiji_initialize_power_tune_defaults(struct pp_hwmgr *hwmgr)
*/ */
static uint16_t scale_fan_gain_settings(uint16_t raw_setting) static uint16_t scale_fan_gain_settings(uint16_t raw_setting)
{ {
uint32_t tmp; uint32_t tmp;
tmp = raw_setting * 4096 / 100; tmp = raw_setting * 4096 / 100;
return (uint16_t)tmp; return (uint16_t)tmp;
} }
static void get_scl_sda_value(uint8_t line, uint8_t *scl, uint8_t* sda) static void get_scl_sda_value(uint8_t line, uint8_t *scl, uint8_t* sda)
@ -546,8 +546,8 @@ int fiji_power_control_set_level(struct pp_hwmgr *hwmgr)
* but message to be 8 bit fraction for messages * but message to be 8 bit fraction for messages
*/ */
target_tdp = ((100 + adjust_percent) * (int)(cac_table->usTDP * 256)) / 100; target_tdp = ((100 + adjust_percent) * (int)(cac_table->usTDP * 256)) / 100;
result = fiji_set_overdriver_target_tdp(hwmgr, (uint32_t)target_tdp); result = fiji_set_overdriver_target_tdp(hwmgr, (uint32_t)target_tdp);
} }
return result; return result;
} }

1
drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
View File

@ -317,4 +317,3 @@ int phm_set_cpu_power_state(struct pp_hwmgr *hwmgr)
return 0; return 0;
} }

527
drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
View File

@ -117,379 +117,380 @@ int GetRoundedValue(fInt); /* Incomplete function - Usef
*/ */
fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/ fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/
{ {
uint32_t i; uint32_t i;
bool bNegated = false; bool bNegated = false;
fInt fPositiveOne = ConvertToFraction(1); fInt fPositiveOne = ConvertToFraction(1);
fInt fZERO = ConvertToFraction(0); fInt fZERO = ConvertToFraction(0);
fInt lower_bound = Divide(78, 10000); fInt lower_bound = Divide(78, 10000);
fInt solution = fPositiveOne; /*Starting off with baseline of 1 */ fInt solution = fPositiveOne; /*Starting off with baseline of 1 */
fInt error_term; fInt error_term;
uint32_t k_array[11] = {55452, 27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78}; uint32_t k_array[11] = {55452, 27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78};
uint32_t expk_array[11] = {2560000, 160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078}; uint32_t expk_array[11] = {2560000, 160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078};
if (GreaterThan(fZERO, exponent)) { if (GreaterThan(fZERO, exponent)) {
exponent = fNegate(exponent); exponent = fNegate(exponent);
bNegated = true; bNegated = true;
} }
while (GreaterThan(exponent, lower_bound)) { while (GreaterThan(exponent, lower_bound)) {
for (i = 0; i < 11; i++) { for (i = 0; i < 11; i++) {
if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) { if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) {
exponent = fSubtract(exponent, GetScaledFraction(k_array[i], 10000)); exponent = fSubtract(exponent, GetScaledFraction(k_array[i], 10000));
solution = fMultiply(solution, GetScaledFraction(expk_array[i], 10000)); solution = fMultiply(solution, GetScaledFraction(expk_array[i], 10000));
} }
} }
} }
error_term = fAdd(fPositiveOne, exponent); error_term = fAdd(fPositiveOne, exponent);
solution = fMultiply(solution, error_term); solution = fMultiply(solution, error_term);
if (bNegated) if (bNegated)
solution = fDivide(fPositiveOne, solution); solution = fDivide(fPositiveOne, solution);
return solution; return solution;
} }
fInt fNaturalLog(fInt value) fInt fNaturalLog(fInt value)
{ {
uint32_t i; uint32_t i;
fInt upper_bound = Divide(8, 1000); fInt upper_bound = Divide(8, 1000);
fInt fNegativeOne = ConvertToFraction(-1); fInt fNegativeOne = ConvertToFraction(-1);
fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */ fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */
fInt error_term; fInt error_term;
uint32_t k_array[10] = {160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078}; uint32_t k_array[10] = {160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078};
uint32_t logk_array[10] = {27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78}; uint32_t logk_array[10] = {27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78};
while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) { while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) {
for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) { if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) {
value = fDivide(value, GetScaledFraction(k_array[i], 10000)); value = fDivide(value, GetScaledFraction(k_array[i], 10000));
solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000)); solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000));
} }
} }
} }
error_term = fAdd(fNegativeOne, value); error_term = fAdd(fNegativeOne, value);
return (fAdd(solution, error_term)); return (fAdd(solution, error_term));
} }
fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength) fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength)
{ {
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fInt f_decoded_value; fInt f_decoded_value;
f_decoded_value = fDivide(f_fuse_value, f_bit_max_value); f_decoded_value = fDivide(f_fuse_value, f_bit_max_value);
f_decoded_value = fMultiply(f_decoded_value, f_range); f_decoded_value = fMultiply(f_decoded_value, f_range);
f_decoded_value = fAdd(f_decoded_value, f_min); f_decoded_value = fAdd(f_decoded_value, f_min);
return f_decoded_value; return f_decoded_value;
} }
fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength) fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength)
{ {
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fInt f_CONSTANT_NEG13 = ConvertToFraction(-13); fInt f_CONSTANT_NEG13 = ConvertToFraction(-13);
fInt f_CONSTANT1 = ConvertToFraction(1); fInt f_CONSTANT1 = ConvertToFraction(1);
fInt f_decoded_value; fInt f_decoded_value;
f_decoded_value = fSubtract(fDivide(f_bit_max_value, f_fuse_value), f_CONSTANT1); f_decoded_value = fSubtract(fDivide(f_bit_max_value, f_fuse_value), f_CONSTANT1);
f_decoded_value = fNaturalLog(f_decoded_value); f_decoded_value = fNaturalLog(f_decoded_value);
f_decoded_value = fMultiply(f_decoded_value, fDivide(f_range, f_CONSTANT_NEG13)); f_decoded_value = fMultiply(f_decoded_value, fDivide(f_range, f_CONSTANT_NEG13));
f_decoded_value = fAdd(f_decoded_value, f_average); f_decoded_value = fAdd(f_decoded_value, f_average);
return f_decoded_value; return f_decoded_value;
} }
fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength) fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength)
{ {
fInt fLeakage; fInt fLeakage;
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse)); fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse));
fLeakage = fDivide(fLeakage, f_bit_max_value); fLeakage = fDivide(fLeakage, f_bit_max_value);
fLeakage = fExponential(fLeakage); fLeakage = fExponential(fLeakage);
fLeakage = fMultiply(fLeakage, f_min); fLeakage = fMultiply(fLeakage, f_min);
return fLeakage; return fLeakage;
} }
fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */ fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */
{ {
fInt temp; fInt temp;
if (X <= MAX) if (X <= MAX)
temp.full = (X << SHIFT_AMOUNT); temp.full = (X << SHIFT_AMOUNT);
else else
temp.full = 0; temp.full = 0;
return temp; return temp;
} }
fInt fNegate(fInt X) fInt fNegate(fInt X)
{ {
fInt CONSTANT_NEGONE = ConvertToFraction(-1); fInt CONSTANT_NEGONE = ConvertToFraction(-1);
return (fMultiply(X, CONSTANT_NEGONE)); return (fMultiply(X, CONSTANT_NEGONE));
} }
fInt Convert_ULONG_ToFraction(uint32_t X) fInt Convert_ULONG_ToFraction(uint32_t X)
{ {
fInt temp; fInt temp;
if (X <= MAX) if (X <= MAX)
temp.full = (X << SHIFT_AMOUNT); temp.full = (X << SHIFT_AMOUNT);
else else
temp.full = 0; temp.full = 0;
return temp; return temp;
} }
fInt GetScaledFraction(int X, int factor) fInt GetScaledFraction(int X, int factor)
{ {
int times_shifted, factor_shifted; int times_shifted, factor_shifted;
bool bNEGATED; bool bNEGATED;
fInt fValue; fInt fValue;
times_shifted = 0; times_shifted = 0;
factor_shifted = 0; factor_shifted = 0;
bNEGATED = false; bNEGATED = false;
if (X < 0) { if (X < 0) {
X = -1*X; X = -1*X;
bNEGATED = true; bNEGATED = true;
} }
if (factor < 0) { if (factor < 0) {
factor = -1*factor; factor = -1*factor;
bNEGATED = !bNEGATED; /*If bNEGATED = true due to X < 0, this will cover the case of negative cancelling negative */
}
bNEGATED = !bNEGATED; /*If bNEGATED = true due to X < 0, this will cover the case of negative cancelling negative */ if ((X > MAX) || factor > MAX) {
} if ((X/factor) <= MAX) {
while (X > MAX) {
X = X >> 1;
times_shifted++;
}
if ((X > MAX) || factor > MAX) { while (factor > MAX) {
if ((X/factor) <= MAX) { factor = factor >> 1;
while (X > MAX) { factor_shifted++;
X = X >> 1; }
times_shifted++; } else {
} fValue.full = 0;
return fValue;
}
}
while (factor > MAX) { if (factor == 1)
factor = factor >> 1; return (ConvertToFraction(X));
factor_shifted++;
}
} else {
fValue.full = 0;
return fValue;
}
}
if (factor == 1) fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor));
return (ConvertToFraction(X));
fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor)); fValue.full = fValue.full << times_shifted;
fValue.full = fValue.full >> factor_shifted;
fValue.full = fValue.full << times_shifted; return fValue;
fValue.full = fValue.full >> factor_shifted;
return fValue;
} }
/* Addition using two fInts */ /* Addition using two fInts */
fInt fAdd (fInt X, fInt Y) fInt fAdd (fInt X, fInt Y)
{ {
fInt Sum; fInt Sum;
Sum.full = X.full + Y.full; Sum.full = X.full + Y.full;
return Sum; return Sum;
} }
/* Addition using two fInts */ /* Addition using two fInts */
fInt fSubtract (fInt X, fInt Y) fInt fSubtract (fInt X, fInt Y)
{ {
fInt Difference; fInt Difference;
Difference.full = X.full - Y.full; Difference.full = X.full - Y.full;
return Difference; return Difference;
} }
bool Equal(fInt A, fInt B) bool Equal(fInt A, fInt B)
{ {
if (A.full == B.full) if (A.full == B.full)
return true; return true;
else else
return false; return false;
} }
bool GreaterThan(fInt A, fInt B) bool GreaterThan(fInt A, fInt B)
{ {
if (A.full > B.full) if (A.full > B.full)
return true; return true;
else else
return false; return false;
} }
fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */ fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */
{ {
fInt Product; fInt Product;
int64_t tempProduct; int64_t tempProduct;
bool X_LessThanOne, Y_LessThanOne; bool X_LessThanOne, Y_LessThanOne;
X_LessThanOne = (X.partial.real == 0 && X.partial.decimal != 0 && X.full >= 0); X_LessThanOne = (X.partial.real == 0 && X.partial.decimal != 0 && X.full >= 0);
Y_LessThanOne = (Y.partial.real == 0 && Y.partial.decimal != 0 && Y.full >= 0); Y_LessThanOne = (Y.partial.real == 0 && Y.partial.decimal != 0 && Y.full >= 0);
/*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/ /*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/
/* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION /* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION
if (X_LessThanOne && Y_LessThanOne) { if (X_LessThanOne && Y_LessThanOne) {
Product.full = X.full * Y.full; Product.full = X.full * Y.full;
return Product return Product
}*/ }*/
tempProduct = ((int64_t)X.full) * ((int64_t)Y.full); /*Q(16,16)*Q(16,16) = Q(32, 32) - Might become a negative number! */ tempProduct = ((int64_t)X.full) * ((int64_t)Y.full); /*Q(16,16)*Q(16,16) = Q(32, 32) - Might become a negative number! */
tempProduct = tempProduct >> 16; /*Remove lagging 16 bits - Will lose some precision from decimal; */ tempProduct = tempProduct >> 16; /*Remove lagging 16 bits - Will lose some precision from decimal; */
Product.full = (int)tempProduct; /*The int64_t will lose the leading 16 bits that were part of the integer portion */ Product.full = (int)tempProduct; /*The int64_t will lose the leading 16 bits that were part of the integer portion */
return Product; return Product;
} }
fInt fDivide (fInt X, fInt Y) fInt fDivide (fInt X, fInt Y)
{ {
fInt fZERO, fQuotient; fInt fZERO, fQuotient;
int64_t longlongX, longlongY; int64_t longlongX, longlongY;
fZERO = ConvertToFraction(0); fZERO = ConvertToFraction(0);
if (Equal(Y, fZERO)) if (Equal(Y, fZERO))
return fZERO; return fZERO;
longlongX = (int64_t)X.full; longlongX = (int64_t)X.full;
longlongY = (int64_t)Y.full; longlongY = (int64_t)Y.full;
longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */ longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */
div64_s64(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */ div64_s64(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */
fQuotient.full = (int)longlongX; fQuotient.full = (int)longlongX;
return fQuotient; return fQuotient;
} }
int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/ int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/
{ {
fInt fullNumber, scaledDecimal, scaledReal; fInt fullNumber, scaledDecimal, scaledReal;
scaledReal.full = GetReal(A) * uPow(10, PRECISION-1); /* DOUBLE CHECK THISSSS!!! */ scaledReal.full = GetReal(A) * uPow(10, PRECISION-1); /* DOUBLE CHECK THISSSS!!! */
scaledDecimal.full = uGetScaledDecimal(A); scaledDecimal.full = uGetScaledDecimal(A);
fullNumber = fAdd(scaledDecimal,scaledReal); fullNumber = fAdd(scaledDecimal,scaledReal);
return fullNumber.full; return fullNumber.full;
} }
fInt fGetSquare(fInt A) fInt fGetSquare(fInt A)
{ {
return fMultiply(A,A); return fMultiply(A,A);
} }
/* x_new = x_old - (x_old^2 - C) / (2 * x_old) */ /* x_new = x_old - (x_old^2 - C) / (2 * x_old) */
fInt fSqrt(fInt num) fInt fSqrt(fInt num)
{ {
fInt F_divide_Fprime, Fprime; fInt F_divide_Fprime, Fprime;
fInt test; fInt test;
fInt twoShifted; fInt twoShifted;
int seed, counter, error; int seed, counter, error;
fInt x_new, x_old, C, y; fInt x_new, x_old, C, y;
fInt fZERO = ConvertToFraction(0); fInt fZERO = ConvertToFraction(0);
/* (0 > num) is the same as (num < 0), i.e., num is negative */
if (GreaterThan(fZERO, num) || Equal(fZERO, num))
return fZERO;
C = num; /* (0 > num) is the same as (num < 0), i.e., num is negative */
if (num.partial.real > 3000) if (GreaterThan(fZERO, num) || Equal(fZERO, num))
seed = 60; return fZERO;
else if (num.partial.real > 1000)
seed = 30;
else if (num.partial.real > 100)
seed = 10;
else
seed = 2;
counter = 0; C = num;
if (Equal(num, fZERO)) /*Square Root of Zero is zero */ if (num.partial.real > 3000)
return fZERO; seed = 60;
else if (num.partial.real > 1000)
seed = 30;
else if (num.partial.real > 100)
seed = 10;
else
seed = 2;
twoShifted = ConvertToFraction(2); counter = 0;
x_new = ConvertToFraction(seed);
do { if (Equal(num, fZERO)) /*Square Root of Zero is zero */
counter++; return fZERO;
x_old.full = x_new.full; twoShifted = ConvertToFraction(2);
x_new = ConvertToFraction(seed);
test = fGetSquare(x_old); /*1.75*1.75 is reverting back to 1 when shifted down */ do {
y = fSubtract(test, C); /*y = f(x) = x^2 - C; */ counter++;
Fprime = fMultiply(twoShifted, x_old); x_old.full = x_new.full;
F_divide_Fprime = fDivide(y, Fprime);
x_new = fSubtract(x_old, F_divide_Fprime); test = fGetSquare(x_old); /*1.75*1.75 is reverting back to 1 when shifted down */
y = fSubtract(test, C); /*y = f(x) = x^2 - C; */
error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old); Fprime = fMultiply(twoShifted, x_old);
F_divide_Fprime = fDivide(y, Fprime);
if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/ x_new = fSubtract(x_old, F_divide_Fprime);
return x_new;
} while (uAbs(error) > 0); error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old);
return (x_new); if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/
return x_new;
} while (uAbs(error) > 0);
return (x_new);
} }
void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[]) void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
{ {
fInt* pRoots = &Roots[0]; fInt *pRoots = &Roots[0];
fInt temp, root_first, root_second; fInt temp, root_first, root_second;
fInt f_CONSTANT10, f_CONSTANT100; fInt f_CONSTANT10, f_CONSTANT100;
f_CONSTANT100 = ConvertToFraction(100); f_CONSTANT100 = ConvertToFraction(100);
f_CONSTANT10 = ConvertToFraction(10); f_CONSTANT10 = ConvertToFraction(10);
while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) { while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) {
A = fDivide(A, f_CONSTANT10); A = fDivide(A, f_CONSTANT10);
B = fDivide(B, f_CONSTANT10); B = fDivide(B, f_CONSTANT10);
C = fDivide(C, f_CONSTANT10); C = fDivide(C, f_CONSTANT10);
} }
temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */ temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */
temp = fMultiply(temp, C); /* root = 4*A*C */ temp = fMultiply(temp, C); /* root = 4*A*C */
temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */ temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */
temp = fSqrt(temp); /*root = Sqrt (b^2 - 4AC); */ temp = fSqrt(temp); /*root = Sqrt (b^2 - 4AC); */
root_first = fSubtract(fNegate(B), temp); /* b - Sqrt(b^2 - 4AC) */ root_first = fSubtract(fNegate(B), temp); /* b - Sqrt(b^2 - 4AC) */
root_second = fAdd(fNegate(B), temp); /* b + Sqrt(b^2 - 4AC) */ root_second = fAdd(fNegate(B), temp); /* b + Sqrt(b^2 - 4AC) */
root_first = fDivide(root_first, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */ root_first = fDivide(root_first, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */
root_first = fDivide(root_first, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ root_first = fDivide(root_first, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */
root_second = fDivide(root_second, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */ root_second = fDivide(root_second, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */
root_second = fDivide(root_second, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ root_second = fDivide(root_second, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */
*(pRoots + 0) = root_first; *(pRoots + 0) = root_first;
*(pRoots + 1) = root_second; *(pRoots + 1) = root_second;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
@ -500,61 +501,58 @@ void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
/* Addition using two normal ints - Temporary - Use only for testing purposes?. */ /* Addition using two normal ints - Temporary - Use only for testing purposes?. */
fInt Add (int X, int Y) fInt Add (int X, int Y)
{ {
fInt A, B, Sum; fInt A, B, Sum;
A.full = (X << SHIFT_AMOUNT); A.full = (X << SHIFT_AMOUNT);
B.full = (Y << SHIFT_AMOUNT); B.full = (Y << SHIFT_AMOUNT);
Sum.full = A.full + B.full; Sum.full = A.full + B.full;
return Sum; return Sum;
} }
/* Conversion Functions */ /* Conversion Functions */
int GetReal (fInt A) int GetReal (fInt A)
{ {
return (A.full >> SHIFT_AMOUNT); return (A.full >> SHIFT_AMOUNT);
} }
/* Temporarily Disabled */ /* Temporarily Disabled */
int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */ int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
{ {
/* ROUNDING TEMPORARLY DISABLED /* ROUNDING TEMPORARLY DISABLED
int temp = A.full; int temp = A.full;
int decimal_cutoff, decimal_mask = 0x000001FF;
decimal_cutoff = temp & decimal_mask;
if (decimal_cutoff > 0x147) {
temp += 673;
}*/
int decimal_cutoff, decimal_mask = 0x000001FF; return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */
decimal_cutoff = temp & decimal_mask;
if (decimal_cutoff > 0x147) {
temp += 673;
}*/
return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */
} }
fInt Multiply (int X, int Y) fInt Multiply (int X, int Y)
{ {
fInt A, B, Product; fInt A, B, Product;
A.full = X << SHIFT_AMOUNT; A.full = X << SHIFT_AMOUNT;
B.full = Y << SHIFT_AMOUNT; B.full = Y << SHIFT_AMOUNT;
Product = fMultiply(A, B); Product = fMultiply(A, B);
return Product; return Product;
} }
fInt Divide (int X, int Y) fInt Divide (int X, int Y)
{ {
fInt A, B, Quotient; fInt A, B, Quotient;
A.full = X << SHIFT_AMOUNT; A.full = X << SHIFT_AMOUNT;
B.full = Y << SHIFT_AMOUNT; B.full = Y << SHIFT_AMOUNT;
Quotient = fDivide(A, B); Quotient = fDivide(A, B);
return Quotient; return Quotient;
} }
int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */ int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */
@ -563,16 +561,13 @@ int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole intege
int i, scaledDecimal = 0, tmp = A.partial.decimal; int i, scaledDecimal = 0, tmp = A.partial.decimal;
for (i = 0; i < PRECISION; i++) { for (i = 0; i < PRECISION; i++) {
dec[i] = tmp / (1 << SHIFT_AMOUNT); dec[i] = tmp / (1 << SHIFT_AMOUNT);
tmp = tmp - ((1 << SHIFT_AMOUNT)*dec[i]);
tmp *= 10;
scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION - 1 -i);
}
tmp = tmp - ((1 << SHIFT_AMOUNT)*dec[i]); return scaledDecimal;
tmp *= 10;
scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION - 1 -i);
}
return scaledDecimal;
} }
int uPow(int base, int power) int uPow(int base, int power)
@ -601,17 +596,17 @@ int uAbs(int X)
fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term) fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term)
{ {
fInt solution; fInt solution;
solution = fDivide(A, fStepSize); solution = fDivide(A, fStepSize);
solution.partial.decimal = 0; /*All fractional digits changes to 0 */ solution.partial.decimal = 0; /*All fractional digits changes to 0 */
if (error_term) if (error_term)
solution.partial.real += 1; /*Error term of 1 added */ solution.partial.real += 1; /*Error term of 1 added */
solution = fMultiply(solution, fStepSize); solution = fMultiply(solution, fStepSize);
solution = fAdd(solution, fStepSize); solution = fAdd(solution, fStepSize);
return solution; return solution;
} }

8
drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c
View File

@ -228,9 +228,9 @@ int fiji_send_msg_to_smc(struct pp_smumgr *smumgr, uint16_t msg)
} }
cgs_write_register(smumgr->device, mmSMC_MESSAGE_0, msg); cgs_write_register(smumgr->device, mmSMC_MESSAGE_0, msg);
SMUM_WAIT_FIELD_UNEQUAL(smumgr, SMC_RESP_0, SMC_RESP, 0); SMUM_WAIT_FIELD_UNEQUAL(smumgr, SMC_RESP_0, SMC_RESP, 0);
return 0; return 0;
} }
/** /**
@ -557,7 +557,7 @@ static int fiji_request_smu_specific_fw_load(struct pp_smumgr *smumgr, uint32_t
/* For non-virtualization cases, /* For non-virtualization cases,
* SMU loads all FWs at once in fiji_request_smu_load_fw. * SMU loads all FWs at once in fiji_request_smu_load_fw.
*/ */
return 0; return 0;
} }
static int fiji_start_smu_in_protection_mode(struct pp_smumgr *smumgr) static int fiji_start_smu_in_protection_mode(struct pp_smumgr *smumgr)
@ -723,7 +723,7 @@ static int fiji_start_avfs_btc(struct pp_smumgr *smumgr)
/* clear reset */ /* clear reset */
cgs_write_register(smumgr->device, mmGRBM_SOFT_RESET, 0); cgs_write_register(smumgr->device, mmGRBM_SOFT_RESET, 0);
return result; return result;
} }
int fiji_setup_pm_fuse_for_avfs(struct pp_smumgr *smumgr) int fiji_setup_pm_fuse_for_avfs(struct pp_smumgr *smumgr)