aboutsummaryrefslogtreecommitdiffstats
path: root/common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch
diff options
context:
space:
mode:
Diffstat (limited to 'common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch')
-rw-r--r--common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch993
1 files changed, 993 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch b/common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch
new file mode 100644
index 00000000..b1f4b6f3
--- /dev/null
+++ b/common/recipes-kernel/linux/files/0153-drm-amd-powerplay-fix-Smatch-static-checker-warnings.patch
@@ -0,0 +1,993 @@
+From ad143b8bf42dfb169b345c19d099d3e2146e33fd 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 0153/1110] 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>
+---
+ 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 e05ae17..398c197 100644
+--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
+@@ -808,7 +808,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 94f404c..6dba5bf 100644
+--- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
+@@ -941,8 +941,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)
+ {
+@@ -1112,7 +1113,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)
+@@ -1158,7 +1159,7 @@ static int fiji_program_static_screen_threshold_parameters(
+ CG_STATIC_SCREEN_PARAMETER, 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);
+
+- return error ? -1 : 0;
++ return error ? -1 : 0;
+ }
+
+ /* 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;
+ }
+
+- 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;
+ }
+
+ /**
+@@ -1927,17 +1928,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.
+@@ -2756,7 +2757,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;
+@@ -3172,9 +3173,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) {
+@@ -3320,7 +3321,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,
+@@ -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)
+ {
+- 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 001b8bb..f9bf4fc 100644
+--- a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
+@@ -317,4 +317,3 @@ int phm_set_cpu_power_state(struct pp_hwmgr *hwmgr)
+
+ return 0;
+ }
+-
+diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
+index 411cb0f..b7429a5 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) */
+
+- 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;
+- 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)
+--
+2.7.4
+
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-04-26 23:35:54 +0000