Commit 737a44b1 authored by Alex Deucher's avatar Alex Deucher
Browse files

drm/amdgpu/powerplay: endian fixes for ppatomctrl.c 



Atom tables are in LE format.

Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent b1814a1d

drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.c

+127 −122
Original line number Diff line number Diff line
@@ -179,13 +179,12 @@ int atomctrl_set_engine_dram_timings_rv770( 


	/* They are both in 10KHz Units. */

	engine_clock_parameters.ulTargetEngineClock =

		(uint32_t) engine_clock & SET_CLOCK_FREQ_MASK;

	engine_clock_parameters.ulTargetEngineClock |=

		(COMPUTE_ENGINE_PLL_PARAM << 24);

		cpu_to_le32((engine_clock & SET_CLOCK_FREQ_MASK) |

			    ((COMPUTE_ENGINE_PLL_PARAM << 24)));



	/* in 10 khz units.*/

	engine_clock_parameters.sReserved.ulClock =

		(uint32_t) memory_clock & SET_CLOCK_FREQ_MASK;

		cpu_to_le32(memory_clock & SET_CLOCK_FREQ_MASK);

	return cgs_atom_exec_cmd_table(hwmgr->device,

			GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings),

			&engine_clock_parameters);
@@ -252,7 +251,7 @@ int atomctrl_get_memory_pll_dividers_si( 
	COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_1 mpll_parameters;

	int result;



	mpll_parameters.ulClock = (uint32_t) clock_value;

	mpll_parameters.ulClock = cpu_to_le32(clock_value);

	mpll_parameters.ucInputFlag = (uint8_t)((strobe_mode) ? 1 : 0);



	result = cgs_atom_exec_cmd_table
@@ -262,9 +261,9 @@ int atomctrl_get_memory_pll_dividers_si( 


	if (0 == result) {

		mpll_param->mpll_fb_divider.clk_frac =

			mpll_parameters.ulFbDiv.usFbDivFrac;

			le16_to_cpu(mpll_parameters.ulFbDiv.usFbDivFrac);

		mpll_param->mpll_fb_divider.cl_kf =

			mpll_parameters.ulFbDiv.usFbDiv;

			le16_to_cpu(mpll_parameters.ulFbDiv.usFbDiv);

		mpll_param->mpll_post_divider =

			(uint32_t)mpll_parameters.ucPostDiv;

		mpll_param->vco_mode =
@@ -300,7 +299,7 @@ int atomctrl_get_memory_pll_dividers_vi(struct pp_hwmgr *hwmgr, 
	COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_2 mpll_parameters;

	int result;



	mpll_parameters.ulClock.ulClock = (uint32_t)clock_value;

	mpll_parameters.ulClock.ulClock = cpu_to_le32(clock_value);



	result = cgs_atom_exec_cmd_table(hwmgr->device,

			GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam),
@@ -320,7 +319,7 @@ int atomctrl_get_engine_pll_dividers_kong(struct pp_hwmgr *hwmgr, 
	COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 pll_parameters;

	int result;



	pll_parameters.ulClock = clock_value;

	pll_parameters.ulClock = cpu_to_le32(clock_value);



	result = cgs_atom_exec_cmd_table

		(hwmgr->device,
@@ -329,7 +328,7 @@ int atomctrl_get_engine_pll_dividers_kong(struct pp_hwmgr *hwmgr, 


	if (0 == result) {

		dividers->pll_post_divider = pll_parameters.ucPostDiv;

		dividers->real_clock = pll_parameters.ulClock;

		dividers->real_clock = le32_to_cpu(pll_parameters.ulClock);

	}



	return result;
@@ -343,7 +342,7 @@ int atomctrl_get_engine_pll_dividers_vi( 
	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 pll_patameters;

	int result;



	pll_patameters.ulClock.ulClock = clock_value;

	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);

	pll_patameters.ulClock.ucPostDiv = COMPUTE_GPUCLK_INPUT_FLAG_SCLK;



	result = cgs_atom_exec_cmd_table
@@ -355,12 +354,12 @@ int atomctrl_get_engine_pll_dividers_vi( 
		dividers->pll_post_divider =

			pll_patameters.ulClock.ucPostDiv;

		dividers->real_clock =

			pll_patameters.ulClock.ulClock;

			le32_to_cpu(pll_patameters.ulClock.ulClock);



		dividers->ul_fb_div.ul_fb_div_frac =

			pll_patameters.ulFbDiv.usFbDivFrac;

			le16_to_cpu(pll_patameters.ulFbDiv.usFbDivFrac);

		dividers->ul_fb_div.ul_fb_div =

			pll_patameters.ulFbDiv.usFbDiv;

			le16_to_cpu(pll_patameters.ulFbDiv.usFbDiv);



		dividers->uc_pll_ref_div =

			pll_patameters.ucPllRefDiv;
@@ -380,7 +379,7 @@ int atomctrl_get_engine_pll_dividers_ai(struct pp_hwmgr *hwmgr, 
	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_7 pll_patameters;

	int result;



	pll_patameters.ulClock.ulClock = clock_value;

	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);

	pll_patameters.ulClock.ucPostDiv = COMPUTE_GPUCLK_INPUT_FLAG_SCLK;



	result = cgs_atom_exec_cmd_table
@@ -412,7 +411,7 @@ int atomctrl_get_dfs_pll_dividers_vi( 
	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 pll_patameters;

	int result;



	pll_patameters.ulClock.ulClock = clock_value;

	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);

	pll_patameters.ulClock.ucPostDiv =

		COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK;
@@ -425,12 +424,12 @@ int atomctrl_get_dfs_pll_dividers_vi( 
		dividers->pll_post_divider =

			pll_patameters.ulClock.ucPostDiv;

		dividers->real_clock =

			pll_patameters.ulClock.ulClock;

			le32_to_cpu(pll_patameters.ulClock.ulClock);



		dividers->ul_fb_div.ul_fb_div_frac =

			pll_patameters.ulFbDiv.usFbDivFrac;

			le16_to_cpu(pll_patameters.ulFbDiv.usFbDivFrac);

		dividers->ul_fb_div.ul_fb_div =

			pll_patameters.ulFbDiv.usFbDiv;

			le16_to_cpu(pll_patameters.ulFbDiv.usFbDiv);



		dividers->uc_pll_ref_div =

			pll_patameters.ucPllRefDiv;
@@ -519,13 +518,13 @@ int atomctrl_get_voltage_table_v3( 


	for (i = 0; i < voltage_object->asGpioVoltageObj.ucGpioEntryNum; i++) {

		voltage_table->entries[i].value =

			voltage_object->asGpioVoltageObj.asVolGpioLut[i].usVoltageValue;

			le16_to_cpu(voltage_object->asGpioVoltageObj.asVolGpioLut[i].usVoltageValue);

		voltage_table->entries[i].smio_low =

			voltage_object->asGpioVoltageObj.asVolGpioLut[i].ulVoltageId;

			le32_to_cpu(voltage_object->asGpioVoltageObj.asVolGpioLut[i].ulVoltageId);

	}



	voltage_table->mask_low    =

		voltage_object->asGpioVoltageObj.ulGpioMaskVal;

		le32_to_cpu(voltage_object->asGpioVoltageObj.ulGpioMaskVal);

	voltage_table->count      =

		voltage_object->asGpioVoltageObj.ucGpioEntryNum;

	voltage_table->phase_delay =
@@ -662,37 +661,37 @@ int atomctrl_calculate_voltage_evv_on_sclk( 


	switch (dpm_level) {

	case 1:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm1);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM1, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm1));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM1), 1000);

		break;

	case 2:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm2);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM2, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm2));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM2), 1000);

		break;

	case 3:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm3);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM3, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm3));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM3), 1000);

		break;

	case 4:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm4);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM4, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm4));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM4), 1000);

		break;

	case 5:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm5);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM5, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm5));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM5), 1000);

		break;

	case 6:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm6);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM6, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm6));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM6), 1000);

		break;

	case 7:

		fPowerDPMx = Convert_ULONG_ToFraction(getASICProfilingInfo->usPowerDpm7);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM7, 1000);

		fPowerDPMx = Convert_ULONG_ToFraction(le16_to_cpu(getASICProfilingInfo->usPowerDpm7));

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM7), 1000);

		break;

	default:

		printk(KERN_ERR "DPM Level not supported\n");

		fPowerDPMx = Convert_ULONG_ToFraction(1);

		fDerateTDP = GetScaledFraction(getASICProfilingInfo->ulTdpDerateDPM0, 1000);

		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM0), 1000);

	}



	/*-------------------------
@@ -716,9 +715,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
		return result;



	/* Finally, the actual fuse value */

	ul_RO_fused = sOutput_FuseValues.ulEfuseValue;

	fMin = GetScaledFraction(sRO_fuse.ulEfuseMin, 1);

	fRange = GetScaledFraction(sRO_fuse.ulEfuseEncodeRange, 1);

	ul_RO_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fMin = GetScaledFraction(le32_to_cpu(sRO_fuse.ulEfuseMin), 1);

	fRange = GetScaledFraction(le32_to_cpu(sRO_fuse.ulEfuseEncodeRange), 1);

	fRO_fused = fDecodeLinearFuse(ul_RO_fused, fMin, fRange, sRO_fuse.ucEfuseLength);



	sCACm_fuse = getASICProfilingInfo->sCACm;
@@ -736,9 +735,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_CACm_fused = sOutput_FuseValues.ulEfuseValue;

	fMin = GetScaledFraction(sCACm_fuse.ulEfuseMin, 1000);

	fRange = GetScaledFraction(sCACm_fuse.ulEfuseEncodeRange, 1000);

	ul_CACm_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fMin = GetScaledFraction(le32_to_cpu(sCACm_fuse.ulEfuseMin), 1000);

	fRange = GetScaledFraction(le32_to_cpu(sCACm_fuse.ulEfuseEncodeRange), 1000);



	fCACm_fused = fDecodeLinearFuse(ul_CACm_fused, fMin, fRange, sCACm_fuse.ucEfuseLength);
@@ -756,9 +755,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_CACb_fused = sOutput_FuseValues.ulEfuseValue;

	fMin = GetScaledFraction(sCACb_fuse.ulEfuseMin, 1000);

	fRange = GetScaledFraction(sCACb_fuse.ulEfuseEncodeRange, 1000);

	ul_CACb_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fMin = GetScaledFraction(le32_to_cpu(sCACb_fuse.ulEfuseMin), 1000);

	fRange = GetScaledFraction(le32_to_cpu(sCACb_fuse.ulEfuseEncodeRange), 1000);



	fCACb_fused = fDecodeLinearFuse(ul_CACb_fused, fMin, fRange, sCACb_fuse.ucEfuseLength);
@@ -777,9 +776,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_Kt_Beta_fused = sOutput_FuseValues.ulEfuseValue;

	fAverage = GetScaledFraction(sKt_Beta_fuse.ulEfuseEncodeAverage, 1000);

	fRange = GetScaledFraction(sKt_Beta_fuse.ulEfuseEncodeRange, 1000);

	ul_Kt_Beta_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fAverage = GetScaledFraction(le32_to_cpu(sKt_Beta_fuse.ulEfuseEncodeAverage), 1000);

	fRange = GetScaledFraction(le32_to_cpu(sKt_Beta_fuse.ulEfuseEncodeRange), 1000);



	fKt_Beta_fused = fDecodeLogisticFuse(ul_Kt_Beta_fused,

			fAverage, fRange, sKt_Beta_fuse.ucEfuseLength);
@@ -798,9 +797,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_Kv_m_fused = sOutput_FuseValues.ulEfuseValue;

	fAverage = GetScaledFraction(sKv_m_fuse.ulEfuseEncodeAverage, 1000);

	fRange = GetScaledFraction((sKv_m_fuse.ulEfuseEncodeRange & 0x7fffffff), 1000);

	ul_Kv_m_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fAverage = GetScaledFraction(le32_to_cpu(sKv_m_fuse.ulEfuseEncodeAverage), 1000);

	fRange = GetScaledFraction((le32_to_cpu(sKv_m_fuse.ulEfuseEncodeRange) & 0x7fffffff), 1000);

	fRange = fMultiply(fRange, ConvertToFraction(-1));



	fKv_m_fused = fDecodeLogisticFuse(ul_Kv_m_fused,
@@ -820,9 +819,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_Kv_b_fused = sOutput_FuseValues.ulEfuseValue;

	fAverage = GetScaledFraction(sKv_b_fuse.ulEfuseEncodeAverage, 1000);

	fRange = GetScaledFraction(sKv_b_fuse.ulEfuseEncodeRange, 1000);

	ul_Kv_b_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fAverage = GetScaledFraction(le32_to_cpu(sKv_b_fuse.ulEfuseEncodeAverage), 1000);

	fRange = GetScaledFraction(le32_to_cpu(sKv_b_fuse.ulEfuseEncodeRange), 1000);



	fKv_b_fused = fDecodeLogisticFuse(ul_Kv_b_fused,

			fAverage, fRange, sKv_b_fuse.ucEfuseLength);
@@ -851,9 +850,9 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	if (result)

		return result;



	ul_FT_Lkg_V0NORM = sOutput_FuseValues.ulEfuseValue;

	fLn_MaxDivMin = GetScaledFraction(getASICProfilingInfo->ulLkgEncodeLn_MaxDivMin, 10000);

	fMin = GetScaledFraction(getASICProfilingInfo->ulLkgEncodeMin, 10000);

	ul_FT_Lkg_V0NORM = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);

	fLn_MaxDivMin = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLkgEncodeLn_MaxDivMin), 10000);

	fMin = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLkgEncodeMin), 10000);



	fFT_Lkg_V0NORM = fDecodeLeakageID(ul_FT_Lkg_V0NORM,

			fLn_MaxDivMin, fMin, getASICProfilingInfo->ucLkgEfuseLength);
@@ -863,40 +862,40 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	 * PART 2 - Grabbing all required values

	 *-------------------------------------------

	 */

	fSM_A0 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A0, 1000000),

	fSM_A0 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A0), 1000000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A0_sign)));

	fSM_A1 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A1, 1000000),

	fSM_A1 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A1), 1000000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A1_sign)));

	fSM_A2 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A2, 100000),

	fSM_A2 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A2), 100000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A2_sign)));

	fSM_A3 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A3, 1000000),

	fSM_A3 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A3), 1000000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A3_sign)));

	fSM_A4 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A4, 1000000),

	fSM_A4 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A4), 1000000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A4_sign)));

	fSM_A5 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A5, 1000),

	fSM_A5 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A5), 1000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A5_sign)));

	fSM_A6 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A6, 1000),

	fSM_A6 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A6), 1000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A6_sign)));

	fSM_A7 = fMultiply(GetScaledFraction(getASICProfilingInfo->ulSM_A7, 1000),

	fSM_A7 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A7), 1000),

			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A7_sign)));



	fMargin_RO_a = ConvertToFraction(getASICProfilingInfo->ulMargin_RO_a);

	fMargin_RO_b = ConvertToFraction(getASICProfilingInfo->ulMargin_RO_b);

	fMargin_RO_c = ConvertToFraction(getASICProfilingInfo->ulMargin_RO_c);

	fMargin_RO_a = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_a));

	fMargin_RO_b = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_b));

	fMargin_RO_c = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_c));



	fMargin_fixed = ConvertToFraction(getASICProfilingInfo->ulMargin_fixed);

	fMargin_fixed = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_fixed));



	fMargin_FMAX_mean = GetScaledFraction(

			getASICProfilingInfo->ulMargin_Fmax_mean, 10000);

		le32_to_cpu(getASICProfilingInfo->ulMargin_Fmax_mean), 10000);

	fMargin_Plat_mean = GetScaledFraction(

			getASICProfilingInfo->ulMargin_plat_mean, 10000);

		le32_to_cpu(getASICProfilingInfo->ulMargin_plat_mean), 10000);

	fMargin_FMAX_sigma = GetScaledFraction(

			getASICProfilingInfo->ulMargin_Fmax_sigma, 10000);

		le32_to_cpu(getASICProfilingInfo->ulMargin_Fmax_sigma), 10000);

	fMargin_Plat_sigma = GetScaledFraction(

			getASICProfilingInfo->ulMargin_plat_sigma, 10000);

		le32_to_cpu(getASICProfilingInfo->ulMargin_plat_sigma), 10000);



	fMargin_DC_sigma = GetScaledFraction(

			getASICProfilingInfo->ulMargin_DC_sigma, 100);

		le32_to_cpu(getASICProfilingInfo->ulMargin_DC_sigma), 100);

	fMargin_DC_sigma = fDivide(fMargin_DC_sigma, ConvertToFraction(1000));



	fCACm_fused = fDivide(fCACm_fused, ConvertToFraction(100));
@@ -908,14 +907,14 @@ int atomctrl_calculate_voltage_evv_on_sclk( 
	fSclk = GetScaledFraction(sclk, 100);



	fV_max = fDivide(GetScaledFraction(

			getASICProfilingInfo->ulMaxVddc, 1000), ConvertToFraction(4));

	fT_prod = GetScaledFraction(getASICProfilingInfo->ulBoardCoreTemp, 10);

	fLKG_Factor = GetScaledFraction(getASICProfilingInfo->ulEvvLkgFactor, 100);

	fT_FT = GetScaledFraction(getASICProfilingInfo->ulLeakageTemp, 10);

				 le32_to_cpu(getASICProfilingInfo->ulMaxVddc), 1000), ConvertToFraction(4));

	fT_prod = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulBoardCoreTemp), 10);

	fLKG_Factor = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulEvvLkgFactor), 100);

	fT_FT = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLeakageTemp), 10);

	fV_FT = fDivide(GetScaledFraction(

			getASICProfilingInfo->ulLeakageVoltage, 1000), ConvertToFraction(4));

				le32_to_cpu(getASICProfilingInfo->ulLeakageVoltage), 1000), ConvertToFraction(4));

	fV_min = fDivide(GetScaledFraction(

			getASICProfilingInfo->ulMinVddc, 1000), ConvertToFraction(4));

				 le32_to_cpu(getASICProfilingInfo->ulMinVddc), 1000), ConvertToFraction(4));



	/*-----------------------

	 * PART 3
@@ -1063,9 +1062,9 @@ int atomctrl_get_voltage_evv_on_sclk( 
	get_voltage_info_param_space.ucVoltageMode   =

		ATOM_GET_VOLTAGE_EVV_VOLTAGE;

	get_voltage_info_param_space.usVoltageLevel  =

		virtual_voltage_Id;

		cpu_to_le16(virtual_voltage_Id);

	get_voltage_info_param_space.ulSCLKFreq      =

		sclk;

		cpu_to_le32(sclk);



	result = cgs_atom_exec_cmd_table(hwmgr->device,

			GetIndexIntoMasterTable(COMMAND, GetVoltageInfo),
@@ -1074,8 +1073,8 @@ int atomctrl_get_voltage_evv_on_sclk( 
	if (0 != result)

		return result;



	*voltage = ((GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 *)

			(&get_voltage_info_param_space))->usVoltageLevel;

	*voltage = le16_to_cpu(((GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 *)

				(&get_voltage_info_param_space))->usVoltageLevel);



	return result;

}
@@ -1165,8 +1164,8 @@ static int asic_internal_ss_get_ss_asignment(struct pp_hwmgr *hwmgr, 


	if (entry_found) {

		ssEntry->speed_spectrum_percentage =

			ssInfo->usSpreadSpectrumPercentage;

		ssEntry->speed_spectrum_rate = ssInfo->usSpreadRateInKhz;

			le16_to_cpu(ssInfo->usSpreadSpectrumPercentage);

		ssEntry->speed_spectrum_rate = le16_to_cpu(ssInfo->usSpreadRateInKhz);



		if (((GET_DATA_TABLE_MAJOR_REVISION(table) == 2) &&

			(GET_DATA_TABLE_MINOR_REVISION(table) >= 2)) ||
@@ -1222,7 +1221,7 @@ int atomctrl_read_efuse(void *device, uint16_t start_index, 
	int result;

	READ_EFUSE_VALUE_PARAMETER efuse_param;



	efuse_param.sEfuse.usEfuseIndex = (start_index / 32) * 4;

	efuse_param.sEfuse.usEfuseIndex = cpu_to_le16((start_index / 32) * 4);

	efuse_param.sEfuse.ucBitShift = (uint8_t)

			(start_index - ((start_index / 32) * 32));

	efuse_param.sEfuse.ucBitLength  = (uint8_t)
@@ -1232,7 +1231,7 @@ int atomctrl_read_efuse(void *device, uint16_t start_index, 
			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),

			&efuse_param);

	if (!result)

		*efuse = efuse_param.ulEfuseValue & mask;

		*efuse = le32_to_cpu(efuse_param.ulEfuseValue) & mask;



	return result;

}
@@ -1243,8 +1242,10 @@ int atomctrl_set_ac_timing_ai(struct pp_hwmgr *hwmgr, uint32_t memory_clock, 
	DYNAMICE_MEMORY_SETTINGS_PARAMETER_V2_1 memory_clock_parameters;

	int result;



	memory_clock_parameters.asDPMMCReg.ulClock.ulClockFreq = memory_clock & SET_CLOCK_FREQ_MASK;

	memory_clock_parameters.asDPMMCReg.ulClock.ulComputeClockFlag = ADJUST_MC_SETTING_PARAM;

	memory_clock_parameters.asDPMMCReg.ulClock.ulClockFreq =

		cpu_to_le32(memory_clock & SET_CLOCK_FREQ_MASK);

	memory_clock_parameters.asDPMMCReg.ulClock.ulComputeClockFlag =

		cpu_to_le32(ADJUST_MC_SETTING_PARAM);

	memory_clock_parameters.asDPMMCReg.ucMclkDPMState = level;



	result = cgs_atom_exec_cmd_table
@@ -1264,8 +1265,8 @@ int atomctrl_get_voltage_evv_on_sclk_ai(struct pp_hwmgr *hwmgr, uint8_t voltage_ 


	get_voltage_info_param_space.ucVoltageType = voltage_type;

	get_voltage_info_param_space.ucVoltageMode = ATOM_GET_VOLTAGE_EVV_VOLTAGE;

	get_voltage_info_param_space.usVoltageLevel = virtual_voltage_Id;

	get_voltage_info_param_space.ulSCLKFreq = sclk;

	get_voltage_info_param_space.usVoltageLevel = cpu_to_le16(virtual_voltage_Id);

	get_voltage_info_param_space.ulSCLKFreq = cpu_to_le32(sclk);



	result = cgs_atom_exec_cmd_table(hwmgr->device,

			GetIndexIntoMasterTable(COMMAND, GetVoltageInfo),
@@ -1274,7 +1275,7 @@ int atomctrl_get_voltage_evv_on_sclk_ai(struct pp_hwmgr *hwmgr, uint8_t voltage_ 
	if (0 != result)

		return result;



	*voltage = get_voltage_info_param_space.usVoltageLevel;

	*voltage = le16_to_cpu(get_voltage_info_param_space.usVoltageLevel);



	return result;

}
@@ -1295,15 +1296,19 @@ int atomctrl_get_smc_sclk_range_table(struct pp_hwmgr *hwmgr, struct pp_atom_ctr 
	for (i = 0; i < psmu_info->ucSclkEntryNum; i++) {

		table->entry[i].ucVco_setting = psmu_info->asSclkFcwRangeEntry[i].ucVco_setting;

		table->entry[i].ucPostdiv = psmu_info->asSclkFcwRangeEntry[i].ucPostdiv;

		table->entry[i].usFcw_pcc = psmu_info->asSclkFcwRangeEntry[i].ucFcw_pcc;

		table->entry[i].usFcw_trans_upper = psmu_info->asSclkFcwRangeEntry[i].ucFcw_trans_upper;

		table->entry[i].usRcw_trans_lower = psmu_info->asSclkFcwRangeEntry[i].ucRcw_trans_lower;

		table->entry[i].usFcw_pcc =

			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucFcw_pcc);

		table->entry[i].usFcw_trans_upper =

			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucFcw_trans_upper);

		table->entry[i].usRcw_trans_lower =

			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucRcw_trans_lower);

	}



	return 0;

}



int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl__avfs_parameters *param)

int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr,

				  struct pp_atom_ctrl__avfs_parameters *param)

{

	ATOM_ASIC_PROFILING_INFO_V3_6 *profile = NULL;
@@ -1317,30 +1322,30 @@ int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl__a 
	if (!profile)

		return -1;



	param->ulAVFS_meanNsigma_Acontant0 = profile->ulAVFS_meanNsigma_Acontant0;

	param->ulAVFS_meanNsigma_Acontant1 = profile->ulAVFS_meanNsigma_Acontant1;

	param->ulAVFS_meanNsigma_Acontant2 = profile->ulAVFS_meanNsigma_Acontant2;

	param->usAVFS_meanNsigma_DC_tol_sigma = profile->usAVFS_meanNsigma_DC_tol_sigma;

	param->usAVFS_meanNsigma_Platform_mean = profile->usAVFS_meanNsigma_Platform_mean;

	param->usAVFS_meanNsigma_Platform_sigma = profile->usAVFS_meanNsigma_Platform_sigma;

	param->ulGB_VDROOP_TABLE_CKSOFF_a0 = profile->ulGB_VDROOP_TABLE_CKSOFF_a0;

	param->ulGB_VDROOP_TABLE_CKSOFF_a1 = profile->ulGB_VDROOP_TABLE_CKSOFF_a1;

	param->ulGB_VDROOP_TABLE_CKSOFF_a2 = profile->ulGB_VDROOP_TABLE_CKSOFF_a2;

	param->ulGB_VDROOP_TABLE_CKSON_a0 = profile->ulGB_VDROOP_TABLE_CKSON_a0;

	param->ulGB_VDROOP_TABLE_CKSON_a1 = profile->ulGB_VDROOP_TABLE_CKSON_a1;

	param->ulGB_VDROOP_TABLE_CKSON_a2 = profile->ulGB_VDROOP_TABLE_CKSON_a2;

	param->ulAVFSGB_FUSE_TABLE_CKSOFF_m1 = profile->ulAVFSGB_FUSE_TABLE_CKSOFF_m1;

	param->usAVFSGB_FUSE_TABLE_CKSOFF_m2 = profile->usAVFSGB_FUSE_TABLE_CKSOFF_m2;

	param->ulAVFSGB_FUSE_TABLE_CKSOFF_b = profile->ulAVFSGB_FUSE_TABLE_CKSOFF_b;

	param->ulAVFSGB_FUSE_TABLE_CKSON_m1 = profile->ulAVFSGB_FUSE_TABLE_CKSON_m1;

	param->usAVFSGB_FUSE_TABLE_CKSON_m2 = profile->usAVFSGB_FUSE_TABLE_CKSON_m2;

	param->ulAVFSGB_FUSE_TABLE_CKSON_b = profile->ulAVFSGB_FUSE_TABLE_CKSON_b;

	param->usMaxVoltage_0_25mv = profile->usMaxVoltage_0_25mv;

	param->ulAVFS_meanNsigma_Acontant0 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant0);

	param->ulAVFS_meanNsigma_Acontant1 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant1);

	param->ulAVFS_meanNsigma_Acontant2 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant2);

	param->usAVFS_meanNsigma_DC_tol_sigma = le16_to_cpu(profile->usAVFS_meanNsigma_DC_tol_sigma);

	param->usAVFS_meanNsigma_Platform_mean = le16_to_cpu(profile->usAVFS_meanNsigma_Platform_mean);

	param->usAVFS_meanNsigma_Platform_sigma = le16_to_cpu(profile->usAVFS_meanNsigma_Platform_sigma);

	param->ulGB_VDROOP_TABLE_CKSOFF_a0 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a0);

	param->ulGB_VDROOP_TABLE_CKSOFF_a1 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a1);

	param->ulGB_VDROOP_TABLE_CKSOFF_a2 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a2);

	param->ulGB_VDROOP_TABLE_CKSON_a0 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a0);

	param->ulGB_VDROOP_TABLE_CKSON_a1 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a1);

	param->ulGB_VDROOP_TABLE_CKSON_a2 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a2);

	param->ulAVFSGB_FUSE_TABLE_CKSOFF_m1 = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSOFF_m1);

	param->usAVFSGB_FUSE_TABLE_CKSOFF_m2 = le16_to_cpu(profile->usAVFSGB_FUSE_TABLE_CKSOFF_m2);

	param->ulAVFSGB_FUSE_TABLE_CKSOFF_b = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSOFF_b);

	param->ulAVFSGB_FUSE_TABLE_CKSON_m1 = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSON_m1);

	param->usAVFSGB_FUSE_TABLE_CKSON_m2 = le16_to_cpu(profile->usAVFSGB_FUSE_TABLE_CKSON_m2);

	param->ulAVFSGB_FUSE_TABLE_CKSON_b = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSON_b);

	param->usMaxVoltage_0_25mv = le16_to_cpu(profile->usMaxVoltage_0_25mv);

	param->ucEnableGB_VDROOP_TABLE_CKSOFF = profile->ucEnableGB_VDROOP_TABLE_CKSOFF;

	param->ucEnableGB_VDROOP_TABLE_CKSON = profile->ucEnableGB_VDROOP_TABLE_CKSON;

	param->ucEnableGB_FUSE_TABLE_CKSOFF = profile->ucEnableGB_FUSE_TABLE_CKSOFF;

	param->ucEnableGB_FUSE_TABLE_CKSON = profile->ucEnableGB_FUSE_TABLE_CKSON;

	param->usPSM_Age_ComFactor = profile->usPSM_Age_ComFactor;

	param->usPSM_Age_ComFactor = le16_to_cpu(profile->usPSM_Age_ComFactor);

	param->ucEnableApplyAVFS_CKS_OFF_Voltage = profile->ucEnableApplyAVFS_CKS_OFF_Voltage;



	return 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE