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>

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 3b78982abaf1..4386cbac7f97 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 94f404c121b7..6dba5bf73e52 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 f89c98fd759e..6efcb2bac45f 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 001b8bb4143d..f9bf4fccbc79 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 411cb0fcdf98..b7429a527828 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 45997e609fd6..21c31db0df26 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)