diff options
Diffstat (limited to 'meta-amdfalconx86/recipes-kernel/linux/linux-yocto/1014-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch')
-rw-r--r-- | meta-amdfalconx86/recipes-kernel/linux/linux-yocto/1014-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch | 995 |
1 files changed, 995 insertions, 0 deletions
diff --git a/meta-amdfalconx86/recipes-kernel/linux/linux-yocto/1014-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch b/meta-amdfalconx86/recipes-kernel/linux/linux-yocto/1014-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch new file mode 100644 index 00000000..0f1acea3 --- /dev/null +++ b/meta-amdfalconx86/recipes-kernel/linux/linux-yocto/1014-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch @@ -0,0 +1,995 @@ +From 5c454b8916afeac864a67c18e1b7d3f5a3abaf0f Mon Sep 17 00:00:00 2001 +From: Rex Zhu <Rex.Zhu@amd.com> +Date: Wed, 6 Jan 2016 16:38:48 +0800 +Subject: [PATCH 1014/1050] drm/amd/powerplay: fix Smatch static checker + warnings with indenting + +Change-Id: Icc7db5f3c7baeae0dd3d95c257db9aed74cf8faa + +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> +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c | 2 +- + drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c | 51 +- + .../gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c | 12 +- + .../gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c | 1 - + drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 555 ++++++++++----------- + drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c | 8 +- + 6 files changed, 312 insertions(+), 317 deletions(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +index 3b78982..4386cba 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +@@ -807,7 +807,7 @@ void amdgpu_pm_compute_clocks(struct amdgpu_device *adev) + struct amdgpu_ring *ring = adev->rings[i]; + if (ring && ring->ready) + amdgpu_fence_wait_empty(ring); +- } ++ } + mutex_unlock(&adev->ring_lock); + + amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE, NULL, NULL); +diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c +index fec0789..8055bfc 100644 +--- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c ++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c +@@ -947,8 +947,9 @@ static int fiji_trim_voltage_table(struct pp_hwmgr *hwmgr, + memcpy(vol_table, table, sizeof(struct pp_atomctrl_voltage_table)); + kfree(table); + +- return 0; ++ return 0; + } ++ + static int fiji_get_svi2_mvdd_voltage_table(struct pp_hwmgr *hwmgr, + phm_ppt_v1_clock_voltage_dependency_table *dep_table) + { +@@ -1118,7 +1119,7 @@ static int fiji_construct_voltage_tables(struct pp_hwmgr *hwmgr) + fiji_trim_voltage_table_to_fit_state_table(hwmgr, + SMU73_MAX_LEVELS_MVDD, &(data->mvdd_voltage_table))); + +- return 0; ++ return 0; + } + + static int fiji_initialize_mc_reg_table(struct pp_hwmgr *hwmgr) +@@ -1164,7 +1165,7 @@ static int fiji_program_static_screen_threshold_parameters( + CG_STATIC_SCREEN_PARAMETER, STATIC_SCREEN_THRESHOLD, + data->static_screen_threshold); + +- return 0; ++ return 0; + } + + /** +@@ -1301,7 +1302,7 @@ static int fiji_process_firmware_header(struct pp_hwmgr *hwmgr) + + error |= (0 != result); + +- return error ? -1 : 0; ++ return error ? -1 : 0; + } + + /* Copy one arb setting to another and then switch the active set. +@@ -1345,12 +1346,12 @@ static int fiji_copy_and_switch_arb_sets(struct pp_hwmgr *hwmgr, + return -EINVAL; + } + +- mc_cg_config = cgs_read_register(hwmgr->device, mmMC_CG_CONFIG); +- mc_cg_config |= 0x0000000F; +- cgs_write_register(hwmgr->device, mmMC_CG_CONFIG, mc_cg_config); +- PHM_WRITE_FIELD(hwmgr->device, MC_ARB_CG, CG_ARB_REQ, arb_dest); ++ mc_cg_config = cgs_read_register(hwmgr->device, mmMC_CG_CONFIG); ++ mc_cg_config |= 0x0000000F; ++ cgs_write_register(hwmgr->device, mmMC_CG_CONFIG, mc_cg_config); ++ PHM_WRITE_FIELD(hwmgr->device, MC_ARB_CG, CG_ARB_REQ, arb_dest); + +- return 0; ++ return 0; + } + + /** +@@ -1933,17 +1934,17 @@ static int fiji_populate_single_graphic_level(struct pp_hwmgr *hwmgr, + + threshold = clock * data->fast_watermark_threshold / 100; + +- /* +- * TODO: get minimum clocks from dal configaration +- * PECI_GetMinClockSettings(hwmgr->pPECI, &minClocks); +- */ +- /* data->DisplayTiming.minClockInSR = minClocks.engineClockInSR; */ ++ /* ++ * TODO: get minimum clocks from dal configaration ++ * PECI_GetMinClockSettings(hwmgr->pPECI, &minClocks); ++ */ ++ /* data->DisplayTiming.minClockInSR = minClocks.engineClockInSR; */ + +- /* get level->DeepSleepDivId +- if (phm_cap_enabled(hwmgr->platformDescriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep)) +- { +- level->DeepSleepDivId = PhwFiji_GetSleepDividerIdFromClock(hwmgr, clock, minClocks.engineClockInSR); +- } */ ++ /* get level->DeepSleepDivId ++ if (phm_cap_enabled(hwmgr->platformDescriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep)) ++ { ++ level->DeepSleepDivId = PhwFiji_GetSleepDividerIdFromClock(hwmgr, clock, minClocks.engineClockInSR); ++ } */ + + /* Default to slow, highest DPM level will be + * set to PPSMC_DISPLAY_WATERMARK_LOW later. +@@ -2762,7 +2763,7 @@ static int fiji_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr) + SclkFrequency) / 100); + if (fiji_clock_stretcher_lookup_table[stretch_amount2][0] < + clock_freq_u16 && +- fiji_clock_stretcher_lookup_table[stretch_amount2][1] > ++ fiji_clock_stretcher_lookup_table[stretch_amount2][1] > + clock_freq_u16) { + /* Program PWR_CKS_CNTL. CKS_USE_FOR_LOW_FREQ */ + value |= (fiji_clock_stretcher_lookup_table[stretch_amount2][3]) << 16; +@@ -3178,9 +3179,9 @@ static int fiji_enable_sclk_mclk_dpm(struct pp_hwmgr *hwmgr) + /* enable SCLK dpm */ + if(!data->sclk_dpm_key_disabled) + PP_ASSERT_WITH_CODE( +- (0 == smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_DPM_Enable)), +- "Failed to enable SCLK DPM during DPM Start Function!", +- return -1); ++ (0 == smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_DPM_Enable)), ++ "Failed to enable SCLK DPM during DPM Start Function!", ++ return -1); + + /* enable MCLK dpm */ + if(0 == data->mclk_dpm_key_disabled) { +@@ -3326,7 +3327,7 @@ static int fiji_start_dpm(struct pp_hwmgr *hwmgr) + return -1); + } + +- return 0; ++ return 0; + } + + static void fiji_set_dpm_event_sources(struct pp_hwmgr *hwmgr, +@@ -3384,7 +3385,7 @@ static int fiji_enable_auto_throttle_source(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) +diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c +index f89c98f..6efcb2b 100644 +--- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c ++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_powertune.c +@@ -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) + { +- uint32_t tmp; +- tmp = raw_setting * 4096 / 100; +- return (uint16_t)tmp; ++ uint32_t tmp; ++ tmp = raw_setting * 4096 / 100; ++ return (uint16_t)tmp; + } + + 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 + */ + 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; + } +diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c +index 749895a..551b4bc 100644 +--- a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c ++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c +@@ -328,7 +328,6 @@ int phm_get_performance_level(struct pp_hwmgr *hwmgr, const struct pp_hw_power_s + + return hwmgr->hwmgr_func->get_performance_level(hwmgr, state, designation, index, level); + +- + } + + +diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h +index 42f2423..ed8a300 100644 +--- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h ++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h +@@ -117,379 +117,380 @@ int GetRoundedValue(fInt); /* Incomplete function - Usef + */ + fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/ + { +- uint32_t i; +- bool bNegated = false; ++ uint32_t i; ++ bool bNegated = false; + +- fInt fPositiveOne = ConvertToFraction(1); +- fInt fZERO = ConvertToFraction(0); ++ fInt fPositiveOne = ConvertToFraction(1); ++ fInt fZERO = ConvertToFraction(0); + +- fInt lower_bound = Divide(78, 10000); +- fInt solution = fPositiveOne; /*Starting off with baseline of 1 */ +- fInt error_term; ++ fInt lower_bound = Divide(78, 10000); ++ fInt solution = fPositiveOne; /*Starting off with baseline of 1 */ ++ fInt error_term; + +- 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 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}; + +- if (GreaterThan(fZERO, exponent)) { +- exponent = fNegate(exponent); +- bNegated = true; +- } ++ if (GreaterThan(fZERO, exponent)) { ++ exponent = fNegate(exponent); ++ bNegated = true; ++ } + +- while (GreaterThan(exponent, lower_bound)) { +- for (i = 0; i < 11; i++) { +- if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) { +- exponent = fSubtract(exponent, GetScaledFraction(k_array[i], 10000)); +- solution = fMultiply(solution, GetScaledFraction(expk_array[i], 10000)); +- } +- } +- } ++ while (GreaterThan(exponent, lower_bound)) { ++ for (i = 0; i < 11; i++) { ++ if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) { ++ exponent = fSubtract(exponent, GetScaledFraction(k_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) +- solution = fDivide(fPositiveOne, solution); ++ if (bNegated) ++ solution = fDivide(fPositiveOne, solution); + +- return solution; ++ return solution; + } + + fInt fNaturalLog(fInt value) + { +- uint32_t i; +- fInt upper_bound = Divide(8, 1000); +- fInt fNegativeOne = ConvertToFraction(-1); +- fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */ +- fInt error_term; +- +- 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}; +- +- while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) { +- for (i = 0; i < 10; i++) { +- if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) { +- value = fDivide(value, GetScaledFraction(k_array[i], 10000)); +- solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000)); +- } +- } +- } +- +- error_term = fAdd(fNegativeOne, value); +- +- return (fAdd(solution, error_term)); ++ uint32_t i; ++ fInt upper_bound = Divide(8, 1000); ++ fInt fNegativeOne = ConvertToFraction(-1); ++ fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */ ++ fInt error_term; ++ ++ 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}; ++ ++ while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) { ++ for (i = 0; i < 10; i++) { ++ if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) { ++ value = fDivide(value, GetScaledFraction(k_array[i], 10000)); ++ solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000)); ++ } ++ } ++ } ++ ++ error_term = fAdd(fNegativeOne, value); ++ ++ return (fAdd(solution, error_term)); + } + + 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_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); ++ fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); ++ 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 = fMultiply(f_decoded_value, f_range); +- f_decoded_value = fAdd(f_decoded_value, f_min); ++ f_decoded_value = fDivide(f_fuse_value, f_bit_max_value); ++ f_decoded_value = fMultiply(f_decoded_value, f_range); ++ 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 f_fuse_value = Convert_ULONG_ToFraction(fuse_value); +- fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); ++ fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); ++ fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); + +- fInt f_CONSTANT_NEG13 = ConvertToFraction(-13); +- fInt f_CONSTANT1 = ConvertToFraction(1); ++ fInt f_CONSTANT_NEG13 = ConvertToFraction(-13); ++ 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 = fNaturalLog(f_decoded_value); +- 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 = fSubtract(fDivide(f_bit_max_value, f_fuse_value), f_CONSTANT1); ++ f_decoded_value = fNaturalLog(f_decoded_value); ++ f_decoded_value = fMultiply(f_decoded_value, fDivide(f_range, f_CONSTANT_NEG13)); ++ 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 fLeakage; +- fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); ++ fInt fLeakage; ++ fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); + +- fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse)); +- fLeakage = fDivide(fLeakage, f_bit_max_value); +- fLeakage = fExponential(fLeakage); +- fLeakage = fMultiply(fLeakage, f_min); ++ fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse)); ++ fLeakage = fDivide(fLeakage, f_bit_max_value); ++ fLeakage = fExponential(fLeakage); ++ 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 temp; ++ fInt temp; + +- if (X <= MAX) +- temp.full = (X << SHIFT_AMOUNT); +- else +- temp.full = 0; ++ if (X <= MAX) ++ temp.full = (X << SHIFT_AMOUNT); ++ else ++ temp.full = 0; + +- return temp; ++ return temp; + } + + fInt fNegate(fInt X) + { +- fInt CONSTANT_NEGONE = ConvertToFraction(-1); +- return (fMultiply(X, CONSTANT_NEGONE)); ++ fInt CONSTANT_NEGONE = ConvertToFraction(-1); ++ return (fMultiply(X, CONSTANT_NEGONE)); + } + + fInt Convert_ULONG_ToFraction(uint32_t X) + { +- fInt temp; ++ fInt temp; + +- if (X <= MAX) +- temp.full = (X << SHIFT_AMOUNT); +- else +- temp.full = 0; ++ if (X <= MAX) ++ temp.full = (X << SHIFT_AMOUNT); ++ else ++ temp.full = 0; + +- return temp; ++ return temp; + } + + fInt GetScaledFraction(int X, int factor) + { +- int times_shifted, factor_shifted; +- bool bNEGATED; +- fInt fValue; +- +- times_shifted = 0; +- factor_shifted = 0; +- bNEGATED = false; +- +- if (X < 0) { +- X = -1*X; +- bNEGATED = true; +- } +- +- if (factor < 0) { +- factor = -1*factor; +- +- 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++; +- } +- +- while (factor > MAX) { +- factor = factor >> 1; +- factor_shifted++; +- } +- } else { +- fValue.full = 0; +- return fValue; +- } +- } +- +- if (factor == 1) +- return (ConvertToFraction(X)); +- +- fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor)); +- +- fValue.full = fValue.full << times_shifted; +- fValue.full = fValue.full >> factor_shifted; +- +- return fValue; ++ int times_shifted, factor_shifted; ++ bool bNEGATED; ++ fInt fValue; ++ ++ times_shifted = 0; ++ factor_shifted = 0; ++ bNEGATED = false; ++ ++ if (X < 0) { ++ X = -1*X; ++ bNEGATED = true; ++ } ++ ++ if (factor < 0) { ++ factor = -1*factor; ++ 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++; ++ } ++ ++ while (factor > MAX) { ++ factor = factor >> 1; ++ factor_shifted++; ++ } ++ } else { ++ fValue.full = 0; ++ return fValue; ++ } ++ } ++ ++ if (factor == 1) ++ return (ConvertToFraction(X)); ++ ++ fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor)); ++ ++ fValue.full = fValue.full << times_shifted; ++ fValue.full = fValue.full >> factor_shifted; ++ ++ return fValue; + } + + /* Addition using two fInts */ + 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 */ + 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) + { +- if (A.full == B.full) +- return true; +- else +- return false; ++ if (A.full == B.full) ++ return true; ++ else ++ return false; + } + + bool GreaterThan(fInt A, fInt B) + { +- if (A.full > B.full) +- return true; +- else +- return false; ++ if (A.full > B.full) ++ return true; ++ else ++ return false; + } + + fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */ + { +- fInt Product; +- int64_t tempProduct; +- bool X_LessThanOne, Y_LessThanOne; ++ fInt Product; ++ int64_t tempProduct; ++ bool X_LessThanOne, Y_LessThanOne; + +- 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); ++ 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); + +- /*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/ +- /* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION ++ /*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/ ++ /* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION + +- if (X_LessThanOne && Y_LessThanOne) { +- Product.full = X.full * Y.full; +- return Product +- }*/ ++ if (X_LessThanOne && Y_LessThanOne) { ++ Product.full = X.full * Y.full; ++ 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 = 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 */ ++ 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; */ ++ 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 fZERO, fQuotient; +- int64_t longlongX, longlongY; ++ fInt fZERO, fQuotient; ++ int64_t longlongX, longlongY; + +- fZERO = ConvertToFraction(0); ++ fZERO = ConvertToFraction(0); + +- if (Equal(Y, fZERO)) +- return fZERO; ++ if (Equal(Y, fZERO)) ++ return fZERO; + +- longlongX = (int64_t)X.full; +- longlongY = (int64_t)Y.full; ++ longlongX = (int64_t)X.full; ++ longlongY = (int64_t)Y.full; + +- longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */ ++ longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */ + +- do_div(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */ ++ do_div(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */ + +- fQuotient.full = (int)longlongX; +- return fQuotient; ++ fQuotient.full = (int)longlongX; ++ return fQuotient; + } + + 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) + { +- return fMultiply(A,A); ++ return fMultiply(A,A); + } + + /* x_new = x_old - (x_old^2 - C) / (2 * x_old) */ + fInt fSqrt(fInt num) + { +- fInt F_divide_Fprime, Fprime; +- fInt test; +- fInt twoShifted; +- int seed, counter, error; +- fInt x_new, x_old, C, y; ++ fInt F_divide_Fprime, Fprime; ++ fInt test; ++ fInt twoShifted; ++ int seed, counter, error; ++ fInt x_new, x_old, C, y; + +- 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; ++ fInt fZERO = ConvertToFraction(0); + +- C = num; ++ /* (0 > num) is the same as (num < 0), i.e., num is negative */ + +- if (num.partial.real > 3000) +- seed = 60; +- else if (num.partial.real > 1000) +- seed = 30; +- else if (num.partial.real > 100) +- seed = 10; +- else +- seed = 2; ++ if (GreaterThan(fZERO, num) || Equal(fZERO, num)) ++ return fZERO; + +- counter = 0; ++ C = num; + +- if (Equal(num, fZERO)) /*Square Root of Zero is zero */ +- return fZERO; ++ if (num.partial.real > 3000) ++ seed = 60; ++ else if (num.partial.real > 1000) ++ seed = 30; ++ else if (num.partial.real > 100) ++ seed = 10; ++ else ++ seed = 2; ++ ++ counter = 0; + +- twoShifted = ConvertToFraction(2); +- x_new = ConvertToFraction(seed); ++ if (Equal(num, fZERO)) /*Square Root of Zero is zero */ ++ return fZERO; + +- do { +- counter++; ++ twoShifted = ConvertToFraction(2); ++ x_new = ConvertToFraction(seed); + +- x_old.full = x_new.full; ++ do { ++ counter++; + +- 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; */ ++ x_old.full = x_new.full; + +- Fprime = fMultiply(twoShifted, x_old); +- F_divide_Fprime = fDivide(y, 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; */ + +- x_new = fSubtract(x_old, F_divide_Fprime); ++ Fprime = fMultiply(twoShifted, x_old); ++ F_divide_Fprime = fDivide(y, Fprime); + +- error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old); ++ x_new = fSubtract(x_old, F_divide_Fprime); + +- if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/ +- return x_new; ++ error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old); + +- } while (uAbs(error) > 0); ++ if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/ ++ return x_new; + +- return (x_new); ++ } while (uAbs(error) > 0); ++ ++ return (x_new); + } + + void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[]) + { +- fInt* pRoots = &Roots[0]; +- fInt temp, root_first, root_second; +- fInt f_CONSTANT10, f_CONSTANT100; ++ fInt *pRoots = &Roots[0]; ++ fInt temp, root_first, root_second; ++ fInt f_CONSTANT10, f_CONSTANT100; + +- f_CONSTANT100 = ConvertToFraction(100); +- f_CONSTANT10 = ConvertToFraction(10); ++ f_CONSTANT100 = ConvertToFraction(100); ++ f_CONSTANT10 = ConvertToFraction(10); + +- while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) { +- A = fDivide(A, f_CONSTANT10); +- B = fDivide(B, f_CONSTANT10); +- C = fDivide(C, f_CONSTANT10); +- } ++ while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) { ++ A = fDivide(A, f_CONSTANT10); ++ B = fDivide(B, f_CONSTANT10); ++ C = fDivide(C, f_CONSTANT10); ++ } + +- temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */ +- temp = fMultiply(temp, C); /* root = 4*A*C */ +- temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */ +- temp = fSqrt(temp); /*root = Sqrt (b^2 - 4AC); */ ++ temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */ ++ temp = fMultiply(temp, C); /* root = 4*A*C */ ++ temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */ ++ temp = fSqrt(temp); /*root = 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_first = fSubtract(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, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ ++ 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_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, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */ ++ root_second = fDivide(root_second, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ + +- *(pRoots + 0) = root_first; +- *(pRoots + 1) = root_second; ++ *(pRoots + 0) = root_first; ++ *(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?. */ + fInt Add (int X, int Y) + { +- fInt A, B, Sum; ++ fInt A, B, Sum; + +- A.full = (X << SHIFT_AMOUNT); +- B.full = (Y << SHIFT_AMOUNT); ++ A.full = (X << 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 */ + int GetReal (fInt A) + { +- return (A.full >> SHIFT_AMOUNT); ++ return (A.full >> SHIFT_AMOUNT); + } + + /* Temporarily Disabled */ + int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */ + { +- /* ROUNDING TEMPORARLY DISABLED +- int temp = A.full; +- +- int decimal_cutoff, decimal_mask = 0x000001FF; +- +- decimal_cutoff = temp & decimal_mask; +- +- +- if (decimal_cutoff > 0x147) { +- temp += 673; +- }*/ +- +- return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */ ++ /* ROUNDING TEMPORARLY DISABLED ++ int temp = A.full; ++ int decimal_cutoff, decimal_mask = 0x000001FF; ++ 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 A, B, Product; ++ fInt A, B, Product; + +- A.full = X << SHIFT_AMOUNT; +- B.full = Y << SHIFT_AMOUNT; ++ A.full = X << 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 A, B, Quotient; ++ fInt A, B, Quotient; + +- A.full = X << SHIFT_AMOUNT; +- B.full = Y << SHIFT_AMOUNT; ++ A.full = X << 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 */ +@@ -563,16 +561,13 @@ int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole intege + int i, scaledDecimal = 0, tmp = A.partial.decimal; + + for (i = 0; i < PRECISION; i++) { +- dec[i] = tmp / (1 << SHIFT_AMOUNT); +- +- tmp = tmp - ((1 << SHIFT_AMOUNT)*dec[i]); +- +- tmp *= 10; +- +- scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION - 1 -i); +- } ++ dec[i] = tmp / (1 << SHIFT_AMOUNT); ++ tmp = tmp - ((1 << SHIFT_AMOUNT)*dec[i]); ++ tmp *= 10; ++ scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION - 1 -i); ++ } + +- return scaledDecimal; ++ return scaledDecimal; + } + + int uPow(int base, int power) +@@ -601,17 +596,17 @@ int uAbs(int X) + + fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term) + { +- fInt solution; ++ fInt solution; + +- solution = fDivide(A, fStepSize); +- solution.partial.decimal = 0; /*All fractional digits changes to 0 */ ++ solution = fDivide(A, fStepSize); ++ solution.partial.decimal = 0; /*All fractional digits changes to 0 */ + +- if (error_term) +- solution.partial.real += 1; /*Error term of 1 added */ ++ if (error_term) ++ solution.partial.real += 1; /*Error term of 1 added */ + +- solution = fMultiply(solution, fStepSize); +- solution = fAdd(solution, fStepSize); ++ solution = fMultiply(solution, fStepSize); ++ solution = fAdd(solution, fStepSize); + +- return solution; ++ return solution; + } + +diff --git a/drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c b/drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c +index 45997e6..21c31db 100644 +--- a/drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c ++++ b/drivers/gpu/drm/amd/powerplay/smumgr/fiji_smumgr.c +@@ -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); +- 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, + * 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) +@@ -723,7 +723,7 @@ static int fiji_start_avfs_btc(struct pp_smumgr *smumgr) + /* clear reset */ + cgs_write_register(smumgr->device, mmGRBM_SOFT_RESET, 0); + +- return result; ++ return result; + } + + int fiji_setup_pm_fuse_for_avfs(struct pp_smumgr *smumgr) +-- +1.9.1 + |