1 /*
2  * Copyright 2015 Advanced Micro Devices, Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  */
23 #include "pp_debug.h"
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h>
27 #include "atom.h"
28 #include "ppatomctrl.h"
29 #include "atombios.h"
30 #include "cgs_common.h"
31 #include "ppevvmath.h"
32 
33 #define MEM_ID_MASK           0xff000000
34 #define MEM_ID_SHIFT          24
35 #define CLOCK_RANGE_MASK      0x00ffffff
36 #define CLOCK_RANGE_SHIFT     0
37 #define LOW_NIBBLE_MASK       0xf
38 #define DATA_EQU_PREV         0
39 #define DATA_FROM_TABLE       4
40 
41 union voltage_object_info {
42 	struct _ATOM_VOLTAGE_OBJECT_INFO v1;
43 	struct _ATOM_VOLTAGE_OBJECT_INFO_V2 v2;
44 	struct _ATOM_VOLTAGE_OBJECT_INFO_V3_1 v3;
45 };
46 
47 static int atomctrl_retrieve_ac_timing(
48 		uint8_t index,
49 		ATOM_INIT_REG_BLOCK *reg_block,
50 		pp_atomctrl_mc_reg_table *table)
51 {
52 	uint32_t i, j;
53 	uint8_t tmem_id;
54 	ATOM_MEMORY_SETTING_DATA_BLOCK *reg_data = (ATOM_MEMORY_SETTING_DATA_BLOCK *)
55 		((uint8_t *)reg_block + (2 * sizeof(uint16_t)) + le16_to_cpu(reg_block->usRegIndexTblSize));
56 
57 	uint8_t num_ranges = 0;
58 
59 	while (*(uint32_t *)reg_data != END_OF_REG_DATA_BLOCK &&
60 			num_ranges < VBIOS_MAX_AC_TIMING_ENTRIES) {
61 		tmem_id = (uint8_t)((*(uint32_t *)reg_data & MEM_ID_MASK) >> MEM_ID_SHIFT);
62 
63 		if (index == tmem_id) {
64 			table->mc_reg_table_entry[num_ranges].mclk_max =
65 				(uint32_t)((*(uint32_t *)reg_data & CLOCK_RANGE_MASK) >>
66 						CLOCK_RANGE_SHIFT);
67 
68 			for (i = 0, j = 1; i < table->last; i++) {
69 				if ((table->mc_reg_address[i].uc_pre_reg_data &
70 							LOW_NIBBLE_MASK) == DATA_FROM_TABLE) {
71 					table->mc_reg_table_entry[num_ranges].mc_data[i] =
72 						(uint32_t)*((uint32_t *)reg_data + j);
73 					j++;
74 				} else if ((table->mc_reg_address[i].uc_pre_reg_data &
75 							LOW_NIBBLE_MASK) == DATA_EQU_PREV) {
76 					table->mc_reg_table_entry[num_ranges].mc_data[i] =
77 						table->mc_reg_table_entry[num_ranges].mc_data[i-1];
78 				}
79 			}
80 			num_ranges++;
81 		}
82 
83 		reg_data = (ATOM_MEMORY_SETTING_DATA_BLOCK *)
84 			((uint8_t *)reg_data + le16_to_cpu(reg_block->usRegDataBlkSize)) ;
85 	}
86 
87 	PP_ASSERT_WITH_CODE((*(uint32_t *)reg_data == END_OF_REG_DATA_BLOCK),
88 			"Invalid VramInfo table.", return -1);
89 	table->num_entries = num_ranges;
90 
91 	return 0;
92 }
93 
94 /**
95  * atomctrl_set_mc_reg_address_table - Get memory clock AC timing registers index from VBIOS table
96  * VBIOS set end of memory clock AC timing registers by ucPreRegDataLength bit6 = 1
97  * @reg_block: the address ATOM_INIT_REG_BLOCK
98  * @table: the address of MCRegTable
99  * Return:   0
100  */
101 static int atomctrl_set_mc_reg_address_table(
102 		ATOM_INIT_REG_BLOCK *reg_block,
103 		pp_atomctrl_mc_reg_table *table)
104 {
105 	uint8_t i = 0;
106 	uint8_t num_entries = (uint8_t)((le16_to_cpu(reg_block->usRegIndexTblSize))
107 			/ sizeof(ATOM_INIT_REG_INDEX_FORMAT));
108 	ATOM_INIT_REG_INDEX_FORMAT *format = &reg_block->asRegIndexBuf[0];
109 
110 	num_entries--;        /* subtract 1 data end mark entry */
111 
112 	PP_ASSERT_WITH_CODE((num_entries <= VBIOS_MC_REGISTER_ARRAY_SIZE),
113 			"Invalid VramInfo table.", return -1);
114 
115 	/* ucPreRegDataLength bit6 = 1 is the end of memory clock AC timing registers */
116 	while ((!(format->ucPreRegDataLength & ACCESS_PLACEHOLDER)) &&
117 			(i < num_entries)) {
118 		table->mc_reg_address[i].s1 =
119 			(uint16_t)(le16_to_cpu(format->usRegIndex));
120 		table->mc_reg_address[i].uc_pre_reg_data =
121 			format->ucPreRegDataLength;
122 
123 		i++;
124 		format = (ATOM_INIT_REG_INDEX_FORMAT *)
125 			((uint8_t *)format + sizeof(ATOM_INIT_REG_INDEX_FORMAT));
126 	}
127 
128 	table->last = i;
129 	return 0;
130 }
131 
132 int atomctrl_initialize_mc_reg_table(
133 		struct pp_hwmgr *hwmgr,
134 		uint8_t module_index,
135 		pp_atomctrl_mc_reg_table *table)
136 {
137 	ATOM_VRAM_INFO_HEADER_V2_1 *vram_info;
138 	ATOM_INIT_REG_BLOCK *reg_block;
139 	int result = 0;
140 	u8 frev, crev;
141 	u16 size;
142 
143 	vram_info = (ATOM_VRAM_INFO_HEADER_V2_1 *)
144 		smu_atom_get_data_table(hwmgr->adev,
145 				GetIndexIntoMasterTable(DATA, VRAM_Info), &size, &frev, &crev);
146 
147 	if (module_index >= vram_info->ucNumOfVRAMModule) {
148 		pr_err("Invalid VramInfo table.");
149 		result = -1;
150 	} else if (vram_info->sHeader.ucTableFormatRevision < 2) {
151 		pr_err("Invalid VramInfo table.");
152 		result = -1;
153 	}
154 
155 	if (0 == result) {
156 		reg_block = (ATOM_INIT_REG_BLOCK *)
157 			((uint8_t *)vram_info + le16_to_cpu(vram_info->usMemClkPatchTblOffset));
158 		result = atomctrl_set_mc_reg_address_table(reg_block, table);
159 	}
160 
161 	if (0 == result) {
162 		result = atomctrl_retrieve_ac_timing(module_index,
163 					reg_block, table);
164 	}
165 
166 	return result;
167 }
168 
169 int atomctrl_initialize_mc_reg_table_v2_2(
170 		struct pp_hwmgr *hwmgr,
171 		uint8_t module_index,
172 		pp_atomctrl_mc_reg_table *table)
173 {
174 	ATOM_VRAM_INFO_HEADER_V2_2 *vram_info;
175 	ATOM_INIT_REG_BLOCK *reg_block;
176 	int result = 0;
177 	u8 frev, crev;
178 	u16 size;
179 
180 	vram_info = (ATOM_VRAM_INFO_HEADER_V2_2 *)
181 		smu_atom_get_data_table(hwmgr->adev,
182 				GetIndexIntoMasterTable(DATA, VRAM_Info), &size, &frev, &crev);
183 
184 	if (module_index >= vram_info->ucNumOfVRAMModule) {
185 		pr_err("Invalid VramInfo table.");
186 		result = -1;
187 	} else if (vram_info->sHeader.ucTableFormatRevision < 2) {
188 		pr_err("Invalid VramInfo table.");
189 		result = -1;
190 	}
191 
192 	if (0 == result) {
193 		reg_block = (ATOM_INIT_REG_BLOCK *)
194 			((uint8_t *)vram_info + le16_to_cpu(vram_info->usMemClkPatchTblOffset));
195 		result = atomctrl_set_mc_reg_address_table(reg_block, table);
196 	}
197 
198 	if (0 == result) {
199 		result = atomctrl_retrieve_ac_timing(module_index,
200 					reg_block, table);
201 	}
202 
203 	return result;
204 }
205 
206 /*
207  * Set DRAM timings based on engine clock and memory clock.
208  */
209 int atomctrl_set_engine_dram_timings_rv770(
210 		struct pp_hwmgr *hwmgr,
211 		uint32_t engine_clock,
212 		uint32_t memory_clock)
213 {
214 	struct amdgpu_device *adev = hwmgr->adev;
215 
216 	SET_ENGINE_CLOCK_PS_ALLOCATION engine_clock_parameters;
217 
218 	/* They are both in 10KHz Units. */
219 	engine_clock_parameters.ulTargetEngineClock =
220 		cpu_to_le32((engine_clock & SET_CLOCK_FREQ_MASK) |
221 			    ((COMPUTE_ENGINE_PLL_PARAM << 24)));
222 
223 	/* in 10 khz units.*/
224 	engine_clock_parameters.sReserved.ulClock =
225 		cpu_to_le32(memory_clock & SET_CLOCK_FREQ_MASK);
226 
227 	return amdgpu_atom_execute_table(adev->mode_info.atom_context,
228 			GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings),
229 			(uint32_t *)&engine_clock_parameters);
230 }
231 
232 /*
233  * Private Function to get the PowerPlay Table Address.
234  * WARNING: The tabled returned by this function is in
235  * dynamically allocated memory.
236  * The caller has to release if by calling kfree.
237  */
238 static ATOM_VOLTAGE_OBJECT_INFO *get_voltage_info_table(void *device)
239 {
240 	int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
241 	u8 frev, crev;
242 	u16 size;
243 	union voltage_object_info *voltage_info;
244 
245 	voltage_info = (union voltage_object_info *)
246 		smu_atom_get_data_table(device, index,
247 			&size, &frev, &crev);
248 
249 	if (voltage_info != NULL)
250 		return (ATOM_VOLTAGE_OBJECT_INFO *) &(voltage_info->v3);
251 	else
252 		return NULL;
253 }
254 
255 static const ATOM_VOLTAGE_OBJECT_V3 *atomctrl_lookup_voltage_type_v3(
256 		const ATOM_VOLTAGE_OBJECT_INFO_V3_1 * voltage_object_info_table,
257 		uint8_t voltage_type, uint8_t voltage_mode)
258 {
259 	unsigned int size = le16_to_cpu(voltage_object_info_table->sHeader.usStructureSize);
260 	unsigned int offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO_V3_1, asVoltageObj[0]);
261 	uint8_t *start = (uint8_t *)voltage_object_info_table;
262 
263 	while (offset < size) {
264 		const ATOM_VOLTAGE_OBJECT_V3 *voltage_object =
265 			(const ATOM_VOLTAGE_OBJECT_V3 *)(start + offset);
266 
267 		if (voltage_type == voltage_object->asGpioVoltageObj.sHeader.ucVoltageType &&
268 			voltage_mode == voltage_object->asGpioVoltageObj.sHeader.ucVoltageMode)
269 			return voltage_object;
270 
271 		offset += le16_to_cpu(voltage_object->asGpioVoltageObj.sHeader.usSize);
272 	}
273 
274 	return NULL;
275 }
276 
277 /**
278  * atomctrl_get_memory_pll_dividers_si
279  *
280  * @hwmgr:           input parameter: pointer to HwMgr
281  * @clock_value:     input parameter: memory clock
282  * @mpll_param:      output parameter: memory clock parameters
283  * @strobe_mode:     input parameter: 1 for strobe mode,  0 for performance mode
284  */
285 int atomctrl_get_memory_pll_dividers_si(
286 		struct pp_hwmgr *hwmgr,
287 		uint32_t clock_value,
288 		pp_atomctrl_memory_clock_param *mpll_param,
289 		bool strobe_mode)
290 {
291 	struct amdgpu_device *adev = hwmgr->adev;
292 	COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_1 mpll_parameters;
293 	int result;
294 
295 	mpll_parameters.ulClock = cpu_to_le32(clock_value);
296 	mpll_parameters.ucInputFlag = (uint8_t)((strobe_mode) ? 1 : 0);
297 
298 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
299 		 GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam),
300 		(uint32_t *)&mpll_parameters);
301 
302 	if (0 == result) {
303 		mpll_param->mpll_fb_divider.clk_frac =
304 			le16_to_cpu(mpll_parameters.ulFbDiv.usFbDivFrac);
305 		mpll_param->mpll_fb_divider.cl_kf =
306 			le16_to_cpu(mpll_parameters.ulFbDiv.usFbDiv);
307 		mpll_param->mpll_post_divider =
308 			(uint32_t)mpll_parameters.ucPostDiv;
309 		mpll_param->vco_mode =
310 			(uint32_t)(mpll_parameters.ucPllCntlFlag &
311 					MPLL_CNTL_FLAG_VCO_MODE_MASK);
312 		mpll_param->yclk_sel =
313 			(uint32_t)((mpll_parameters.ucPllCntlFlag &
314 						MPLL_CNTL_FLAG_BYPASS_DQ_PLL) ? 1 : 0);
315 		mpll_param->qdr =
316 			(uint32_t)((mpll_parameters.ucPllCntlFlag &
317 						MPLL_CNTL_FLAG_QDR_ENABLE) ? 1 : 0);
318 		mpll_param->half_rate =
319 			(uint32_t)((mpll_parameters.ucPllCntlFlag &
320 						MPLL_CNTL_FLAG_AD_HALF_RATE) ? 1 : 0);
321 		mpll_param->dll_speed =
322 			(uint32_t)(mpll_parameters.ucDllSpeed);
323 		mpll_param->bw_ctrl =
324 			(uint32_t)(mpll_parameters.ucBWCntl);
325 	}
326 
327 	return result;
328 }
329 
330 /**
331  * atomctrl_get_memory_pll_dividers_vi
332  *
333  * @hwmgr:                 input parameter: pointer to HwMgr
334  * @clock_value:           input parameter: memory clock
335  * @mpll_param:            output parameter: memory clock parameters
336  */
337 int atomctrl_get_memory_pll_dividers_vi(struct pp_hwmgr *hwmgr,
338 		uint32_t clock_value, pp_atomctrl_memory_clock_param *mpll_param)
339 {
340 	struct amdgpu_device *adev = hwmgr->adev;
341 	COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_2 mpll_parameters;
342 	int result;
343 
344 	mpll_parameters.ulClock.ulClock = cpu_to_le32(clock_value);
345 
346 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
347 			GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam),
348 			(uint32_t *)&mpll_parameters);
349 
350 	if (!result)
351 		mpll_param->mpll_post_divider =
352 				(uint32_t)mpll_parameters.ulClock.ucPostDiv;
353 
354 	return result;
355 }
356 
357 int atomctrl_get_memory_pll_dividers_ai(struct pp_hwmgr *hwmgr,
358 					uint32_t clock_value,
359 					pp_atomctrl_memory_clock_param_ai *mpll_param)
360 {
361 	struct amdgpu_device *adev = hwmgr->adev;
362 	COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_3 mpll_parameters = {{0}, 0, 0};
363 	int result;
364 
365 	mpll_parameters.ulClock.ulClock = cpu_to_le32(clock_value);
366 
367 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
368 			GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam),
369 			(uint32_t *)&mpll_parameters);
370 
371 	/* VEGAM's mpll takes sometime to finish computing */
372 	udelay(10);
373 
374 	if (!result) {
375 		mpll_param->ulMclk_fcw_int =
376 			le16_to_cpu(mpll_parameters.usMclk_fcw_int);
377 		mpll_param->ulMclk_fcw_frac =
378 			le16_to_cpu(mpll_parameters.usMclk_fcw_frac);
379 		mpll_param->ulClock =
380 			le32_to_cpu(mpll_parameters.ulClock.ulClock);
381 		mpll_param->ulPostDiv = mpll_parameters.ulClock.ucPostDiv;
382 	}
383 
384 	return result;
385 }
386 
387 int atomctrl_get_engine_pll_dividers_kong(struct pp_hwmgr *hwmgr,
388 					  uint32_t clock_value,
389 					  pp_atomctrl_clock_dividers_kong *dividers)
390 {
391 	struct amdgpu_device *adev = hwmgr->adev;
392 	COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 pll_parameters;
393 	int result;
394 
395 	pll_parameters.ulClock = cpu_to_le32(clock_value);
396 
397 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
398 		 GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL),
399 		(uint32_t *)&pll_parameters);
400 
401 	if (0 == result) {
402 		dividers->pll_post_divider = pll_parameters.ucPostDiv;
403 		dividers->real_clock = le32_to_cpu(pll_parameters.ulClock);
404 	}
405 
406 	return result;
407 }
408 
409 int atomctrl_get_engine_pll_dividers_vi(
410 		struct pp_hwmgr *hwmgr,
411 		uint32_t clock_value,
412 		pp_atomctrl_clock_dividers_vi *dividers)
413 {
414 	struct amdgpu_device *adev = hwmgr->adev;
415 	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 pll_patameters;
416 	int result;
417 
418 	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);
419 	pll_patameters.ulClock.ucPostDiv = COMPUTE_GPUCLK_INPUT_FLAG_SCLK;
420 
421 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
422 		 GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL),
423 		(uint32_t *)&pll_patameters);
424 
425 	if (0 == result) {
426 		dividers->pll_post_divider =
427 			pll_patameters.ulClock.ucPostDiv;
428 		dividers->real_clock =
429 			le32_to_cpu(pll_patameters.ulClock.ulClock);
430 
431 		dividers->ul_fb_div.ul_fb_div_frac =
432 			le16_to_cpu(pll_patameters.ulFbDiv.usFbDivFrac);
433 		dividers->ul_fb_div.ul_fb_div =
434 			le16_to_cpu(pll_patameters.ulFbDiv.usFbDiv);
435 
436 		dividers->uc_pll_ref_div =
437 			pll_patameters.ucPllRefDiv;
438 		dividers->uc_pll_post_div =
439 			pll_patameters.ucPllPostDiv;
440 		dividers->uc_pll_cntl_flag =
441 			pll_patameters.ucPllCntlFlag;
442 	}
443 
444 	return result;
445 }
446 
447 int atomctrl_get_engine_pll_dividers_ai(struct pp_hwmgr *hwmgr,
448 		uint32_t clock_value,
449 		pp_atomctrl_clock_dividers_ai *dividers)
450 {
451 	struct amdgpu_device *adev = hwmgr->adev;
452 	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_7 pll_patameters;
453 	int result;
454 
455 	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);
456 	pll_patameters.ulClock.ucPostDiv = COMPUTE_GPUCLK_INPUT_FLAG_SCLK;
457 
458 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
459 		 GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL),
460 		(uint32_t *)&pll_patameters);
461 
462 	if (0 == result) {
463 		dividers->usSclk_fcw_frac     = le16_to_cpu(pll_patameters.usSclk_fcw_frac);
464 		dividers->usSclk_fcw_int      = le16_to_cpu(pll_patameters.usSclk_fcw_int);
465 		dividers->ucSclkPostDiv       = pll_patameters.ucSclkPostDiv;
466 		dividers->ucSclkVcoMode       = pll_patameters.ucSclkVcoMode;
467 		dividers->ucSclkPllRange      = pll_patameters.ucSclkPllRange;
468 		dividers->ucSscEnable         = pll_patameters.ucSscEnable;
469 		dividers->usSsc_fcw1_frac     = le16_to_cpu(pll_patameters.usSsc_fcw1_frac);
470 		dividers->usSsc_fcw1_int      = le16_to_cpu(pll_patameters.usSsc_fcw1_int);
471 		dividers->usPcc_fcw_int       = le16_to_cpu(pll_patameters.usPcc_fcw_int);
472 		dividers->usSsc_fcw_slew_frac = le16_to_cpu(pll_patameters.usSsc_fcw_slew_frac);
473 		dividers->usPcc_fcw_slew_frac = le16_to_cpu(pll_patameters.usPcc_fcw_slew_frac);
474 	}
475 	return result;
476 }
477 
478 int atomctrl_get_dfs_pll_dividers_vi(
479 		struct pp_hwmgr *hwmgr,
480 		uint32_t clock_value,
481 		pp_atomctrl_clock_dividers_vi *dividers)
482 {
483 	struct amdgpu_device *adev = hwmgr->adev;
484 	COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 pll_patameters;
485 	int result;
486 
487 	pll_patameters.ulClock.ulClock = cpu_to_le32(clock_value);
488 	pll_patameters.ulClock.ucPostDiv =
489 		COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK;
490 
491 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
492 		 GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL),
493 		(uint32_t *)&pll_patameters);
494 
495 	if (0 == result) {
496 		dividers->pll_post_divider =
497 			pll_patameters.ulClock.ucPostDiv;
498 		dividers->real_clock =
499 			le32_to_cpu(pll_patameters.ulClock.ulClock);
500 
501 		dividers->ul_fb_div.ul_fb_div_frac =
502 			le16_to_cpu(pll_patameters.ulFbDiv.usFbDivFrac);
503 		dividers->ul_fb_div.ul_fb_div =
504 			le16_to_cpu(pll_patameters.ulFbDiv.usFbDiv);
505 
506 		dividers->uc_pll_ref_div =
507 			pll_patameters.ucPllRefDiv;
508 		dividers->uc_pll_post_div =
509 			pll_patameters.ucPllPostDiv;
510 		dividers->uc_pll_cntl_flag =
511 			pll_patameters.ucPllCntlFlag;
512 	}
513 
514 	return result;
515 }
516 
517 /*
518  * Get the reference clock in 10KHz
519  */
520 uint32_t atomctrl_get_reference_clock(struct pp_hwmgr *hwmgr)
521 {
522 	ATOM_FIRMWARE_INFO *fw_info;
523 	u8 frev, crev;
524 	u16 size;
525 	uint32_t clock;
526 
527 	fw_info = (ATOM_FIRMWARE_INFO *)
528 		smu_atom_get_data_table(hwmgr->adev,
529 			GetIndexIntoMasterTable(DATA, FirmwareInfo),
530 			&size, &frev, &crev);
531 
532 	if (fw_info == NULL)
533 		clock = 2700;
534 	else
535 		clock = (uint32_t)(le16_to_cpu(fw_info->usReferenceClock));
536 
537 	return clock;
538 }
539 
540 /*
541  * Returns true if the given voltage type is controlled by GPIO pins.
542  * voltage_type is one of SET_VOLTAGE_TYPE_ASIC_VDDC,
543  * SET_VOLTAGE_TYPE_ASIC_MVDDC, SET_VOLTAGE_TYPE_ASIC_MVDDQ.
544  * voltage_mode is one of ATOM_SET_VOLTAGE, ATOM_SET_VOLTAGE_PHASE
545  */
546 bool atomctrl_is_voltage_controlled_by_gpio_v3(
547 		struct pp_hwmgr *hwmgr,
548 		uint8_t voltage_type,
549 		uint8_t voltage_mode)
550 {
551 	ATOM_VOLTAGE_OBJECT_INFO_V3_1 *voltage_info =
552 		(ATOM_VOLTAGE_OBJECT_INFO_V3_1 *)get_voltage_info_table(hwmgr->adev);
553 	bool ret;
554 
555 	PP_ASSERT_WITH_CODE((NULL != voltage_info),
556 			"Could not find Voltage Table in BIOS.", return false;);
557 
558 	ret = (NULL != atomctrl_lookup_voltage_type_v3
559 			(voltage_info, voltage_type, voltage_mode)) ? true : false;
560 
561 	return ret;
562 }
563 
564 int atomctrl_get_voltage_table_v3(
565 		struct pp_hwmgr *hwmgr,
566 		uint8_t voltage_type,
567 		uint8_t voltage_mode,
568 		pp_atomctrl_voltage_table *voltage_table)
569 {
570 	ATOM_VOLTAGE_OBJECT_INFO_V3_1 *voltage_info =
571 		(ATOM_VOLTAGE_OBJECT_INFO_V3_1 *)get_voltage_info_table(hwmgr->adev);
572 	const ATOM_VOLTAGE_OBJECT_V3 *voltage_object;
573 	unsigned int i;
574 
575 	PP_ASSERT_WITH_CODE((NULL != voltage_info),
576 			"Could not find Voltage Table in BIOS.", return -1;);
577 
578 	voltage_object = atomctrl_lookup_voltage_type_v3
579 		(voltage_info, voltage_type, voltage_mode);
580 
581 	if (voltage_object == NULL)
582 		return -1;
583 
584 	PP_ASSERT_WITH_CODE(
585 			(voltage_object->asGpioVoltageObj.ucGpioEntryNum <=
586 			PP_ATOMCTRL_MAX_VOLTAGE_ENTRIES),
587 			"Too many voltage entries!",
588 			return -1;
589 			);
590 
591 	for (i = 0; i < voltage_object->asGpioVoltageObj.ucGpioEntryNum; i++) {
592 		voltage_table->entries[i].value =
593 			le16_to_cpu(voltage_object->asGpioVoltageObj.asVolGpioLut[i].usVoltageValue);
594 		voltage_table->entries[i].smio_low =
595 			le32_to_cpu(voltage_object->asGpioVoltageObj.asVolGpioLut[i].ulVoltageId);
596 	}
597 
598 	voltage_table->mask_low    =
599 		le32_to_cpu(voltage_object->asGpioVoltageObj.ulGpioMaskVal);
600 	voltage_table->count      =
601 		voltage_object->asGpioVoltageObj.ucGpioEntryNum;
602 	voltage_table->phase_delay =
603 		voltage_object->asGpioVoltageObj.ucPhaseDelay;
604 
605 	return 0;
606 }
607 
608 static bool atomctrl_lookup_gpio_pin(
609 		ATOM_GPIO_PIN_LUT * gpio_lookup_table,
610 		const uint32_t pinId,
611 		pp_atomctrl_gpio_pin_assignment *gpio_pin_assignment)
612 {
613 	unsigned int size = le16_to_cpu(gpio_lookup_table->sHeader.usStructureSize);
614 	unsigned int offset = offsetof(ATOM_GPIO_PIN_LUT, asGPIO_Pin[0]);
615 	uint8_t *start = (uint8_t *)gpio_lookup_table;
616 
617 	while (offset < size) {
618 		const ATOM_GPIO_PIN_ASSIGNMENT *pin_assignment =
619 			(const ATOM_GPIO_PIN_ASSIGNMENT *)(start + offset);
620 
621 		if (pinId == pin_assignment->ucGPIO_ID) {
622 			gpio_pin_assignment->uc_gpio_pin_bit_shift =
623 				pin_assignment->ucGpioPinBitShift;
624 			gpio_pin_assignment->us_gpio_pin_aindex =
625 				le16_to_cpu(pin_assignment->usGpioPin_AIndex);
626 			return true;
627 		}
628 
629 		offset += offsetof(ATOM_GPIO_PIN_ASSIGNMENT, ucGPIO_ID) + 1;
630 	}
631 
632 	return false;
633 }
634 
635 /*
636  * Private Function to get the PowerPlay Table Address.
637  * WARNING: The tabled returned by this function is in
638  * dynamically allocated memory.
639  * The caller has to release if by calling kfree.
640  */
641 static ATOM_GPIO_PIN_LUT *get_gpio_lookup_table(void *device)
642 {
643 	u8 frev, crev;
644 	u16 size;
645 	void *table_address;
646 
647 	table_address = (ATOM_GPIO_PIN_LUT *)
648 		smu_atom_get_data_table(device,
649 				GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT),
650 				&size, &frev, &crev);
651 
652 	PP_ASSERT_WITH_CODE((NULL != table_address),
653 			"Error retrieving BIOS Table Address!", return NULL;);
654 
655 	return (ATOM_GPIO_PIN_LUT *)table_address;
656 }
657 
658 /*
659  * Returns 1 if the given pin id find in lookup table.
660  */
661 bool atomctrl_get_pp_assign_pin(
662 		struct pp_hwmgr *hwmgr,
663 		const uint32_t pinId,
664 		pp_atomctrl_gpio_pin_assignment *gpio_pin_assignment)
665 {
666 	bool bRet = false;
667 	ATOM_GPIO_PIN_LUT *gpio_lookup_table =
668 		get_gpio_lookup_table(hwmgr->adev);
669 
670 	PP_ASSERT_WITH_CODE((NULL != gpio_lookup_table),
671 			"Could not find GPIO lookup Table in BIOS.", return false);
672 
673 	bRet = atomctrl_lookup_gpio_pin(gpio_lookup_table, pinId,
674 		gpio_pin_assignment);
675 
676 	return bRet;
677 }
678 
679 int atomctrl_calculate_voltage_evv_on_sclk(
680 		struct pp_hwmgr *hwmgr,
681 		uint8_t voltage_type,
682 		uint32_t sclk,
683 		uint16_t virtual_voltage_Id,
684 		uint16_t *voltage,
685 		uint16_t dpm_level,
686 		bool debug)
687 {
688 	ATOM_ASIC_PROFILING_INFO_V3_4 *getASICProfilingInfo;
689 	struct amdgpu_device *adev = hwmgr->adev;
690 	EFUSE_LINEAR_FUNC_PARAM sRO_fuse;
691 	EFUSE_LINEAR_FUNC_PARAM sCACm_fuse;
692 	EFUSE_LINEAR_FUNC_PARAM sCACb_fuse;
693 	EFUSE_LOGISTIC_FUNC_PARAM sKt_Beta_fuse;
694 	EFUSE_LOGISTIC_FUNC_PARAM sKv_m_fuse;
695 	EFUSE_LOGISTIC_FUNC_PARAM sKv_b_fuse;
696 	EFUSE_INPUT_PARAMETER sInput_FuseValues;
697 	READ_EFUSE_VALUE_PARAMETER sOutput_FuseValues;
698 
699 	uint32_t ul_RO_fused, ul_CACb_fused, ul_CACm_fused, ul_Kt_Beta_fused, ul_Kv_m_fused, ul_Kv_b_fused;
700 	fInt fSM_A0, fSM_A1, fSM_A2, fSM_A3, fSM_A4, fSM_A5, fSM_A6, fSM_A7;
701 	fInt fMargin_RO_a, fMargin_RO_b, fMargin_RO_c, fMargin_fixed, fMargin_FMAX_mean, fMargin_Plat_mean, fMargin_FMAX_sigma, fMargin_Plat_sigma, fMargin_DC_sigma;
702 	fInt fLkg_FT, repeat;
703 	fInt fMicro_FMAX, fMicro_CR, fSigma_FMAX, fSigma_CR, fSigma_DC, fDC_SCLK, fSquared_Sigma_DC, fSquared_Sigma_CR, fSquared_Sigma_FMAX;
704 	fInt fRLL_LoadLine, fDerateTDP, fVDDC_base, fA_Term, fC_Term, fB_Term, fRO_DC_margin;
705 	fInt fRO_fused, fCACm_fused, fCACb_fused, fKv_m_fused, fKv_b_fused, fKt_Beta_fused, fFT_Lkg_V0NORM;
706 	fInt fSclk_margin, fSclk, fEVV_V;
707 	fInt fV_min, fV_max, fT_prod, fLKG_Factor, fT_FT, fV_FT, fV_x, fTDP_Power, fTDP_Power_right, fTDP_Power_left, fTDP_Current, fV_NL;
708 	uint32_t ul_FT_Lkg_V0NORM;
709 	fInt fLn_MaxDivMin, fMin, fAverage, fRange;
710 	fInt fRoots[2];
711 	fInt fStepSize = GetScaledFraction(625, 100000);
712 
713 	int result;
714 
715 	getASICProfilingInfo = (ATOM_ASIC_PROFILING_INFO_V3_4 *)
716 			smu_atom_get_data_table(hwmgr->adev,
717 					GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo),
718 					NULL, NULL, NULL);
719 
720 	if (!getASICProfilingInfo)
721 		return -1;
722 
723 	if (getASICProfilingInfo->asHeader.ucTableFormatRevision < 3 ||
724 	    (getASICProfilingInfo->asHeader.ucTableFormatRevision == 3 &&
725 	     getASICProfilingInfo->asHeader.ucTableContentRevision < 4))
726 		return -1;
727 
728 	/*-----------------------------------------------------------
729 	 *GETTING MULTI-STEP PARAMETERS RELATED TO CURRENT DPM LEVEL
730 	 *-----------------------------------------------------------
731 	 */
732 	fRLL_LoadLine = Divide(getASICProfilingInfo->ulLoadLineSlop, 1000);
733 
734 	switch (dpm_level) {
735 	case 1:
736 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM1), 1000);
737 		break;
738 	case 2:
739 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM2), 1000);
740 		break;
741 	case 3:
742 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM3), 1000);
743 		break;
744 	case 4:
745 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM4), 1000);
746 		break;
747 	case 5:
748 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM5), 1000);
749 		break;
750 	case 6:
751 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM6), 1000);
752 		break;
753 	case 7:
754 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM7), 1000);
755 		break;
756 	default:
757 		pr_err("DPM Level not supported\n");
758 		fDerateTDP = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulTdpDerateDPM0), 1000);
759 	}
760 
761 	/*-------------------------
762 	 * DECODING FUSE VALUES
763 	 * ------------------------
764 	 */
765 	/*Decode RO_Fused*/
766 	sRO_fuse = getASICProfilingInfo->sRoFuse;
767 
768 	sInput_FuseValues.usEfuseIndex = sRO_fuse.usEfuseIndex;
769 	sInput_FuseValues.ucBitShift = sRO_fuse.ucEfuseBitLSB;
770 	sInput_FuseValues.ucBitLength = sRO_fuse.ucEfuseLength;
771 
772 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
773 
774 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
775 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
776 			(uint32_t *)&sOutput_FuseValues);
777 
778 	if (result)
779 		return result;
780 
781 	/* Finally, the actual fuse value */
782 	ul_RO_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
783 	fMin = GetScaledFraction(le32_to_cpu(sRO_fuse.ulEfuseMin), 1);
784 	fRange = GetScaledFraction(le32_to_cpu(sRO_fuse.ulEfuseEncodeRange), 1);
785 	fRO_fused = fDecodeLinearFuse(ul_RO_fused, fMin, fRange, sRO_fuse.ucEfuseLength);
786 
787 	sCACm_fuse = getASICProfilingInfo->sCACm;
788 
789 	sInput_FuseValues.usEfuseIndex = sCACm_fuse.usEfuseIndex;
790 	sInput_FuseValues.ucBitShift = sCACm_fuse.ucEfuseBitLSB;
791 	sInput_FuseValues.ucBitLength = sCACm_fuse.ucEfuseLength;
792 
793 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
794 
795 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
796 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
797 			(uint32_t *)&sOutput_FuseValues);
798 
799 	if (result)
800 		return result;
801 
802 	ul_CACm_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
803 	fMin = GetScaledFraction(le32_to_cpu(sCACm_fuse.ulEfuseMin), 1000);
804 	fRange = GetScaledFraction(le32_to_cpu(sCACm_fuse.ulEfuseEncodeRange), 1000);
805 
806 	fCACm_fused = fDecodeLinearFuse(ul_CACm_fused, fMin, fRange, sCACm_fuse.ucEfuseLength);
807 
808 	sCACb_fuse = getASICProfilingInfo->sCACb;
809 
810 	sInput_FuseValues.usEfuseIndex = sCACb_fuse.usEfuseIndex;
811 	sInput_FuseValues.ucBitShift = sCACb_fuse.ucEfuseBitLSB;
812 	sInput_FuseValues.ucBitLength = sCACb_fuse.ucEfuseLength;
813 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
814 
815 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
816 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
817 			(uint32_t *)&sOutput_FuseValues);
818 
819 	if (result)
820 		return result;
821 
822 	ul_CACb_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
823 	fMin = GetScaledFraction(le32_to_cpu(sCACb_fuse.ulEfuseMin), 1000);
824 	fRange = GetScaledFraction(le32_to_cpu(sCACb_fuse.ulEfuseEncodeRange), 1000);
825 
826 	fCACb_fused = fDecodeLinearFuse(ul_CACb_fused, fMin, fRange, sCACb_fuse.ucEfuseLength);
827 
828 	sKt_Beta_fuse = getASICProfilingInfo->sKt_b;
829 
830 	sInput_FuseValues.usEfuseIndex = sKt_Beta_fuse.usEfuseIndex;
831 	sInput_FuseValues.ucBitShift = sKt_Beta_fuse.ucEfuseBitLSB;
832 	sInput_FuseValues.ucBitLength = sKt_Beta_fuse.ucEfuseLength;
833 
834 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
835 
836 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
837 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
838 			(uint32_t *)&sOutput_FuseValues);
839 
840 	if (result)
841 		return result;
842 
843 	ul_Kt_Beta_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
844 	fAverage = GetScaledFraction(le32_to_cpu(sKt_Beta_fuse.ulEfuseEncodeAverage), 1000);
845 	fRange = GetScaledFraction(le32_to_cpu(sKt_Beta_fuse.ulEfuseEncodeRange), 1000);
846 
847 	fKt_Beta_fused = fDecodeLogisticFuse(ul_Kt_Beta_fused,
848 			fAverage, fRange, sKt_Beta_fuse.ucEfuseLength);
849 
850 	sKv_m_fuse = getASICProfilingInfo->sKv_m;
851 
852 	sInput_FuseValues.usEfuseIndex = sKv_m_fuse.usEfuseIndex;
853 	sInput_FuseValues.ucBitShift = sKv_m_fuse.ucEfuseBitLSB;
854 	sInput_FuseValues.ucBitLength = sKv_m_fuse.ucEfuseLength;
855 
856 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
857 
858 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
859 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
860 			(uint32_t *)&sOutput_FuseValues);
861 	if (result)
862 		return result;
863 
864 	ul_Kv_m_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
865 	fAverage = GetScaledFraction(le32_to_cpu(sKv_m_fuse.ulEfuseEncodeAverage), 1000);
866 	fRange = GetScaledFraction((le32_to_cpu(sKv_m_fuse.ulEfuseEncodeRange) & 0x7fffffff), 1000);
867 	fRange = fMultiply(fRange, ConvertToFraction(-1));
868 
869 	fKv_m_fused = fDecodeLogisticFuse(ul_Kv_m_fused,
870 			fAverage, fRange, sKv_m_fuse.ucEfuseLength);
871 
872 	sKv_b_fuse = getASICProfilingInfo->sKv_b;
873 
874 	sInput_FuseValues.usEfuseIndex = sKv_b_fuse.usEfuseIndex;
875 	sInput_FuseValues.ucBitShift = sKv_b_fuse.ucEfuseBitLSB;
876 	sInput_FuseValues.ucBitLength = sKv_b_fuse.ucEfuseLength;
877 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
878 
879 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
880 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
881 			(uint32_t *)&sOutput_FuseValues);
882 
883 	if (result)
884 		return result;
885 
886 	ul_Kv_b_fused = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
887 	fAverage = GetScaledFraction(le32_to_cpu(sKv_b_fuse.ulEfuseEncodeAverage), 1000);
888 	fRange = GetScaledFraction(le32_to_cpu(sKv_b_fuse.ulEfuseEncodeRange), 1000);
889 
890 	fKv_b_fused = fDecodeLogisticFuse(ul_Kv_b_fused,
891 			fAverage, fRange, sKv_b_fuse.ucEfuseLength);
892 
893 	/* Decoding the Leakage - No special struct container */
894 	/*
895 	 * usLkgEuseIndex=56
896 	 * ucLkgEfuseBitLSB=6
897 	 * ucLkgEfuseLength=10
898 	 * ulLkgEncodeLn_MaxDivMin=69077
899 	 * ulLkgEncodeMax=1000000
900 	 * ulLkgEncodeMin=1000
901 	 * ulEfuseLogisticAlpha=13
902 	 */
903 
904 	sInput_FuseValues.usEfuseIndex = getASICProfilingInfo->usLkgEuseIndex;
905 	sInput_FuseValues.ucBitShift = getASICProfilingInfo->ucLkgEfuseBitLSB;
906 	sInput_FuseValues.ucBitLength = getASICProfilingInfo->ucLkgEfuseLength;
907 
908 	sOutput_FuseValues.sEfuse = sInput_FuseValues;
909 
910 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
911 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
912 			(uint32_t *)&sOutput_FuseValues);
913 
914 	if (result)
915 		return result;
916 
917 	ul_FT_Lkg_V0NORM = le32_to_cpu(sOutput_FuseValues.ulEfuseValue);
918 	fLn_MaxDivMin = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLkgEncodeLn_MaxDivMin), 10000);
919 	fMin = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLkgEncodeMin), 10000);
920 
921 	fFT_Lkg_V0NORM = fDecodeLeakageID(ul_FT_Lkg_V0NORM,
922 			fLn_MaxDivMin, fMin, getASICProfilingInfo->ucLkgEfuseLength);
923 	fLkg_FT = fFT_Lkg_V0NORM;
924 
925 	/*-------------------------------------------
926 	 * PART 2 - Grabbing all required values
927 	 *-------------------------------------------
928 	 */
929 	fSM_A0 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A0), 1000000),
930 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A0_sign)));
931 	fSM_A1 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A1), 1000000),
932 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A1_sign)));
933 	fSM_A2 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A2), 100000),
934 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A2_sign)));
935 	fSM_A3 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A3), 1000000),
936 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A3_sign)));
937 	fSM_A4 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A4), 1000000),
938 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A4_sign)));
939 	fSM_A5 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A5), 1000),
940 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A5_sign)));
941 	fSM_A6 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A6), 1000),
942 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A6_sign)));
943 	fSM_A7 = fMultiply(GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulSM_A7), 1000),
944 			ConvertToFraction(uPow(-1, getASICProfilingInfo->ucSM_A7_sign)));
945 
946 	fMargin_RO_a = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_a));
947 	fMargin_RO_b = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_b));
948 	fMargin_RO_c = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_RO_c));
949 
950 	fMargin_fixed = ConvertToFraction(le32_to_cpu(getASICProfilingInfo->ulMargin_fixed));
951 
952 	fMargin_FMAX_mean = GetScaledFraction(
953 		le32_to_cpu(getASICProfilingInfo->ulMargin_Fmax_mean), 10000);
954 	fMargin_Plat_mean = GetScaledFraction(
955 		le32_to_cpu(getASICProfilingInfo->ulMargin_plat_mean), 10000);
956 	fMargin_FMAX_sigma = GetScaledFraction(
957 		le32_to_cpu(getASICProfilingInfo->ulMargin_Fmax_sigma), 10000);
958 	fMargin_Plat_sigma = GetScaledFraction(
959 		le32_to_cpu(getASICProfilingInfo->ulMargin_plat_sigma), 10000);
960 
961 	fMargin_DC_sigma = GetScaledFraction(
962 		le32_to_cpu(getASICProfilingInfo->ulMargin_DC_sigma), 100);
963 	fMargin_DC_sigma = fDivide(fMargin_DC_sigma, ConvertToFraction(1000));
964 
965 	fCACm_fused = fDivide(fCACm_fused, ConvertToFraction(100));
966 	fCACb_fused = fDivide(fCACb_fused, ConvertToFraction(100));
967 	fKt_Beta_fused = fDivide(fKt_Beta_fused, ConvertToFraction(100));
968 	fKv_m_fused =  fNegate(fDivide(fKv_m_fused, ConvertToFraction(100)));
969 	fKv_b_fused = fDivide(fKv_b_fused, ConvertToFraction(10));
970 
971 	fSclk = GetScaledFraction(sclk, 100);
972 
973 	fV_max = fDivide(GetScaledFraction(
974 				 le32_to_cpu(getASICProfilingInfo->ulMaxVddc), 1000), ConvertToFraction(4));
975 	fT_prod = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulBoardCoreTemp), 10);
976 	fLKG_Factor = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulEvvLkgFactor), 100);
977 	fT_FT = GetScaledFraction(le32_to_cpu(getASICProfilingInfo->ulLeakageTemp), 10);
978 	fV_FT = fDivide(GetScaledFraction(
979 				le32_to_cpu(getASICProfilingInfo->ulLeakageVoltage), 1000), ConvertToFraction(4));
980 	fV_min = fDivide(GetScaledFraction(
981 				 le32_to_cpu(getASICProfilingInfo->ulMinVddc), 1000), ConvertToFraction(4));
982 
983 	/*-----------------------
984 	 * PART 3
985 	 *-----------------------
986 	 */
987 
988 	fA_Term = fAdd(fMargin_RO_a, fAdd(fMultiply(fSM_A4, fSclk), fSM_A5));
989 	fB_Term = fAdd(fAdd(fMultiply(fSM_A2, fSclk), fSM_A6), fMargin_RO_b);
990 	fC_Term = fAdd(fMargin_RO_c,
991 			fAdd(fMultiply(fSM_A0, fLkg_FT),
992 			fAdd(fMultiply(fSM_A1, fMultiply(fLkg_FT, fSclk)),
993 			fAdd(fMultiply(fSM_A3, fSclk),
994 			fSubtract(fSM_A7, fRO_fused)))));
995 
996 	fVDDC_base = fSubtract(fRO_fused,
997 			fSubtract(fMargin_RO_c,
998 					fSubtract(fSM_A3, fMultiply(fSM_A1, fSclk))));
999 	fVDDC_base = fDivide(fVDDC_base, fAdd(fMultiply(fSM_A0, fSclk), fSM_A2));
1000 
1001 	repeat = fSubtract(fVDDC_base,
1002 			fDivide(fMargin_DC_sigma, ConvertToFraction(1000)));
1003 
1004 	fRO_DC_margin = fAdd(fMultiply(fMargin_RO_a,
1005 			fGetSquare(repeat)),
1006 			fAdd(fMultiply(fMargin_RO_b, repeat),
1007 			fMargin_RO_c));
1008 
1009 	fDC_SCLK = fSubtract(fRO_fused,
1010 			fSubtract(fRO_DC_margin,
1011 			fSubtract(fSM_A3,
1012 			fMultiply(fSM_A2, repeat))));
1013 	fDC_SCLK = fDivide(fDC_SCLK, fAdd(fMultiply(fSM_A0, repeat), fSM_A1));
1014 
1015 	fSigma_DC = fSubtract(fSclk, fDC_SCLK);
1016 
1017 	fMicro_FMAX = fMultiply(fSclk, fMargin_FMAX_mean);
1018 	fMicro_CR = fMultiply(fSclk, fMargin_Plat_mean);
1019 	fSigma_FMAX = fMultiply(fSclk, fMargin_FMAX_sigma);
1020 	fSigma_CR = fMultiply(fSclk, fMargin_Plat_sigma);
1021 
1022 	fSquared_Sigma_DC = fGetSquare(fSigma_DC);
1023 	fSquared_Sigma_CR = fGetSquare(fSigma_CR);
1024 	fSquared_Sigma_FMAX = fGetSquare(fSigma_FMAX);
1025 
1026 	fSclk_margin = fAdd(fMicro_FMAX,
1027 			fAdd(fMicro_CR,
1028 			fAdd(fMargin_fixed,
1029 			fSqrt(fAdd(fSquared_Sigma_FMAX,
1030 			fAdd(fSquared_Sigma_DC, fSquared_Sigma_CR))))));
1031 	/*
1032 	 fA_Term = fSM_A4 * (fSclk + fSclk_margin) + fSM_A5;
1033 	 fB_Term = fSM_A2 * (fSclk + fSclk_margin) + fSM_A6;
1034 	 fC_Term = fRO_DC_margin + fSM_A0 * fLkg_FT + fSM_A1 * fLkg_FT * (fSclk + fSclk_margin) + fSM_A3 * (fSclk + fSclk_margin) + fSM_A7 - fRO_fused;
1035 	 */
1036 
1037 	fA_Term = fAdd(fMultiply(fSM_A4, fAdd(fSclk, fSclk_margin)), fSM_A5);
1038 	fB_Term = fAdd(fMultiply(fSM_A2, fAdd(fSclk, fSclk_margin)), fSM_A6);
1039 	fC_Term = fAdd(fRO_DC_margin,
1040 			fAdd(fMultiply(fSM_A0, fLkg_FT),
1041 			fAdd(fMultiply(fMultiply(fSM_A1, fLkg_FT),
1042 			fAdd(fSclk, fSclk_margin)),
1043 			fAdd(fMultiply(fSM_A3,
1044 			fAdd(fSclk, fSclk_margin)),
1045 			fSubtract(fSM_A7, fRO_fused)))));
1046 
1047 	SolveQuadracticEqn(fA_Term, fB_Term, fC_Term, fRoots);
1048 
1049 	if (GreaterThan(fRoots[0], fRoots[1]))
1050 		fEVV_V = fRoots[1];
1051 	else
1052 		fEVV_V = fRoots[0];
1053 
1054 	if (GreaterThan(fV_min, fEVV_V))
1055 		fEVV_V = fV_min;
1056 	else if (GreaterThan(fEVV_V, fV_max))
1057 		fEVV_V = fSubtract(fV_max, fStepSize);
1058 
1059 	fEVV_V = fRoundUpByStepSize(fEVV_V, fStepSize, 0);
1060 
1061 	/*-----------------
1062 	 * PART 4
1063 	 *-----------------
1064 	 */
1065 
1066 	fV_x = fV_min;
1067 
1068 	while (GreaterThan(fAdd(fV_max, fStepSize), fV_x)) {
1069 		fTDP_Power_left = fMultiply(fMultiply(fMultiply(fAdd(
1070 				fMultiply(fCACm_fused, fV_x), fCACb_fused), fSclk),
1071 				fGetSquare(fV_x)), fDerateTDP);
1072 
1073 		fTDP_Power_right = fMultiply(fFT_Lkg_V0NORM, fMultiply(fLKG_Factor,
1074 				fMultiply(fExponential(fMultiply(fAdd(fMultiply(fKv_m_fused,
1075 				fT_prod), fKv_b_fused), fV_x)), fV_x)));
1076 		fTDP_Power_right = fMultiply(fTDP_Power_right, fExponential(fMultiply(
1077 				fKt_Beta_fused, fT_prod)));
1078 		fTDP_Power_right = fDivide(fTDP_Power_right, fExponential(fMultiply(
1079 				fAdd(fMultiply(fKv_m_fused, fT_prod), fKv_b_fused), fV_FT)));
1080 		fTDP_Power_right = fDivide(fTDP_Power_right, fExponential(fMultiply(
1081 				fKt_Beta_fused, fT_FT)));
1082 
1083 		fTDP_Power = fAdd(fTDP_Power_left, fTDP_Power_right);
1084 
1085 		fTDP_Current = fDivide(fTDP_Power, fV_x);
1086 
1087 		fV_NL = fAdd(fV_x, fDivide(fMultiply(fTDP_Current, fRLL_LoadLine),
1088 				ConvertToFraction(10)));
1089 
1090 		fV_NL = fRoundUpByStepSize(fV_NL, fStepSize, 0);
1091 
1092 		if (GreaterThan(fV_max, fV_NL) &&
1093 			(GreaterThan(fV_NL, fEVV_V) ||
1094 			Equal(fV_NL, fEVV_V))) {
1095 			fV_NL = fMultiply(fV_NL, ConvertToFraction(1000));
1096 
1097 			*voltage = (uint16_t)fV_NL.partial.real;
1098 			break;
1099 		} else
1100 			fV_x = fAdd(fV_x, fStepSize);
1101 	}
1102 
1103 	return result;
1104 }
1105 
1106 /**
1107  * atomctrl_get_voltage_evv_on_sclk: gets voltage via call to ATOM COMMAND table.
1108  * @hwmgr:              input: pointer to hwManager
1109  * @voltage_type:       input: type of EVV voltage VDDC or VDDGFX
1110  * @sclk:               input: in 10Khz unit. DPM state SCLK frequency
1111  *		         which is define in PPTable SCLK/VDDC dependence
1112  *			 table associated with this virtual_voltage_Id
1113  * @virtual_voltage_Id: input: voltage id which match per voltage DPM state: 0xff01, 0xff02.. 0xff08
1114  * @voltage: 	        output: real voltage level in unit of mv
1115  */
1116 int atomctrl_get_voltage_evv_on_sclk(
1117 		struct pp_hwmgr *hwmgr,
1118 		uint8_t voltage_type,
1119 		uint32_t sclk, uint16_t virtual_voltage_Id,
1120 		uint16_t *voltage)
1121 {
1122 	struct amdgpu_device *adev = hwmgr->adev;
1123 	GET_VOLTAGE_INFO_INPUT_PARAMETER_V1_2 get_voltage_info_param_space;
1124 	int result;
1125 
1126 	get_voltage_info_param_space.ucVoltageType   =
1127 		voltage_type;
1128 	get_voltage_info_param_space.ucVoltageMode   =
1129 		ATOM_GET_VOLTAGE_EVV_VOLTAGE;
1130 	get_voltage_info_param_space.usVoltageLevel  =
1131 		cpu_to_le16(virtual_voltage_Id);
1132 	get_voltage_info_param_space.ulSCLKFreq      =
1133 		cpu_to_le32(sclk);
1134 
1135 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1136 			GetIndexIntoMasterTable(COMMAND, GetVoltageInfo),
1137 			(uint32_t *)&get_voltage_info_param_space);
1138 
1139 	*voltage = result ? 0 :
1140 			le16_to_cpu(((GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 *)
1141 				(&get_voltage_info_param_space))->usVoltageLevel);
1142 
1143 	return result;
1144 }
1145 
1146 /**
1147  * atomctrl_get_voltage_evv: gets voltage via call to ATOM COMMAND table.
1148  * @hwmgr:              input: pointer to hwManager
1149  * @virtual_voltage_id: input: voltage id which match per voltage DPM state: 0xff01, 0xff02.. 0xff08
1150  * @voltage: 	       output: real voltage level in unit of mv
1151  */
1152 int atomctrl_get_voltage_evv(struct pp_hwmgr *hwmgr,
1153 			     uint16_t virtual_voltage_id,
1154 			     uint16_t *voltage)
1155 {
1156 	struct amdgpu_device *adev = hwmgr->adev;
1157 	GET_VOLTAGE_INFO_INPUT_PARAMETER_V1_2 get_voltage_info_param_space;
1158 	int result;
1159 	int entry_id;
1160 
1161 	/* search for leakage voltage ID 0xff01 ~ 0xff08 and sckl */
1162 	for (entry_id = 0; entry_id < hwmgr->dyn_state.vddc_dependency_on_sclk->count; entry_id++) {
1163 		if (hwmgr->dyn_state.vddc_dependency_on_sclk->entries[entry_id].v == virtual_voltage_id) {
1164 			/* found */
1165 			break;
1166 		}
1167 	}
1168 
1169 	if (entry_id >= hwmgr->dyn_state.vddc_dependency_on_sclk->count) {
1170 	        pr_debug("Can't find requested voltage id in vddc_dependency_on_sclk table!\n");
1171 	        return -EINVAL;
1172 	}
1173 
1174 	get_voltage_info_param_space.ucVoltageType = VOLTAGE_TYPE_VDDC;
1175 	get_voltage_info_param_space.ucVoltageMode = ATOM_GET_VOLTAGE_EVV_VOLTAGE;
1176 	get_voltage_info_param_space.usVoltageLevel = virtual_voltage_id;
1177 	get_voltage_info_param_space.ulSCLKFreq =
1178 		cpu_to_le32(hwmgr->dyn_state.vddc_dependency_on_sclk->entries[entry_id].clk);
1179 
1180 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1181 			GetIndexIntoMasterTable(COMMAND, GetVoltageInfo),
1182 			(uint32_t *)&get_voltage_info_param_space);
1183 
1184 	if (0 != result)
1185 		return result;
1186 
1187 	*voltage = le16_to_cpu(((GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 *)
1188 				(&get_voltage_info_param_space))->usVoltageLevel);
1189 
1190 	return result;
1191 }
1192 
1193 /*
1194  * Get the mpll reference clock in 10KHz
1195  */
1196 uint32_t atomctrl_get_mpll_reference_clock(struct pp_hwmgr *hwmgr)
1197 {
1198 	ATOM_COMMON_TABLE_HEADER *fw_info;
1199 	uint32_t clock;
1200 	u8 frev, crev;
1201 	u16 size;
1202 
1203 	fw_info = (ATOM_COMMON_TABLE_HEADER *)
1204 		smu_atom_get_data_table(hwmgr->adev,
1205 				GetIndexIntoMasterTable(DATA, FirmwareInfo),
1206 				&size, &frev, &crev);
1207 
1208 	if (fw_info == NULL)
1209 		clock = 2700;
1210 	else {
1211 		if ((fw_info->ucTableFormatRevision == 2) &&
1212 			(le16_to_cpu(fw_info->usStructureSize) >= sizeof(ATOM_FIRMWARE_INFO_V2_1))) {
1213 			ATOM_FIRMWARE_INFO_V2_1 *fwInfo_2_1 =
1214 				(ATOM_FIRMWARE_INFO_V2_1 *)fw_info;
1215 			clock = (uint32_t)(le16_to_cpu(fwInfo_2_1->usMemoryReferenceClock));
1216 		} else {
1217 			ATOM_FIRMWARE_INFO *fwInfo_0_0 =
1218 				(ATOM_FIRMWARE_INFO *)fw_info;
1219 			clock = (uint32_t)(le16_to_cpu(fwInfo_0_0->usReferenceClock));
1220 		}
1221 	}
1222 
1223 	return clock;
1224 }
1225 
1226 /*
1227  * Get the asic internal spread spectrum table
1228  */
1229 static ATOM_ASIC_INTERNAL_SS_INFO *asic_internal_ss_get_ss_table(void *device)
1230 {
1231 	ATOM_ASIC_INTERNAL_SS_INFO *table = NULL;
1232 	u8 frev, crev;
1233 	u16 size;
1234 
1235 	table = (ATOM_ASIC_INTERNAL_SS_INFO *)
1236 		smu_atom_get_data_table(device,
1237 			GetIndexIntoMasterTable(DATA, ASIC_InternalSS_Info),
1238 			&size, &frev, &crev);
1239 
1240 	return table;
1241 }
1242 
1243 bool atomctrl_is_asic_internal_ss_supported(struct pp_hwmgr *hwmgr)
1244 {
1245 	ATOM_ASIC_INTERNAL_SS_INFO *table =
1246 		asic_internal_ss_get_ss_table(hwmgr->adev);
1247 
1248 	if (table)
1249 		return true;
1250 	else
1251 		return false;
1252 }
1253 
1254 /*
1255  * Get the asic internal spread spectrum assignment
1256  */
1257 static int asic_internal_ss_get_ss_asignment(struct pp_hwmgr *hwmgr,
1258 		const uint8_t clockSource,
1259 		const uint32_t clockSpeed,
1260 		pp_atomctrl_internal_ss_info *ssEntry)
1261 {
1262 	ATOM_ASIC_INTERNAL_SS_INFO *table;
1263 	ATOM_ASIC_SS_ASSIGNMENT *ssInfo;
1264 	int entry_found = 0;
1265 
1266 	memset(ssEntry, 0x00, sizeof(pp_atomctrl_internal_ss_info));
1267 
1268 	table = asic_internal_ss_get_ss_table(hwmgr->adev);
1269 
1270 	if (NULL == table)
1271 		return -1;
1272 
1273 	ssInfo = &table->asSpreadSpectrum[0];
1274 
1275 	while (((uint8_t *)ssInfo - (uint8_t *)table) <
1276 		le16_to_cpu(table->sHeader.usStructureSize)) {
1277 		if ((clockSource == ssInfo->ucClockIndication) &&
1278 			((uint32_t)clockSpeed <= le32_to_cpu(ssInfo->ulTargetClockRange))) {
1279 			entry_found = 1;
1280 			break;
1281 		}
1282 
1283 		ssInfo = (ATOM_ASIC_SS_ASSIGNMENT *)((uint8_t *)ssInfo +
1284 				sizeof(ATOM_ASIC_SS_ASSIGNMENT));
1285 	}
1286 
1287 	if (entry_found) {
1288 		ssEntry->speed_spectrum_percentage =
1289 			le16_to_cpu(ssInfo->usSpreadSpectrumPercentage);
1290 		ssEntry->speed_spectrum_rate = le16_to_cpu(ssInfo->usSpreadRateInKhz);
1291 
1292 		if (((GET_DATA_TABLE_MAJOR_REVISION(table) == 2) &&
1293 			(GET_DATA_TABLE_MINOR_REVISION(table) >= 2)) ||
1294 			(GET_DATA_TABLE_MAJOR_REVISION(table) == 3)) {
1295 			ssEntry->speed_spectrum_rate /= 100;
1296 		}
1297 
1298 		switch (ssInfo->ucSpreadSpectrumMode) {
1299 		case 0:
1300 			ssEntry->speed_spectrum_mode =
1301 				pp_atomctrl_spread_spectrum_mode_down;
1302 			break;
1303 		case 1:
1304 			ssEntry->speed_spectrum_mode =
1305 				pp_atomctrl_spread_spectrum_mode_center;
1306 			break;
1307 		default:
1308 			ssEntry->speed_spectrum_mode =
1309 				pp_atomctrl_spread_spectrum_mode_down;
1310 			break;
1311 		}
1312 	}
1313 
1314 	return entry_found ? 0 : 1;
1315 }
1316 
1317 /*
1318  * Get the memory clock spread spectrum info
1319  */
1320 int atomctrl_get_memory_clock_spread_spectrum(
1321 		struct pp_hwmgr *hwmgr,
1322 		const uint32_t memory_clock,
1323 		pp_atomctrl_internal_ss_info *ssInfo)
1324 {
1325 	return asic_internal_ss_get_ss_asignment(hwmgr,
1326 			ASIC_INTERNAL_MEMORY_SS, memory_clock, ssInfo);
1327 }
1328 
1329 /*
1330  * Get the engine clock spread spectrum info
1331  */
1332 int atomctrl_get_engine_clock_spread_spectrum(
1333 		struct pp_hwmgr *hwmgr,
1334 		const uint32_t engine_clock,
1335 		pp_atomctrl_internal_ss_info *ssInfo)
1336 {
1337 	return asic_internal_ss_get_ss_asignment(hwmgr,
1338 			ASIC_INTERNAL_ENGINE_SS, engine_clock, ssInfo);
1339 }
1340 
1341 int atomctrl_read_efuse(struct pp_hwmgr *hwmgr, uint16_t start_index,
1342 		uint16_t end_index, uint32_t *efuse)
1343 {
1344 	struct amdgpu_device *adev = hwmgr->adev;
1345 	uint32_t mask;
1346 	int result;
1347 	READ_EFUSE_VALUE_PARAMETER efuse_param;
1348 
1349 	if ((end_index - start_index)  == 31)
1350 		mask = 0xFFFFFFFF;
1351 	else
1352 		mask = (1 << ((end_index - start_index) + 1)) - 1;
1353 
1354 	efuse_param.sEfuse.usEfuseIndex = cpu_to_le16((start_index / 32) * 4);
1355 	efuse_param.sEfuse.ucBitShift = (uint8_t)
1356 			(start_index - ((start_index / 32) * 32));
1357 	efuse_param.sEfuse.ucBitLength  = (uint8_t)
1358 			((end_index - start_index) + 1);
1359 
1360 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1361 			GetIndexIntoMasterTable(COMMAND, ReadEfuseValue),
1362 			(uint32_t *)&efuse_param);
1363 	*efuse = result ? 0 : le32_to_cpu(efuse_param.ulEfuseValue) & mask;
1364 
1365 	return result;
1366 }
1367 
1368 int atomctrl_set_ac_timing_ai(struct pp_hwmgr *hwmgr, uint32_t memory_clock,
1369 			      uint8_t level)
1370 {
1371 	struct amdgpu_device *adev = hwmgr->adev;
1372 	DYNAMICE_MEMORY_SETTINGS_PARAMETER_V2_1 memory_clock_parameters;
1373 	int result;
1374 
1375 	memory_clock_parameters.asDPMMCReg.ulClock.ulClockFreq =
1376 		memory_clock & SET_CLOCK_FREQ_MASK;
1377 	memory_clock_parameters.asDPMMCReg.ulClock.ulComputeClockFlag =
1378 		ADJUST_MC_SETTING_PARAM;
1379 	memory_clock_parameters.asDPMMCReg.ucMclkDPMState = level;
1380 
1381 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1382 		 GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings),
1383 		(uint32_t *)&memory_clock_parameters);
1384 
1385 	return result;
1386 }
1387 
1388 int atomctrl_get_voltage_evv_on_sclk_ai(struct pp_hwmgr *hwmgr, uint8_t voltage_type,
1389 				uint32_t sclk, uint16_t virtual_voltage_Id, uint32_t *voltage)
1390 {
1391 	struct amdgpu_device *adev = hwmgr->adev;
1392 	int result;
1393 	GET_VOLTAGE_INFO_INPUT_PARAMETER_V1_3 get_voltage_info_param_space;
1394 
1395 	get_voltage_info_param_space.ucVoltageType = voltage_type;
1396 	get_voltage_info_param_space.ucVoltageMode = ATOM_GET_VOLTAGE_EVV_VOLTAGE;
1397 	get_voltage_info_param_space.usVoltageLevel = cpu_to_le16(virtual_voltage_Id);
1398 	get_voltage_info_param_space.ulSCLKFreq = cpu_to_le32(sclk);
1399 
1400 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1401 			GetIndexIntoMasterTable(COMMAND, GetVoltageInfo),
1402 			(uint32_t *)&get_voltage_info_param_space);
1403 
1404 	*voltage = result ? 0 :
1405 		le32_to_cpu(((GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_3 *)(&get_voltage_info_param_space))->ulVoltageLevel);
1406 
1407 	return result;
1408 }
1409 
1410 int atomctrl_get_smc_sclk_range_table(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl_sclk_range_table *table)
1411 {
1412 
1413 	int i;
1414 	u8 frev, crev;
1415 	u16 size;
1416 
1417 	ATOM_SMU_INFO_V2_1 *psmu_info =
1418 		(ATOM_SMU_INFO_V2_1 *)smu_atom_get_data_table(hwmgr->adev,
1419 			GetIndexIntoMasterTable(DATA, SMU_Info),
1420 			&size, &frev, &crev);
1421 
1422 
1423 	for (i = 0; i < psmu_info->ucSclkEntryNum; i++) {
1424 		table->entry[i].ucVco_setting = psmu_info->asSclkFcwRangeEntry[i].ucVco_setting;
1425 		table->entry[i].ucPostdiv = psmu_info->asSclkFcwRangeEntry[i].ucPostdiv;
1426 		table->entry[i].usFcw_pcc =
1427 			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucFcw_pcc);
1428 		table->entry[i].usFcw_trans_upper =
1429 			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucFcw_trans_upper);
1430 		table->entry[i].usRcw_trans_lower =
1431 			le16_to_cpu(psmu_info->asSclkFcwRangeEntry[i].ucRcw_trans_lower);
1432 	}
1433 
1434 	return 0;
1435 }
1436 
1437 int atomctrl_get_vddc_shared_railinfo(struct pp_hwmgr *hwmgr, uint8_t *shared_rail)
1438 {
1439 	ATOM_SMU_INFO_V2_1 *psmu_info =
1440 		(ATOM_SMU_INFO_V2_1 *)smu_atom_get_data_table(hwmgr->adev,
1441 			GetIndexIntoMasterTable(DATA, SMU_Info),
1442 			NULL, NULL, NULL);
1443 	if (!psmu_info)
1444 		return -1;
1445 
1446 	*shared_rail = psmu_info->ucSharePowerSource;
1447 
1448 	return 0;
1449 }
1450 
1451 int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr,
1452 				  struct pp_atom_ctrl__avfs_parameters *param)
1453 {
1454 	ATOM_ASIC_PROFILING_INFO_V3_6 *profile = NULL;
1455 
1456 	if (param == NULL)
1457 		return -EINVAL;
1458 
1459 	profile = (ATOM_ASIC_PROFILING_INFO_V3_6 *)
1460 			smu_atom_get_data_table(hwmgr->adev,
1461 					GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo),
1462 					NULL, NULL, NULL);
1463 	if (!profile)
1464 		return -1;
1465 
1466 	param->ulAVFS_meanNsigma_Acontant0 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant0);
1467 	param->ulAVFS_meanNsigma_Acontant1 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant1);
1468 	param->ulAVFS_meanNsigma_Acontant2 = le32_to_cpu(profile->ulAVFS_meanNsigma_Acontant2);
1469 	param->usAVFS_meanNsigma_DC_tol_sigma = le16_to_cpu(profile->usAVFS_meanNsigma_DC_tol_sigma);
1470 	param->usAVFS_meanNsigma_Platform_mean = le16_to_cpu(profile->usAVFS_meanNsigma_Platform_mean);
1471 	param->usAVFS_meanNsigma_Platform_sigma = le16_to_cpu(profile->usAVFS_meanNsigma_Platform_sigma);
1472 	param->ulGB_VDROOP_TABLE_CKSOFF_a0 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a0);
1473 	param->ulGB_VDROOP_TABLE_CKSOFF_a1 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a1);
1474 	param->ulGB_VDROOP_TABLE_CKSOFF_a2 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSOFF_a2);
1475 	param->ulGB_VDROOP_TABLE_CKSON_a0 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a0);
1476 	param->ulGB_VDROOP_TABLE_CKSON_a1 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a1);
1477 	param->ulGB_VDROOP_TABLE_CKSON_a2 = le32_to_cpu(profile->ulGB_VDROOP_TABLE_CKSON_a2);
1478 	param->ulAVFSGB_FUSE_TABLE_CKSOFF_m1 = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSOFF_m1);
1479 	param->usAVFSGB_FUSE_TABLE_CKSOFF_m2 = le16_to_cpu(profile->usAVFSGB_FUSE_TABLE_CKSOFF_m2);
1480 	param->ulAVFSGB_FUSE_TABLE_CKSOFF_b = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSOFF_b);
1481 	param->ulAVFSGB_FUSE_TABLE_CKSON_m1 = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSON_m1);
1482 	param->usAVFSGB_FUSE_TABLE_CKSON_m2 = le16_to_cpu(profile->usAVFSGB_FUSE_TABLE_CKSON_m2);
1483 	param->ulAVFSGB_FUSE_TABLE_CKSON_b = le32_to_cpu(profile->ulAVFSGB_FUSE_TABLE_CKSON_b);
1484 	param->usMaxVoltage_0_25mv = le16_to_cpu(profile->usMaxVoltage_0_25mv);
1485 	param->ucEnableGB_VDROOP_TABLE_CKSOFF = profile->ucEnableGB_VDROOP_TABLE_CKSOFF;
1486 	param->ucEnableGB_VDROOP_TABLE_CKSON = profile->ucEnableGB_VDROOP_TABLE_CKSON;
1487 	param->ucEnableGB_FUSE_TABLE_CKSOFF = profile->ucEnableGB_FUSE_TABLE_CKSOFF;
1488 	param->ucEnableGB_FUSE_TABLE_CKSON = profile->ucEnableGB_FUSE_TABLE_CKSON;
1489 	param->usPSM_Age_ComFactor = le16_to_cpu(profile->usPSM_Age_ComFactor);
1490 	param->ucEnableApplyAVFS_CKS_OFF_Voltage = profile->ucEnableApplyAVFS_CKS_OFF_Voltage;
1491 
1492 	return 0;
1493 }
1494 
1495 int  atomctrl_get_svi2_info(struct pp_hwmgr *hwmgr, uint8_t voltage_type,
1496 				uint8_t *svd_gpio_id, uint8_t *svc_gpio_id,
1497 				uint16_t *load_line)
1498 {
1499 	ATOM_VOLTAGE_OBJECT_INFO_V3_1 *voltage_info =
1500 		(ATOM_VOLTAGE_OBJECT_INFO_V3_1 *)get_voltage_info_table(hwmgr->adev);
1501 
1502 	const ATOM_VOLTAGE_OBJECT_V3 *voltage_object;
1503 
1504 	PP_ASSERT_WITH_CODE((NULL != voltage_info),
1505 			"Could not find Voltage Table in BIOS.", return -EINVAL);
1506 
1507 	voltage_object = atomctrl_lookup_voltage_type_v3
1508 		(voltage_info, voltage_type,  VOLTAGE_OBJ_SVID2);
1509 
1510 	*svd_gpio_id = voltage_object->asSVID2Obj.ucSVDGpioId;
1511 	*svc_gpio_id = voltage_object->asSVID2Obj.ucSVCGpioId;
1512 	*load_line = voltage_object->asSVID2Obj.usLoadLine_PSI;
1513 
1514 	return 0;
1515 }
1516 
1517 int atomctrl_get_leakage_id_from_efuse(struct pp_hwmgr *hwmgr, uint16_t *virtual_voltage_id)
1518 {
1519 	struct amdgpu_device *adev = hwmgr->adev;
1520 	SET_VOLTAGE_PS_ALLOCATION allocation;
1521 	SET_VOLTAGE_PARAMETERS_V1_3 *voltage_parameters =
1522 			(SET_VOLTAGE_PARAMETERS_V1_3 *)&allocation.sASICSetVoltage;
1523 	int result;
1524 
1525 	voltage_parameters->ucVoltageMode = ATOM_GET_LEAKAGE_ID;
1526 
1527 	result = amdgpu_atom_execute_table(adev->mode_info.atom_context,
1528 			GetIndexIntoMasterTable(COMMAND, SetVoltage),
1529 			(uint32_t *)voltage_parameters);
1530 
1531 	*virtual_voltage_id = voltage_parameters->usVoltageLevel;
1532 
1533 	return result;
1534 }
1535 
1536 int atomctrl_get_leakage_vddc_base_on_leakage(struct pp_hwmgr *hwmgr,
1537 					uint16_t *vddc, uint16_t *vddci,
1538 					uint16_t virtual_voltage_id,
1539 					uint16_t efuse_voltage_id)
1540 {
1541 	int i, j;
1542 	int ix;
1543 	u16 *leakage_bin, *vddc_id_buf, *vddc_buf, *vddci_id_buf, *vddci_buf;
1544 	ATOM_ASIC_PROFILING_INFO_V2_1 *profile;
1545 
1546 	*vddc = 0;
1547 	*vddci = 0;
1548 
1549 	ix = GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo);
1550 
1551 	profile = (ATOM_ASIC_PROFILING_INFO_V2_1 *)
1552 			smu_atom_get_data_table(hwmgr->adev,
1553 					ix,
1554 					NULL, NULL, NULL);
1555 	if (!profile)
1556 		return -EINVAL;
1557 
1558 	if ((profile->asHeader.ucTableFormatRevision >= 2) &&
1559 		(profile->asHeader.ucTableContentRevision >= 1) &&
1560 		(profile->asHeader.usStructureSize >= sizeof(ATOM_ASIC_PROFILING_INFO_V2_1))) {
1561 		leakage_bin = (u16 *)((char *)profile + profile->usLeakageBinArrayOffset);
1562 		vddc_id_buf = (u16 *)((char *)profile + profile->usElbVDDC_IdArrayOffset);
1563 		vddc_buf = (u16 *)((char *)profile + profile->usElbVDDC_LevelArrayOffset);
1564 		if (profile->ucElbVDDC_Num > 0) {
1565 			for (i = 0; i < profile->ucElbVDDC_Num; i++) {
1566 				if (vddc_id_buf[i] == virtual_voltage_id) {
1567 					for (j = 0; j < profile->ucLeakageBinNum; j++) {
1568 						if (efuse_voltage_id <= leakage_bin[j]) {
1569 							*vddc = vddc_buf[j * profile->ucElbVDDC_Num + i];
1570 							break;
1571 						}
1572 					}
1573 					break;
1574 				}
1575 			}
1576 		}
1577 
1578 		vddci_id_buf = (u16 *)((char *)profile + profile->usElbVDDCI_IdArrayOffset);
1579 		vddci_buf   = (u16 *)((char *)profile + profile->usElbVDDCI_LevelArrayOffset);
1580 		if (profile->ucElbVDDCI_Num > 0) {
1581 			for (i = 0; i < profile->ucElbVDDCI_Num; i++) {
1582 				if (vddci_id_buf[i] == virtual_voltage_id) {
1583 					for (j = 0; j < profile->ucLeakageBinNum; j++) {
1584 						if (efuse_voltage_id <= leakage_bin[j]) {
1585 							*vddci = vddci_buf[j * profile->ucElbVDDCI_Num + i];
1586 							break;
1587 						}
1588 					}
1589 					break;
1590 				}
1591 			}
1592 		}
1593 	}
1594 
1595 	return 0;
1596 }
1597 
1598 void atomctrl_get_voltage_range(struct pp_hwmgr *hwmgr, uint32_t *max_vddc,
1599 							uint32_t *min_vddc)
1600 {
1601 	void *profile;
1602 
1603 	profile = smu_atom_get_data_table(hwmgr->adev,
1604 					GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo),
1605 					NULL, NULL, NULL);
1606 
1607 	if (profile) {
1608 		switch (hwmgr->chip_id) {
1609 		case CHIP_TONGA:
1610 		case CHIP_FIJI:
1611 			*max_vddc = le32_to_cpu(((ATOM_ASIC_PROFILING_INFO_V3_3 *)profile)->ulMaxVddc) / 4;
1612 			*min_vddc = le32_to_cpu(((ATOM_ASIC_PROFILING_INFO_V3_3 *)profile)->ulMinVddc) / 4;
1613 			return;
1614 		case CHIP_POLARIS11:
1615 		case CHIP_POLARIS10:
1616 		case CHIP_POLARIS12:
1617 			*max_vddc = le32_to_cpu(((ATOM_ASIC_PROFILING_INFO_V3_6 *)profile)->ulMaxVddc) / 100;
1618 			*min_vddc = le32_to_cpu(((ATOM_ASIC_PROFILING_INFO_V3_6 *)profile)->ulMinVddc) / 100;
1619 			return;
1620 		default:
1621 			break;
1622 		}
1623 	}
1624 	*max_vddc = 0;
1625 	*min_vddc = 0;
1626 }
1627 
1628 int atomctrl_get_edc_hilo_leakage_offset_table(struct pp_hwmgr *hwmgr,
1629 					       AtomCtrl_HiLoLeakageOffsetTable *table)
1630 {
1631 	ATOM_GFX_INFO_V2_3 *gfxinfo = smu_atom_get_data_table(hwmgr->adev,
1632 					GetIndexIntoMasterTable(DATA, GFX_Info),
1633 					NULL, NULL, NULL);
1634 	if (!gfxinfo)
1635 		return -ENOENT;
1636 
1637 	table->usHiLoLeakageThreshold = gfxinfo->usHiLoLeakageThreshold;
1638 	table->usEdcDidtLoDpm7TableOffset = gfxinfo->usEdcDidtLoDpm7TableOffset;
1639 	table->usEdcDidtHiDpm7TableOffset = gfxinfo->usEdcDidtHiDpm7TableOffset;
1640 
1641 	return 0;
1642 }
1643 
1644 static AtomCtrl_EDCLeakgeTable *get_edc_leakage_table(struct pp_hwmgr *hwmgr,
1645 						      uint16_t offset)
1646 {
1647 	void *table_address;
1648 	char *temp;
1649 
1650 	table_address = smu_atom_get_data_table(hwmgr->adev,
1651 			GetIndexIntoMasterTable(DATA, GFX_Info),
1652 			NULL, NULL, NULL);
1653 	if (!table_address)
1654 		return NULL;
1655 
1656 	temp = (char *)table_address;
1657 	table_address += offset;
1658 
1659 	return (AtomCtrl_EDCLeakgeTable *)temp;
1660 }
1661 
1662 int atomctrl_get_edc_leakage_table(struct pp_hwmgr *hwmgr,
1663 				   AtomCtrl_EDCLeakgeTable *table,
1664 				   uint16_t offset)
1665 {
1666 	uint32_t length, i;
1667 	AtomCtrl_EDCLeakgeTable *leakage_table =
1668 		get_edc_leakage_table(hwmgr, offset);
1669 
1670 	if (!leakage_table)
1671 		return -ENOENT;
1672 
1673 	length = sizeof(leakage_table->DIDT_REG) /
1674 		 sizeof(leakage_table->DIDT_REG[0]);
1675 	for (i = 0; i < length; i++)
1676 		table->DIDT_REG[i] = leakage_table->DIDT_REG[i];
1677 
1678 	return 0;
1679 }
1680