xref: /linux/drivers/gpu/drm/amd/pm/amdgpu_dpm.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 /*
2  * Copyright 2011 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  * Authors: Alex Deucher
23  */
24 
25 #include "amdgpu.h"
26 #include "amdgpu_atombios.h"
27 #include "amdgpu_i2c.h"
28 #include "amdgpu_dpm.h"
29 #include "atom.h"
30 #include "amd_pcie.h"
31 #include "amdgpu_display.h"
32 #include "hwmgr.h"
33 #include <linux/power_supply.h>
34 #include "amdgpu_smu.h"
35 
36 #define amdgpu_dpm_notify_ac_dc(adev) \
37 		((adev)->powerplay.pp_funcs->notify_ac_dc((adev)->powerplay.pp_handle))
38 
39 #define amdgpu_dpm_is_legacy_dpm(adev) ((adev)->powerplay.pp_handle == (adev))
40 
41 int amdgpu_dpm_get_sclk(struct amdgpu_device *adev, bool low)
42 {
43 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
44 	int ret = 0;
45 
46 	if (!pp_funcs->get_sclk)
47 		return 0;
48 
49 	mutex_lock(&adev->pm.mutex);
50 	ret = pp_funcs->get_sclk((adev)->powerplay.pp_handle,
51 				 low);
52 	mutex_unlock(&adev->pm.mutex);
53 
54 	return ret;
55 }
56 
57 int amdgpu_dpm_get_mclk(struct amdgpu_device *adev, bool low)
58 {
59 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
60 	int ret = 0;
61 
62 	if (!pp_funcs->get_mclk)
63 		return 0;
64 
65 	mutex_lock(&adev->pm.mutex);
66 	ret = pp_funcs->get_mclk((adev)->powerplay.pp_handle,
67 				 low);
68 	mutex_unlock(&adev->pm.mutex);
69 
70 	return ret;
71 }
72 
73 int amdgpu_dpm_set_powergating_by_smu(struct amdgpu_device *adev,
74 				       uint32_t block_type,
75 				       bool gate,
76 				       int inst)
77 {
78 	int ret = 0;
79 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
80 	enum ip_power_state pwr_state = gate ? POWER_STATE_OFF : POWER_STATE_ON;
81 	bool is_vcn = block_type == AMD_IP_BLOCK_TYPE_VCN;
82 
83 	mutex_lock(&adev->pm.mutex);
84 
85 	if (atomic_read(&adev->pm.pwr_state[block_type]) == pwr_state &&
86 			(!is_vcn || adev->vcn.num_vcn_inst == 1)) {
87 		dev_dbg(adev->dev, "IP block%d already in the target %s state!",
88 				block_type, gate ? "gate" : "ungate");
89 		goto out_unlock;
90 	}
91 
92 	switch (block_type) {
93 	case AMD_IP_BLOCK_TYPE_UVD:
94 	case AMD_IP_BLOCK_TYPE_VCE:
95 	case AMD_IP_BLOCK_TYPE_GFX:
96 	case AMD_IP_BLOCK_TYPE_SDMA:
97 	case AMD_IP_BLOCK_TYPE_JPEG:
98 	case AMD_IP_BLOCK_TYPE_GMC:
99 	case AMD_IP_BLOCK_TYPE_ACP:
100 	case AMD_IP_BLOCK_TYPE_VPE:
101 	case AMD_IP_BLOCK_TYPE_ISP:
102 		if (pp_funcs && pp_funcs->set_powergating_by_smu)
103 			ret = (pp_funcs->set_powergating_by_smu(
104 				(adev)->powerplay.pp_handle, block_type, gate, 0));
105 		break;
106 	case AMD_IP_BLOCK_TYPE_VCN:
107 		if (pp_funcs && pp_funcs->set_powergating_by_smu)
108 			ret = (pp_funcs->set_powergating_by_smu(
109 				(adev)->powerplay.pp_handle, block_type, gate, inst));
110 		break;
111 	default:
112 		break;
113 	}
114 
115 	if (!ret)
116 		atomic_set(&adev->pm.pwr_state[block_type], pwr_state);
117 
118 out_unlock:
119 	mutex_unlock(&adev->pm.mutex);
120 
121 	return ret;
122 }
123 
124 int amdgpu_dpm_set_gfx_power_up_by_imu(struct amdgpu_device *adev)
125 {
126 	struct smu_context *smu = adev->powerplay.pp_handle;
127 	int ret = -EOPNOTSUPP;
128 
129 	mutex_lock(&adev->pm.mutex);
130 	ret = smu_set_gfx_power_up_by_imu(smu);
131 	mutex_unlock(&adev->pm.mutex);
132 
133 	msleep(10);
134 
135 	return ret;
136 }
137 
138 int amdgpu_dpm_baco_enter(struct amdgpu_device *adev)
139 {
140 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
141 	void *pp_handle = adev->powerplay.pp_handle;
142 	int ret = 0;
143 
144 	if (!pp_funcs || !pp_funcs->set_asic_baco_state)
145 		return -ENOENT;
146 
147 	mutex_lock(&adev->pm.mutex);
148 
149 	/* enter BACO state */
150 	ret = pp_funcs->set_asic_baco_state(pp_handle, 1);
151 
152 	mutex_unlock(&adev->pm.mutex);
153 
154 	return ret;
155 }
156 
157 int amdgpu_dpm_baco_exit(struct amdgpu_device *adev)
158 {
159 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
160 	void *pp_handle = adev->powerplay.pp_handle;
161 	int ret = 0;
162 
163 	if (!pp_funcs || !pp_funcs->set_asic_baco_state)
164 		return -ENOENT;
165 
166 	mutex_lock(&adev->pm.mutex);
167 
168 	/* exit BACO state */
169 	ret = pp_funcs->set_asic_baco_state(pp_handle, 0);
170 
171 	mutex_unlock(&adev->pm.mutex);
172 
173 	return ret;
174 }
175 
176 int amdgpu_dpm_set_mp1_state(struct amdgpu_device *adev,
177 			     enum pp_mp1_state mp1_state)
178 {
179 	int ret = 0;
180 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
181 
182 	if (mp1_state == PP_MP1_STATE_FLR) {
183 		/* VF lost access to SMU */
184 		if (amdgpu_sriov_vf(adev))
185 			adev->pm.dpm_enabled = false;
186 	} else if (pp_funcs && pp_funcs->set_mp1_state) {
187 		mutex_lock(&adev->pm.mutex);
188 
189 		ret = pp_funcs->set_mp1_state(
190 				adev->powerplay.pp_handle,
191 				mp1_state);
192 
193 		mutex_unlock(&adev->pm.mutex);
194 	}
195 
196 	return ret;
197 }
198 
199 int amdgpu_dpm_is_baco_supported(struct amdgpu_device *adev)
200 {
201 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
202 	void *pp_handle = adev->powerplay.pp_handle;
203 	int ret;
204 
205 	if (!pp_funcs || !pp_funcs->get_asic_baco_capability)
206 		return 0;
207 	/* Don't use baco for reset in S3.
208 	 * This is a workaround for some platforms
209 	 * where entering BACO during suspend
210 	 * seems to cause reboots or hangs.
211 	 * This might be related to the fact that BACO controls
212 	 * power to the whole GPU including devices like audio and USB.
213 	 * Powering down/up everything may adversely affect these other
214 	 * devices.  Needs more investigation.
215 	 */
216 	if (adev->in_s3)
217 		return 0;
218 
219 	mutex_lock(&adev->pm.mutex);
220 
221 	ret = pp_funcs->get_asic_baco_capability(pp_handle);
222 
223 	mutex_unlock(&adev->pm.mutex);
224 
225 	return ret;
226 }
227 
228 int amdgpu_dpm_mode2_reset(struct amdgpu_device *adev)
229 {
230 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
231 	void *pp_handle = adev->powerplay.pp_handle;
232 	int ret = 0;
233 
234 	if (!pp_funcs || !pp_funcs->asic_reset_mode_2)
235 		return -ENOENT;
236 
237 	mutex_lock(&adev->pm.mutex);
238 
239 	ret = pp_funcs->asic_reset_mode_2(pp_handle);
240 
241 	mutex_unlock(&adev->pm.mutex);
242 
243 	return ret;
244 }
245 
246 int amdgpu_dpm_enable_gfx_features(struct amdgpu_device *adev)
247 {
248 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
249 	void *pp_handle = adev->powerplay.pp_handle;
250 	int ret = 0;
251 
252 	if (!pp_funcs || !pp_funcs->asic_reset_enable_gfx_features)
253 		return -ENOENT;
254 
255 	mutex_lock(&adev->pm.mutex);
256 
257 	ret = pp_funcs->asic_reset_enable_gfx_features(pp_handle);
258 
259 	mutex_unlock(&adev->pm.mutex);
260 
261 	return ret;
262 }
263 
264 int amdgpu_dpm_baco_reset(struct amdgpu_device *adev)
265 {
266 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
267 	void *pp_handle = adev->powerplay.pp_handle;
268 	int ret = 0;
269 
270 	if (!pp_funcs || !pp_funcs->set_asic_baco_state)
271 		return -ENOENT;
272 
273 	mutex_lock(&adev->pm.mutex);
274 
275 	/* enter BACO state */
276 	ret = pp_funcs->set_asic_baco_state(pp_handle, 1);
277 	if (ret)
278 		goto out;
279 
280 	/* exit BACO state */
281 	ret = pp_funcs->set_asic_baco_state(pp_handle, 0);
282 
283 out:
284 	mutex_unlock(&adev->pm.mutex);
285 	return ret;
286 }
287 
288 bool amdgpu_dpm_is_mode1_reset_supported(struct amdgpu_device *adev)
289 {
290 	struct smu_context *smu = adev->powerplay.pp_handle;
291 	bool support_mode1_reset = false;
292 
293 	if (is_support_sw_smu(adev)) {
294 		mutex_lock(&adev->pm.mutex);
295 		support_mode1_reset = smu_mode1_reset_is_support(smu);
296 		mutex_unlock(&adev->pm.mutex);
297 	}
298 
299 	return support_mode1_reset;
300 }
301 
302 int amdgpu_dpm_mode1_reset(struct amdgpu_device *adev)
303 {
304 	struct smu_context *smu = adev->powerplay.pp_handle;
305 	int ret = -EOPNOTSUPP;
306 
307 	if (is_support_sw_smu(adev)) {
308 		mutex_lock(&adev->pm.mutex);
309 		ret = smu_mode1_reset(smu);
310 		mutex_unlock(&adev->pm.mutex);
311 	}
312 
313 	return ret;
314 }
315 
316 bool amdgpu_dpm_is_link_reset_supported(struct amdgpu_device *adev)
317 {
318 	struct smu_context *smu = adev->powerplay.pp_handle;
319 	bool support_link_reset = false;
320 
321 	if (is_support_sw_smu(adev)) {
322 		mutex_lock(&adev->pm.mutex);
323 		support_link_reset = smu_link_reset_is_support(smu);
324 		mutex_unlock(&adev->pm.mutex);
325 	}
326 
327 	return support_link_reset;
328 }
329 
330 int amdgpu_dpm_link_reset(struct amdgpu_device *adev)
331 {
332 	struct smu_context *smu = adev->powerplay.pp_handle;
333 	int ret = -EOPNOTSUPP;
334 
335 	if (is_support_sw_smu(adev)) {
336 		mutex_lock(&adev->pm.mutex);
337 		ret = smu_link_reset(smu);
338 		mutex_unlock(&adev->pm.mutex);
339 	}
340 
341 	return ret;
342 }
343 
344 int amdgpu_dpm_switch_power_profile(struct amdgpu_device *adev,
345 				    enum PP_SMC_POWER_PROFILE type,
346 				    bool en)
347 {
348 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
349 	int ret = 0;
350 
351 	if (amdgpu_sriov_vf(adev) ||
352 		amdgpu_in_reset(adev))
353 		return 0;
354 
355 	if (pp_funcs && pp_funcs->switch_power_profile) {
356 		mutex_lock(&adev->pm.mutex);
357 		ret = pp_funcs->switch_power_profile(
358 			adev->powerplay.pp_handle, type, en);
359 		mutex_unlock(&adev->pm.mutex);
360 	}
361 
362 	return ret;
363 }
364 
365 int amdgpu_dpm_pause_power_profile(struct amdgpu_device *adev,
366 				   bool pause)
367 {
368 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
369 	int ret = 0;
370 
371 	if (amdgpu_sriov_vf(adev) ||
372 		amdgpu_in_reset(adev))
373 		return 0;
374 
375 	if (pp_funcs && pp_funcs->pause_power_profile) {
376 		mutex_lock(&adev->pm.mutex);
377 		ret = pp_funcs->pause_power_profile(
378 			adev->powerplay.pp_handle, pause);
379 		mutex_unlock(&adev->pm.mutex);
380 	}
381 
382 	return ret;
383 }
384 
385 int amdgpu_dpm_set_xgmi_pstate(struct amdgpu_device *adev,
386 			       uint32_t pstate)
387 {
388 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
389 	int ret = 0;
390 
391 	if (pp_funcs && pp_funcs->set_xgmi_pstate) {
392 		mutex_lock(&adev->pm.mutex);
393 		ret = pp_funcs->set_xgmi_pstate(adev->powerplay.pp_handle,
394 								pstate);
395 		mutex_unlock(&adev->pm.mutex);
396 	}
397 
398 	return ret;
399 }
400 
401 int amdgpu_dpm_set_df_cstate(struct amdgpu_device *adev,
402 			     uint32_t cstate)
403 {
404 	int ret = 0;
405 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
406 	void *pp_handle = adev->powerplay.pp_handle;
407 
408 	if (pp_funcs && pp_funcs->set_df_cstate) {
409 		mutex_lock(&adev->pm.mutex);
410 		ret = pp_funcs->set_df_cstate(pp_handle, cstate);
411 		mutex_unlock(&adev->pm.mutex);
412 	}
413 
414 	return ret;
415 }
416 
417 ssize_t amdgpu_dpm_get_pm_policy_info(struct amdgpu_device *adev,
418 				      enum pp_pm_policy p_type, char *buf)
419 {
420 	struct smu_context *smu = adev->powerplay.pp_handle;
421 	int ret = -EOPNOTSUPP;
422 
423 	if (is_support_sw_smu(adev)) {
424 		mutex_lock(&adev->pm.mutex);
425 		ret = smu_get_pm_policy_info(smu, p_type, buf);
426 		mutex_unlock(&adev->pm.mutex);
427 	}
428 
429 	return ret;
430 }
431 
432 int amdgpu_dpm_set_pm_policy(struct amdgpu_device *adev, int policy_type,
433 			     int policy_level)
434 {
435 	struct smu_context *smu = adev->powerplay.pp_handle;
436 	int ret = -EOPNOTSUPP;
437 
438 	if (is_support_sw_smu(adev)) {
439 		mutex_lock(&adev->pm.mutex);
440 		ret = smu_set_pm_policy(smu, policy_type, policy_level);
441 		mutex_unlock(&adev->pm.mutex);
442 	}
443 
444 	return ret;
445 }
446 
447 int amdgpu_dpm_enable_mgpu_fan_boost(struct amdgpu_device *adev)
448 {
449 	void *pp_handle = adev->powerplay.pp_handle;
450 	const struct amd_pm_funcs *pp_funcs =
451 			adev->powerplay.pp_funcs;
452 	int ret = 0;
453 
454 	if (pp_funcs && pp_funcs->enable_mgpu_fan_boost) {
455 		mutex_lock(&adev->pm.mutex);
456 		ret = pp_funcs->enable_mgpu_fan_boost(pp_handle);
457 		mutex_unlock(&adev->pm.mutex);
458 	}
459 
460 	return ret;
461 }
462 
463 int amdgpu_dpm_set_clockgating_by_smu(struct amdgpu_device *adev,
464 				      uint32_t msg_id)
465 {
466 	void *pp_handle = adev->powerplay.pp_handle;
467 	const struct amd_pm_funcs *pp_funcs =
468 			adev->powerplay.pp_funcs;
469 	int ret = 0;
470 
471 	if (pp_funcs && pp_funcs->set_clockgating_by_smu) {
472 		mutex_lock(&adev->pm.mutex);
473 		ret = pp_funcs->set_clockgating_by_smu(pp_handle,
474 						       msg_id);
475 		mutex_unlock(&adev->pm.mutex);
476 	}
477 
478 	return ret;
479 }
480 
481 int amdgpu_dpm_smu_i2c_bus_access(struct amdgpu_device *adev,
482 				  bool acquire)
483 {
484 	void *pp_handle = adev->powerplay.pp_handle;
485 	const struct amd_pm_funcs *pp_funcs =
486 			adev->powerplay.pp_funcs;
487 	int ret = -EOPNOTSUPP;
488 
489 	if (pp_funcs && pp_funcs->smu_i2c_bus_access) {
490 		mutex_lock(&adev->pm.mutex);
491 		ret = pp_funcs->smu_i2c_bus_access(pp_handle,
492 						   acquire);
493 		mutex_unlock(&adev->pm.mutex);
494 	}
495 
496 	return ret;
497 }
498 
499 void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev)
500 {
501 	if (adev->pm.dpm_enabled) {
502 		mutex_lock(&adev->pm.mutex);
503 		if (power_supply_is_system_supplied() > 0)
504 			adev->pm.ac_power = true;
505 		else
506 			adev->pm.ac_power = false;
507 
508 		if (adev->powerplay.pp_funcs &&
509 		    adev->powerplay.pp_funcs->notify_ac_dc)
510 			amdgpu_dpm_notify_ac_dc(adev);
511 
512 		mutex_unlock(&adev->pm.mutex);
513 	}
514 }
515 
516 int amdgpu_dpm_read_sensor(struct amdgpu_device *adev, enum amd_pp_sensors sensor,
517 			   void *data, uint32_t *size)
518 {
519 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
520 	int ret = -EINVAL;
521 
522 	if (!data || !size)
523 		return -EINVAL;
524 
525 	if (pp_funcs && pp_funcs->read_sensor) {
526 		mutex_lock(&adev->pm.mutex);
527 		ret = pp_funcs->read_sensor(adev->powerplay.pp_handle,
528 					    sensor,
529 					    data,
530 					    size);
531 		mutex_unlock(&adev->pm.mutex);
532 	}
533 
534 	return ret;
535 }
536 
537 int amdgpu_dpm_get_apu_thermal_limit(struct amdgpu_device *adev, uint32_t *limit)
538 {
539 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
540 	int ret = -EOPNOTSUPP;
541 
542 	if (pp_funcs && pp_funcs->get_apu_thermal_limit) {
543 		mutex_lock(&adev->pm.mutex);
544 		ret = pp_funcs->get_apu_thermal_limit(adev->powerplay.pp_handle, limit);
545 		mutex_unlock(&adev->pm.mutex);
546 	}
547 
548 	return ret;
549 }
550 
551 int amdgpu_dpm_set_apu_thermal_limit(struct amdgpu_device *adev, uint32_t limit)
552 {
553 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
554 	int ret = -EOPNOTSUPP;
555 
556 	if (pp_funcs && pp_funcs->set_apu_thermal_limit) {
557 		mutex_lock(&adev->pm.mutex);
558 		ret = pp_funcs->set_apu_thermal_limit(adev->powerplay.pp_handle, limit);
559 		mutex_unlock(&adev->pm.mutex);
560 	}
561 
562 	return ret;
563 }
564 
565 void amdgpu_dpm_compute_clocks(struct amdgpu_device *adev)
566 {
567 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
568 	int i;
569 
570 	if (!adev->pm.dpm_enabled)
571 		return;
572 
573 	if (!pp_funcs->pm_compute_clocks)
574 		return;
575 
576 	if (adev->mode_info.num_crtc)
577 		amdgpu_display_bandwidth_update(adev);
578 
579 	for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
580 		struct amdgpu_ring *ring = adev->rings[i];
581 		if (ring && ring->sched.ready)
582 			amdgpu_fence_wait_empty(ring);
583 	}
584 
585 	mutex_lock(&adev->pm.mutex);
586 	pp_funcs->pm_compute_clocks(adev->powerplay.pp_handle);
587 	mutex_unlock(&adev->pm.mutex);
588 }
589 
590 void amdgpu_dpm_enable_uvd(struct amdgpu_device *adev, bool enable)
591 {
592 	int ret = 0;
593 
594 	if (adev->family == AMDGPU_FAMILY_SI) {
595 		mutex_lock(&adev->pm.mutex);
596 		if (enable) {
597 			adev->pm.dpm.uvd_active = true;
598 			adev->pm.dpm.state = POWER_STATE_TYPE_INTERNAL_UVD;
599 		} else {
600 			adev->pm.dpm.uvd_active = false;
601 		}
602 		mutex_unlock(&adev->pm.mutex);
603 
604 		amdgpu_dpm_compute_clocks(adev);
605 		return;
606 	}
607 
608 	ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_UVD, !enable, 0);
609 	if (ret)
610 		drm_err(adev_to_drm(adev), "DPM %s uvd failed, ret = %d.\n",
611 			enable ? "enable" : "disable", ret);
612 }
613 
614 void amdgpu_dpm_enable_vcn(struct amdgpu_device *adev, bool enable, int inst)
615 {
616 	int ret = 0;
617 
618 	ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VCN, !enable, inst);
619 	if (ret)
620 		drm_err(adev_to_drm(adev), "DPM %s vcn failed, ret = %d.\n",
621 			enable ? "enable" : "disable", ret);
622 }
623 
624 void amdgpu_dpm_enable_vce(struct amdgpu_device *adev, bool enable)
625 {
626 	int ret = 0;
627 
628 	if (adev->family == AMDGPU_FAMILY_SI) {
629 		mutex_lock(&adev->pm.mutex);
630 		if (enable) {
631 			adev->pm.dpm.vce_active = true;
632 			/* XXX select vce level based on ring/task */
633 			adev->pm.dpm.vce_level = AMD_VCE_LEVEL_AC_ALL;
634 		} else {
635 			adev->pm.dpm.vce_active = false;
636 		}
637 		mutex_unlock(&adev->pm.mutex);
638 
639 		amdgpu_dpm_compute_clocks(adev);
640 		return;
641 	}
642 
643 	ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VCE, !enable, 0);
644 	if (ret)
645 		drm_err(adev_to_drm(adev), "DPM %s vce failed, ret = %d.\n",
646 			enable ? "enable" : "disable", ret);
647 }
648 
649 void amdgpu_dpm_enable_jpeg(struct amdgpu_device *adev, bool enable)
650 {
651 	int ret = 0;
652 
653 	ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_JPEG, !enable, 0);
654 	if (ret)
655 		drm_err(adev_to_drm(adev), "Dpm %s jpeg failed, ret = %d.\n",
656 			enable ? "enable" : "disable", ret);
657 }
658 
659 void amdgpu_dpm_enable_vpe(struct amdgpu_device *adev, bool enable)
660 {
661 	int ret = 0;
662 
663 	ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VPE, !enable, 0);
664 	if (ret)
665 		drm_err(adev_to_drm(adev), "DPM %s vpe failed, ret = %d.\n",
666 			enable ? "enable" : "disable", ret);
667 }
668 
669 int amdgpu_pm_load_smu_firmware(struct amdgpu_device *adev, uint32_t *smu_version)
670 {
671 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
672 	int r = 0;
673 
674 	if (!pp_funcs || !pp_funcs->load_firmware ||
675 	    (is_support_sw_smu(adev) && (adev->flags & AMD_IS_APU)))
676 		return 0;
677 
678 	mutex_lock(&adev->pm.mutex);
679 	r = pp_funcs->load_firmware(adev->powerplay.pp_handle);
680 	if (r) {
681 		pr_err("smu firmware loading failed\n");
682 		goto out;
683 	}
684 
685 	if (smu_version)
686 		*smu_version = adev->pm.fw_version;
687 
688 out:
689 	mutex_unlock(&adev->pm.mutex);
690 	return r;
691 }
692 
693 int amdgpu_dpm_handle_passthrough_sbr(struct amdgpu_device *adev, bool enable)
694 {
695 	int ret = 0;
696 
697 	if (is_support_sw_smu(adev)) {
698 		mutex_lock(&adev->pm.mutex);
699 		ret = smu_handle_passthrough_sbr(adev->powerplay.pp_handle,
700 						 enable);
701 		mutex_unlock(&adev->pm.mutex);
702 	}
703 
704 	return ret;
705 }
706 
707 int amdgpu_dpm_send_hbm_bad_pages_num(struct amdgpu_device *adev, uint32_t size)
708 {
709 	struct smu_context *smu = adev->powerplay.pp_handle;
710 	int ret = 0;
711 
712 	if (!is_support_sw_smu(adev))
713 		return -EOPNOTSUPP;
714 
715 	mutex_lock(&adev->pm.mutex);
716 	ret = smu_send_hbm_bad_pages_num(smu, size);
717 	mutex_unlock(&adev->pm.mutex);
718 
719 	return ret;
720 }
721 
722 int amdgpu_dpm_send_hbm_bad_channel_flag(struct amdgpu_device *adev, uint32_t size)
723 {
724 	struct smu_context *smu = adev->powerplay.pp_handle;
725 	int ret = 0;
726 
727 	if (!is_support_sw_smu(adev))
728 		return -EOPNOTSUPP;
729 
730 	mutex_lock(&adev->pm.mutex);
731 	ret = smu_send_hbm_bad_channel_flag(smu, size);
732 	mutex_unlock(&adev->pm.mutex);
733 
734 	return ret;
735 }
736 
737 int amdgpu_dpm_send_rma_reason(struct amdgpu_device *adev)
738 {
739 	struct smu_context *smu = adev->powerplay.pp_handle;
740 	int ret;
741 
742 	if (!is_support_sw_smu(adev))
743 		return -EOPNOTSUPP;
744 
745 	mutex_lock(&adev->pm.mutex);
746 	ret = smu_send_rma_reason(smu);
747 	mutex_unlock(&adev->pm.mutex);
748 
749 	return ret;
750 }
751 
752 /**
753  * amdgpu_dpm_reset_sdma_is_supported - Check if SDMA reset is supported
754  * @adev: amdgpu_device pointer
755  *
756  * This function checks if the SMU supports resetting the SDMA engine.
757  * It returns false if the hardware does not support software SMU or
758  * if the feature is not supported.
759  */
760 bool amdgpu_dpm_reset_sdma_is_supported(struct amdgpu_device *adev)
761 {
762 	struct smu_context *smu = adev->powerplay.pp_handle;
763 	bool ret;
764 
765 	if (!is_support_sw_smu(adev))
766 		return false;
767 
768 	mutex_lock(&adev->pm.mutex);
769 	ret = smu_reset_sdma_is_supported(smu);
770 	mutex_unlock(&adev->pm.mutex);
771 
772 	return ret;
773 }
774 
775 int amdgpu_dpm_reset_sdma(struct amdgpu_device *adev, uint32_t inst_mask)
776 {
777 	struct smu_context *smu = adev->powerplay.pp_handle;
778 	int ret;
779 
780 	if (!is_support_sw_smu(adev))
781 		return -EOPNOTSUPP;
782 
783 	mutex_lock(&adev->pm.mutex);
784 	ret = smu_reset_sdma(smu, inst_mask);
785 	mutex_unlock(&adev->pm.mutex);
786 
787 	return ret;
788 }
789 
790 int amdgpu_dpm_reset_vcn(struct amdgpu_device *adev, uint32_t inst_mask)
791 {
792 	struct smu_context *smu = adev->powerplay.pp_handle;
793 	int ret;
794 
795 	if (!is_support_sw_smu(adev))
796 		return -EOPNOTSUPP;
797 
798 	mutex_lock(&adev->pm.mutex);
799 	ret = smu_reset_vcn(smu, inst_mask);
800 	mutex_unlock(&adev->pm.mutex);
801 
802 	return ret;
803 }
804 
805 bool amdgpu_dpm_reset_vcn_is_supported(struct amdgpu_device *adev)
806 {
807 	struct smu_context *smu = adev->powerplay.pp_handle;
808 	bool ret;
809 
810 	if (!is_support_sw_smu(adev))
811 		return false;
812 
813 	mutex_lock(&adev->pm.mutex);
814 	ret = smu_reset_vcn_is_supported(smu);
815 	mutex_unlock(&adev->pm.mutex);
816 
817 	return ret;
818 }
819 
820 int amdgpu_dpm_get_dpm_freq_range(struct amdgpu_device *adev,
821 				  enum pp_clock_type type,
822 				  uint32_t *min,
823 				  uint32_t *max)
824 {
825 	int ret = 0;
826 
827 	if (type != PP_SCLK)
828 		return -EINVAL;
829 
830 	if (!is_support_sw_smu(adev))
831 		return -EOPNOTSUPP;
832 
833 	mutex_lock(&adev->pm.mutex);
834 	ret = smu_get_dpm_freq_range(adev->powerplay.pp_handle,
835 				     SMU_SCLK,
836 				     min,
837 				     max);
838 	mutex_unlock(&adev->pm.mutex);
839 
840 	return ret;
841 }
842 
843 int amdgpu_dpm_set_soft_freq_range(struct amdgpu_device *adev,
844 				   enum pp_clock_type type,
845 				   uint32_t min,
846 				   uint32_t max)
847 {
848 	struct smu_context *smu = adev->powerplay.pp_handle;
849 
850 	if (!is_support_sw_smu(adev))
851 		return -EOPNOTSUPP;
852 
853 	guard(mutex)(&adev->pm.mutex);
854 
855 	return smu_set_soft_freq_range(smu,
856 				      type,
857 				      min,
858 				      max);
859 }
860 
861 int amdgpu_dpm_write_watermarks_table(struct amdgpu_device *adev)
862 {
863 	struct smu_context *smu = adev->powerplay.pp_handle;
864 	int ret = 0;
865 
866 	if (!is_support_sw_smu(adev))
867 		return 0;
868 
869 	mutex_lock(&adev->pm.mutex);
870 	ret = smu_write_watermarks_table(smu);
871 	mutex_unlock(&adev->pm.mutex);
872 
873 	return ret;
874 }
875 
876 int amdgpu_dpm_wait_for_event(struct amdgpu_device *adev,
877 			      enum smu_event_type event,
878 			      uint64_t event_arg)
879 {
880 	struct smu_context *smu = adev->powerplay.pp_handle;
881 	int ret = 0;
882 
883 	if (!is_support_sw_smu(adev))
884 		return -EOPNOTSUPP;
885 
886 	mutex_lock(&adev->pm.mutex);
887 	ret = smu_wait_for_event(smu, event, event_arg);
888 	mutex_unlock(&adev->pm.mutex);
889 
890 	return ret;
891 }
892 
893 int amdgpu_dpm_set_residency_gfxoff(struct amdgpu_device *adev, bool value)
894 {
895 	struct smu_context *smu = adev->powerplay.pp_handle;
896 	int ret = 0;
897 
898 	if (!is_support_sw_smu(adev))
899 		return -EOPNOTSUPP;
900 
901 	mutex_lock(&adev->pm.mutex);
902 	ret = smu_set_residency_gfxoff(smu, value);
903 	mutex_unlock(&adev->pm.mutex);
904 
905 	return ret;
906 }
907 
908 int amdgpu_dpm_get_residency_gfxoff(struct amdgpu_device *adev, u32 *value)
909 {
910 	struct smu_context *smu = adev->powerplay.pp_handle;
911 	int ret = 0;
912 
913 	if (!is_support_sw_smu(adev))
914 		return -EOPNOTSUPP;
915 
916 	mutex_lock(&adev->pm.mutex);
917 	ret = smu_get_residency_gfxoff(smu, value);
918 	mutex_unlock(&adev->pm.mutex);
919 
920 	return ret;
921 }
922 
923 int amdgpu_dpm_get_entrycount_gfxoff(struct amdgpu_device *adev, u64 *value)
924 {
925 	struct smu_context *smu = adev->powerplay.pp_handle;
926 	int ret = 0;
927 
928 	if (!is_support_sw_smu(adev))
929 		return -EOPNOTSUPP;
930 
931 	mutex_lock(&adev->pm.mutex);
932 	ret = smu_get_entrycount_gfxoff(smu, value);
933 	mutex_unlock(&adev->pm.mutex);
934 
935 	return ret;
936 }
937 
938 int amdgpu_dpm_get_status_gfxoff(struct amdgpu_device *adev, uint32_t *value)
939 {
940 	struct smu_context *smu = adev->powerplay.pp_handle;
941 	int ret = 0;
942 
943 	if (!is_support_sw_smu(adev))
944 		return -EOPNOTSUPP;
945 
946 	mutex_lock(&adev->pm.mutex);
947 	ret = smu_get_status_gfxoff(smu, value);
948 	mutex_unlock(&adev->pm.mutex);
949 
950 	return ret;
951 }
952 
953 uint64_t amdgpu_dpm_get_thermal_throttling_counter(struct amdgpu_device *adev)
954 {
955 	struct smu_context *smu = adev->powerplay.pp_handle;
956 
957 	if (!is_support_sw_smu(adev))
958 		return 0;
959 
960 	return atomic64_read(&smu->throttle_int_counter);
961 }
962 
963 /* amdgpu_dpm_gfx_state_change - Handle gfx power state change set
964  * @adev: amdgpu_device pointer
965  * @state: gfx power state(1 -sGpuChangeState_D0Entry and 2 -sGpuChangeState_D3Entry)
966  *
967  */
968 void amdgpu_dpm_gfx_state_change(struct amdgpu_device *adev,
969 				 enum gfx_change_state state)
970 {
971 	mutex_lock(&adev->pm.mutex);
972 	if (adev->powerplay.pp_funcs &&
973 	    adev->powerplay.pp_funcs->gfx_state_change_set)
974 		((adev)->powerplay.pp_funcs->gfx_state_change_set(
975 			(adev)->powerplay.pp_handle, state));
976 	mutex_unlock(&adev->pm.mutex);
977 }
978 
979 int amdgpu_dpm_get_ecc_info(struct amdgpu_device *adev,
980 			    void *umc_ecc)
981 {
982 	struct smu_context *smu = adev->powerplay.pp_handle;
983 	int ret = 0;
984 
985 	if (!is_support_sw_smu(adev))
986 		return -EOPNOTSUPP;
987 
988 	mutex_lock(&adev->pm.mutex);
989 	ret = smu_get_ecc_info(smu, umc_ecc);
990 	mutex_unlock(&adev->pm.mutex);
991 
992 	return ret;
993 }
994 
995 struct amd_vce_state *amdgpu_dpm_get_vce_clock_state(struct amdgpu_device *adev,
996 						     uint32_t idx)
997 {
998 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
999 	struct amd_vce_state *vstate = NULL;
1000 
1001 	if (!pp_funcs->get_vce_clock_state)
1002 		return NULL;
1003 
1004 	mutex_lock(&adev->pm.mutex);
1005 	vstate = pp_funcs->get_vce_clock_state(adev->powerplay.pp_handle,
1006 					       idx);
1007 	mutex_unlock(&adev->pm.mutex);
1008 
1009 	return vstate;
1010 }
1011 
1012 void amdgpu_dpm_get_current_power_state(struct amdgpu_device *adev,
1013 					enum amd_pm_state_type *state)
1014 {
1015 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1016 
1017 	mutex_lock(&adev->pm.mutex);
1018 
1019 	if (!pp_funcs->get_current_power_state) {
1020 		*state = adev->pm.dpm.user_state;
1021 		goto out;
1022 	}
1023 
1024 	*state = pp_funcs->get_current_power_state(adev->powerplay.pp_handle);
1025 	if (*state < POWER_STATE_TYPE_DEFAULT ||
1026 	    *state > POWER_STATE_TYPE_INTERNAL_3DPERF)
1027 		*state = adev->pm.dpm.user_state;
1028 
1029 out:
1030 	mutex_unlock(&adev->pm.mutex);
1031 }
1032 
1033 void amdgpu_dpm_set_power_state(struct amdgpu_device *adev,
1034 				enum amd_pm_state_type state)
1035 {
1036 	mutex_lock(&adev->pm.mutex);
1037 	adev->pm.dpm.user_state = state;
1038 	mutex_unlock(&adev->pm.mutex);
1039 
1040 	if (is_support_sw_smu(adev))
1041 		return;
1042 
1043 	if (amdgpu_dpm_dispatch_task(adev,
1044 				     AMD_PP_TASK_ENABLE_USER_STATE,
1045 				     &state) == -EOPNOTSUPP)
1046 		amdgpu_dpm_compute_clocks(adev);
1047 }
1048 
1049 enum amd_dpm_forced_level amdgpu_dpm_get_performance_level(struct amdgpu_device *adev)
1050 {
1051 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1052 	enum amd_dpm_forced_level level;
1053 
1054 	if (!pp_funcs)
1055 		return AMD_DPM_FORCED_LEVEL_AUTO;
1056 
1057 	mutex_lock(&adev->pm.mutex);
1058 	if (pp_funcs->get_performance_level)
1059 		level = pp_funcs->get_performance_level(adev->powerplay.pp_handle);
1060 	else
1061 		level = adev->pm.dpm.forced_level;
1062 	mutex_unlock(&adev->pm.mutex);
1063 
1064 	return level;
1065 }
1066 
1067 static void amdgpu_dpm_enter_umd_state(struct amdgpu_device *adev)
1068 {
1069 	/* enter UMD Pstate */
1070 	amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1071 					       AMD_PG_STATE_UNGATE);
1072 	amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1073 					       AMD_CG_STATE_UNGATE);
1074 }
1075 
1076 static void amdgpu_dpm_exit_umd_state(struct amdgpu_device *adev)
1077 {
1078 	/* exit UMD Pstate */
1079 	amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1080 					       AMD_CG_STATE_GATE);
1081 	amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1082 					       AMD_PG_STATE_GATE);
1083 }
1084 
1085 int amdgpu_dpm_force_performance_level(struct amdgpu_device *adev,
1086 				       enum amd_dpm_forced_level level)
1087 {
1088 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1089 	enum amd_dpm_forced_level current_level;
1090 	uint32_t profile_mode_mask = AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD |
1091 					AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK |
1092 					AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK |
1093 					AMD_DPM_FORCED_LEVEL_PROFILE_PEAK;
1094 
1095 	if (!pp_funcs || !pp_funcs->force_performance_level)
1096 		return 0;
1097 
1098 	if (adev->pm.dpm.thermal_active)
1099 		return -EINVAL;
1100 
1101 	current_level = amdgpu_dpm_get_performance_level(adev);
1102 	if (current_level == level)
1103 		return 0;
1104 
1105 	if (!(current_level & profile_mode_mask) &&
1106 	    (level == AMD_DPM_FORCED_LEVEL_PROFILE_EXIT))
1107 		return -EINVAL;
1108 
1109 	if (adev->asic_type == CHIP_RAVEN) {
1110 		if (!(adev->apu_flags & AMD_APU_IS_RAVEN2)) {
1111 			if (current_level != AMD_DPM_FORCED_LEVEL_MANUAL &&
1112 			    level == AMD_DPM_FORCED_LEVEL_MANUAL)
1113 				amdgpu_gfx_off_ctrl(adev, false);
1114 			else if (current_level == AMD_DPM_FORCED_LEVEL_MANUAL &&
1115 				 level != AMD_DPM_FORCED_LEVEL_MANUAL)
1116 				amdgpu_gfx_off_ctrl(adev, true);
1117 		}
1118 	}
1119 
1120 	if (!(current_level & profile_mode_mask) && (level & profile_mode_mask))
1121 		amdgpu_dpm_enter_umd_state(adev);
1122 	else if ((current_level & profile_mode_mask) &&
1123 		 !(level & profile_mode_mask))
1124 		amdgpu_dpm_exit_umd_state(adev);
1125 
1126 	mutex_lock(&adev->pm.mutex);
1127 
1128 	if (pp_funcs->force_performance_level(adev->powerplay.pp_handle,
1129 					      level)) {
1130 		mutex_unlock(&adev->pm.mutex);
1131 		/* If new level failed, retain the umd state as before */
1132 		if (!(current_level & profile_mode_mask) &&
1133 		    (level & profile_mode_mask))
1134 			amdgpu_dpm_exit_umd_state(adev);
1135 		else if ((current_level & profile_mode_mask) &&
1136 			 !(level & profile_mode_mask))
1137 			amdgpu_dpm_enter_umd_state(adev);
1138 
1139 		return -EINVAL;
1140 	}
1141 
1142 	adev->pm.dpm.forced_level = level;
1143 
1144 	mutex_unlock(&adev->pm.mutex);
1145 
1146 	return 0;
1147 }
1148 
1149 int amdgpu_dpm_get_pp_num_states(struct amdgpu_device *adev,
1150 				 struct pp_states_info *states)
1151 {
1152 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1153 	int ret = 0;
1154 
1155 	if (!pp_funcs->get_pp_num_states)
1156 		return -EOPNOTSUPP;
1157 
1158 	mutex_lock(&adev->pm.mutex);
1159 	ret = pp_funcs->get_pp_num_states(adev->powerplay.pp_handle,
1160 					  states);
1161 	mutex_unlock(&adev->pm.mutex);
1162 
1163 	return ret;
1164 }
1165 
1166 int amdgpu_dpm_dispatch_task(struct amdgpu_device *adev,
1167 			      enum amd_pp_task task_id,
1168 			      enum amd_pm_state_type *user_state)
1169 {
1170 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1171 	int ret = 0;
1172 
1173 	if (!pp_funcs->dispatch_tasks)
1174 		return -EOPNOTSUPP;
1175 
1176 	mutex_lock(&adev->pm.mutex);
1177 	ret = pp_funcs->dispatch_tasks(adev->powerplay.pp_handle,
1178 				       task_id,
1179 				       user_state);
1180 	mutex_unlock(&adev->pm.mutex);
1181 
1182 	return ret;
1183 }
1184 
1185 static bool amdgpu_dpm_is_pp_table_allowed(struct amdgpu_device *adev)
1186 {
1187 	return !amdgpu_sriov_vf(adev) &&
1188 	       !(adev->flags & AMD_IS_APU) &&
1189 	       !adev->scpm_enabled;
1190 }
1191 
1192 int amdgpu_dpm_get_pp_table(struct amdgpu_device *adev, char *table,
1193 			    size_t size)
1194 {
1195 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1196 	char *pptable = NULL;
1197 	int ret = 0;
1198 
1199 	if ((!table && size) || (table && !size))
1200 		return -EINVAL;
1201 
1202 	if (!amdgpu_dpm_is_pp_table_allowed(adev) ||
1203 	    !pp_funcs->get_pp_table)
1204 		return -EOPNOTSUPP;
1205 
1206 	mutex_lock(&adev->pm.mutex);
1207 	ret = pp_funcs->get_pp_table(adev->powerplay.pp_handle,
1208 				     &pptable);
1209 	if (ret > 0 && !pptable) {
1210 		ret = -EINVAL;
1211 	} else if (ret > 0 && table) {
1212 		ret = min_t(size_t, ret, size);
1213 		memcpy(table, pptable, ret);
1214 	}
1215 	mutex_unlock(&adev->pm.mutex);
1216 
1217 	return ret;
1218 }
1219 
1220 int amdgpu_dpm_set_fine_grain_clk_vol(struct amdgpu_device *adev,
1221 				      uint32_t type,
1222 				      long *input,
1223 				      uint32_t size)
1224 {
1225 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1226 	int ret = 0;
1227 
1228 	if (!pp_funcs->set_fine_grain_clk_vol)
1229 		return 0;
1230 
1231 	mutex_lock(&adev->pm.mutex);
1232 	ret = pp_funcs->set_fine_grain_clk_vol(adev->powerplay.pp_handle,
1233 					       type,
1234 					       input,
1235 					       size);
1236 	mutex_unlock(&adev->pm.mutex);
1237 
1238 	return ret;
1239 }
1240 
1241 int amdgpu_dpm_odn_edit_dpm_table(struct amdgpu_device *adev,
1242 				  uint32_t type,
1243 				  long *input,
1244 				  uint32_t size)
1245 {
1246 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1247 	int ret = 0;
1248 
1249 	if (!pp_funcs->odn_edit_dpm_table)
1250 		return 0;
1251 
1252 	mutex_lock(&adev->pm.mutex);
1253 	ret = pp_funcs->odn_edit_dpm_table(adev->powerplay.pp_handle,
1254 					   type,
1255 					   input,
1256 					   size);
1257 	mutex_unlock(&adev->pm.mutex);
1258 
1259 	return ret;
1260 }
1261 
1262 int amdgpu_dpm_emit_clock_levels(struct amdgpu_device *adev,
1263 				  enum pp_clock_type type,
1264 				  char *buf,
1265 				  int *offset)
1266 {
1267 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1268 	int ret = 0;
1269 
1270 	if (!pp_funcs->emit_clock_levels)
1271 		return -ENOENT;
1272 
1273 	mutex_lock(&adev->pm.mutex);
1274 	ret = pp_funcs->emit_clock_levels(adev->powerplay.pp_handle,
1275 					   type,
1276 					   buf,
1277 					   offset);
1278 	mutex_unlock(&adev->pm.mutex);
1279 
1280 	return ret;
1281 }
1282 
1283 int amdgpu_dpm_set_ppfeature_status(struct amdgpu_device *adev,
1284 				    uint64_t ppfeature_masks)
1285 {
1286 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1287 	int ret = 0;
1288 
1289 	if (!pp_funcs->set_ppfeature_status)
1290 		return 0;
1291 
1292 	mutex_lock(&adev->pm.mutex);
1293 	ret = pp_funcs->set_ppfeature_status(adev->powerplay.pp_handle,
1294 					     ppfeature_masks);
1295 	mutex_unlock(&adev->pm.mutex);
1296 
1297 	return ret;
1298 }
1299 
1300 int amdgpu_dpm_get_ppfeature_status(struct amdgpu_device *adev, char *buf)
1301 {
1302 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1303 	int ret = 0;
1304 
1305 	if (!pp_funcs->get_ppfeature_status)
1306 		return 0;
1307 
1308 	mutex_lock(&adev->pm.mutex);
1309 	ret = pp_funcs->get_ppfeature_status(adev->powerplay.pp_handle,
1310 					     buf);
1311 	mutex_unlock(&adev->pm.mutex);
1312 
1313 	return ret;
1314 }
1315 
1316 int amdgpu_dpm_force_clock_level(struct amdgpu_device *adev,
1317 				 enum pp_clock_type type,
1318 				 uint32_t mask)
1319 {
1320 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1321 	int ret = 0;
1322 
1323 	if (!pp_funcs->force_clock_level)
1324 		return 0;
1325 
1326 	mutex_lock(&adev->pm.mutex);
1327 	ret = pp_funcs->force_clock_level(adev->powerplay.pp_handle,
1328 					  type,
1329 					  mask);
1330 	mutex_unlock(&adev->pm.mutex);
1331 
1332 	return ret;
1333 }
1334 
1335 int amdgpu_dpm_get_sclk_od(struct amdgpu_device *adev)
1336 {
1337 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1338 	int ret = 0;
1339 
1340 	if (!pp_funcs->get_sclk_od)
1341 		return -EOPNOTSUPP;
1342 
1343 	mutex_lock(&adev->pm.mutex);
1344 	ret = pp_funcs->get_sclk_od(adev->powerplay.pp_handle);
1345 	mutex_unlock(&adev->pm.mutex);
1346 
1347 	return ret;
1348 }
1349 
1350 int amdgpu_dpm_set_sclk_od(struct amdgpu_device *adev, uint32_t value)
1351 {
1352 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1353 
1354 	if (is_support_sw_smu(adev))
1355 		return -EOPNOTSUPP;
1356 
1357 	mutex_lock(&adev->pm.mutex);
1358 	if (pp_funcs->set_sclk_od)
1359 		pp_funcs->set_sclk_od(adev->powerplay.pp_handle, value);
1360 	mutex_unlock(&adev->pm.mutex);
1361 
1362 	if (amdgpu_dpm_dispatch_task(adev,
1363 				     AMD_PP_TASK_READJUST_POWER_STATE,
1364 				     NULL) == -EOPNOTSUPP) {
1365 		adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
1366 		amdgpu_dpm_compute_clocks(adev);
1367 	}
1368 
1369 	return 0;
1370 }
1371 
1372 int amdgpu_dpm_get_mclk_od(struct amdgpu_device *adev)
1373 {
1374 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1375 	int ret = 0;
1376 
1377 	if (!pp_funcs->get_mclk_od)
1378 		return -EOPNOTSUPP;
1379 
1380 	mutex_lock(&adev->pm.mutex);
1381 	ret = pp_funcs->get_mclk_od(adev->powerplay.pp_handle);
1382 	mutex_unlock(&adev->pm.mutex);
1383 
1384 	return ret;
1385 }
1386 
1387 int amdgpu_dpm_set_mclk_od(struct amdgpu_device *adev, uint32_t value)
1388 {
1389 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1390 
1391 	if (is_support_sw_smu(adev))
1392 		return -EOPNOTSUPP;
1393 
1394 	mutex_lock(&adev->pm.mutex);
1395 	if (pp_funcs->set_mclk_od)
1396 		pp_funcs->set_mclk_od(adev->powerplay.pp_handle, value);
1397 	mutex_unlock(&adev->pm.mutex);
1398 
1399 	if (amdgpu_dpm_dispatch_task(adev,
1400 				     AMD_PP_TASK_READJUST_POWER_STATE,
1401 				     NULL) == -EOPNOTSUPP) {
1402 		adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
1403 		amdgpu_dpm_compute_clocks(adev);
1404 	}
1405 
1406 	return 0;
1407 }
1408 
1409 int amdgpu_dpm_get_power_profile_mode(struct amdgpu_device *adev,
1410 				      char *buf)
1411 {
1412 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1413 	int ret = 0;
1414 
1415 	if (!pp_funcs->get_power_profile_mode)
1416 		return -EOPNOTSUPP;
1417 
1418 	mutex_lock(&adev->pm.mutex);
1419 	ret = pp_funcs->get_power_profile_mode(adev->powerplay.pp_handle,
1420 					       buf);
1421 	mutex_unlock(&adev->pm.mutex);
1422 
1423 	return ret;
1424 }
1425 
1426 int amdgpu_dpm_set_power_profile_mode(struct amdgpu_device *adev,
1427 				      long *input, uint32_t size)
1428 {
1429 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1430 	int ret = 0;
1431 
1432 	if (!pp_funcs->set_power_profile_mode)
1433 		return 0;
1434 
1435 	mutex_lock(&adev->pm.mutex);
1436 	ret = pp_funcs->set_power_profile_mode(adev->powerplay.pp_handle,
1437 					       input,
1438 					       size);
1439 	mutex_unlock(&adev->pm.mutex);
1440 
1441 	return ret;
1442 }
1443 
1444 ssize_t amdgpu_dpm_get_gpu_metrics(struct amdgpu_device *adev, void *buf,
1445 				   size_t size)
1446 {
1447 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1448 	void *table;
1449 	ssize_t ret;
1450 
1451 	if (!pp_funcs->get_gpu_metrics)
1452 		return 0;
1453 
1454 	mutex_lock(&adev->pm.mutex);
1455 	ret = pp_funcs->get_gpu_metrics(adev->powerplay.pp_handle,
1456 					&table);
1457 	if (ret > 0) {
1458 		ret = min_t(ssize_t, ret, size);
1459 		memcpy(buf, table, ret);
1460 	}
1461 	mutex_unlock(&adev->pm.mutex);
1462 
1463 	return ret;
1464 }
1465 
1466 ssize_t amdgpu_dpm_get_pm_metrics(struct amdgpu_device *adev, void *pm_metrics,
1467 				  size_t size)
1468 {
1469 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1470 	int ret = 0;
1471 
1472 	if (!pp_funcs->get_pm_metrics)
1473 		return -EOPNOTSUPP;
1474 
1475 	mutex_lock(&adev->pm.mutex);
1476 	ret = pp_funcs->get_pm_metrics(adev->powerplay.pp_handle, pm_metrics,
1477 				       size);
1478 	mutex_unlock(&adev->pm.mutex);
1479 
1480 	return ret;
1481 }
1482 
1483 int amdgpu_dpm_get_fan_control_mode(struct amdgpu_device *adev,
1484 				    uint32_t *fan_mode)
1485 {
1486 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1487 	int ret = 0;
1488 
1489 	if (!pp_funcs->get_fan_control_mode)
1490 		return -EOPNOTSUPP;
1491 
1492 	mutex_lock(&adev->pm.mutex);
1493 	ret = pp_funcs->get_fan_control_mode(adev->powerplay.pp_handle,
1494 					     fan_mode);
1495 	mutex_unlock(&adev->pm.mutex);
1496 
1497 	return ret;
1498 }
1499 
1500 int amdgpu_dpm_set_fan_speed_pwm(struct amdgpu_device *adev,
1501 				 uint32_t speed)
1502 {
1503 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1504 	int ret = 0;
1505 
1506 	if (!pp_funcs->set_fan_speed_pwm)
1507 		return -EOPNOTSUPP;
1508 
1509 	mutex_lock(&adev->pm.mutex);
1510 	ret = pp_funcs->set_fan_speed_pwm(adev->powerplay.pp_handle,
1511 					  speed);
1512 	mutex_unlock(&adev->pm.mutex);
1513 
1514 	return ret;
1515 }
1516 
1517 int amdgpu_dpm_get_fan_speed_pwm(struct amdgpu_device *adev,
1518 				 uint32_t *speed)
1519 {
1520 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1521 	int ret = 0;
1522 
1523 	if (!pp_funcs->get_fan_speed_pwm)
1524 		return -EOPNOTSUPP;
1525 
1526 	mutex_lock(&adev->pm.mutex);
1527 	ret = pp_funcs->get_fan_speed_pwm(adev->powerplay.pp_handle,
1528 					  speed);
1529 	mutex_unlock(&adev->pm.mutex);
1530 
1531 	return ret;
1532 }
1533 
1534 int amdgpu_dpm_get_fan_speed_rpm(struct amdgpu_device *adev,
1535 				 uint32_t *speed)
1536 {
1537 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1538 	int ret = 0;
1539 
1540 	if (!pp_funcs->get_fan_speed_rpm)
1541 		return -EOPNOTSUPP;
1542 
1543 	mutex_lock(&adev->pm.mutex);
1544 	ret = pp_funcs->get_fan_speed_rpm(adev->powerplay.pp_handle,
1545 					  speed);
1546 	mutex_unlock(&adev->pm.mutex);
1547 
1548 	return ret;
1549 }
1550 
1551 int amdgpu_dpm_set_fan_speed_rpm(struct amdgpu_device *adev,
1552 				 uint32_t speed)
1553 {
1554 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1555 	int ret = 0;
1556 
1557 	if (!pp_funcs->set_fan_speed_rpm)
1558 		return -EOPNOTSUPP;
1559 
1560 	mutex_lock(&adev->pm.mutex);
1561 	ret = pp_funcs->set_fan_speed_rpm(adev->powerplay.pp_handle,
1562 					  speed);
1563 	mutex_unlock(&adev->pm.mutex);
1564 
1565 	return ret;
1566 }
1567 
1568 int amdgpu_dpm_set_fan_control_mode(struct amdgpu_device *adev,
1569 				    uint32_t mode)
1570 {
1571 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1572 	int ret = 0;
1573 
1574 	if (!pp_funcs->set_fan_control_mode)
1575 		return -EOPNOTSUPP;
1576 
1577 	mutex_lock(&adev->pm.mutex);
1578 	ret = pp_funcs->set_fan_control_mode(adev->powerplay.pp_handle,
1579 					     mode);
1580 	mutex_unlock(&adev->pm.mutex);
1581 
1582 	return ret;
1583 }
1584 
1585 int amdgpu_dpm_get_power_limit(struct amdgpu_device *adev,
1586 			       uint32_t *limit,
1587 			       enum pp_power_limit_level pp_limit_level,
1588 			       enum pp_power_type power_type)
1589 {
1590 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1591 	int ret = 0;
1592 
1593 	if (!pp_funcs->get_power_limit)
1594 		return -EOPNOTSUPP;
1595 
1596 	mutex_lock(&adev->pm.mutex);
1597 	ret = pp_funcs->get_power_limit(adev->powerplay.pp_handle,
1598 					limit,
1599 					pp_limit_level,
1600 					power_type);
1601 	mutex_unlock(&adev->pm.mutex);
1602 
1603 	return ret;
1604 }
1605 
1606 int amdgpu_dpm_set_power_limit(struct amdgpu_device *adev,
1607 			       uint32_t limit_type,
1608 			       uint32_t limit)
1609 {
1610 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1611 	int ret = 0;
1612 
1613 	if (!pp_funcs->set_power_limit)
1614 		return -EINVAL;
1615 
1616 	mutex_lock(&adev->pm.mutex);
1617 	ret = pp_funcs->set_power_limit(adev->powerplay.pp_handle,
1618 					limit_type, limit);
1619 	mutex_unlock(&adev->pm.mutex);
1620 
1621 	return ret;
1622 }
1623 
1624 int amdgpu_dpm_is_cclk_dpm_supported(struct amdgpu_device *adev)
1625 {
1626 	bool cclk_dpm_supported = false;
1627 
1628 	if (!is_support_sw_smu(adev))
1629 		return false;
1630 
1631 	mutex_lock(&adev->pm.mutex);
1632 	cclk_dpm_supported = is_support_cclk_dpm(adev);
1633 	mutex_unlock(&adev->pm.mutex);
1634 
1635 	return (int)cclk_dpm_supported;
1636 }
1637 
1638 int amdgpu_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev,
1639 						       struct seq_file *m)
1640 {
1641 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1642 
1643 	if (!pp_funcs->debugfs_print_current_performance_level)
1644 		return -EOPNOTSUPP;
1645 
1646 	mutex_lock(&adev->pm.mutex);
1647 	pp_funcs->debugfs_print_current_performance_level(adev->powerplay.pp_handle,
1648 							  m);
1649 	mutex_unlock(&adev->pm.mutex);
1650 
1651 	return 0;
1652 }
1653 
1654 int amdgpu_dpm_get_smu_prv_buf_details(struct amdgpu_device *adev,
1655 				       void **addr,
1656 				       size_t *size)
1657 {
1658 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1659 	int ret = 0;
1660 
1661 	if (!pp_funcs->get_smu_prv_buf_details)
1662 		return -ENOSYS;
1663 
1664 	mutex_lock(&adev->pm.mutex);
1665 	ret = pp_funcs->get_smu_prv_buf_details(adev->powerplay.pp_handle,
1666 						addr,
1667 						size);
1668 	mutex_unlock(&adev->pm.mutex);
1669 
1670 	return ret;
1671 }
1672 
1673 int amdgpu_dpm_is_overdrive_supported(struct amdgpu_device *adev)
1674 {
1675 	if (is_support_sw_smu(adev)) {
1676 		struct smu_context *smu = adev->powerplay.pp_handle;
1677 
1678 		return (smu->od_enabled || smu->is_apu);
1679 	} else {
1680 		struct pp_hwmgr *hwmgr;
1681 
1682 		/*
1683 		 * dpm on some legacy asics don't carry od_enabled member
1684 		 * as its pp_handle is casted directly from adev.
1685 		 */
1686 		if (amdgpu_dpm_is_legacy_dpm(adev))
1687 			return false;
1688 
1689 		hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle;
1690 
1691 		return hwmgr->od_enabled;
1692 	}
1693 }
1694 
1695 int amdgpu_dpm_is_overdrive_enabled(struct amdgpu_device *adev)
1696 {
1697 	if (is_support_sw_smu(adev)) {
1698 		struct smu_context *smu = adev->powerplay.pp_handle;
1699 
1700 		return smu->od_enabled;
1701 	} else {
1702 		struct pp_hwmgr *hwmgr;
1703 
1704 		/*
1705 		 * dpm on some legacy asics don't carry od_enabled member
1706 		 * as its pp_handle is casted directly from adev.
1707 		 */
1708 		if (amdgpu_dpm_is_legacy_dpm(adev))
1709 			return false;
1710 
1711 		hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle;
1712 
1713 		return hwmgr->od_enabled;
1714 	}
1715 }
1716 
1717 int amdgpu_dpm_set_pp_table(struct amdgpu_device *adev,
1718 			    const char *buf,
1719 			    size_t size)
1720 {
1721 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1722 	int ret = 0;
1723 
1724 	if (!buf || !size)
1725 		return -EINVAL;
1726 
1727 	if (!amdgpu_dpm_is_pp_table_allowed(adev) ||
1728 	    !pp_funcs->set_pp_table)
1729 		return -EOPNOTSUPP;
1730 
1731 	mutex_lock(&adev->pm.mutex);
1732 	ret = pp_funcs->set_pp_table(adev->powerplay.pp_handle,
1733 				     buf,
1734 				     size);
1735 	mutex_unlock(&adev->pm.mutex);
1736 
1737 	return ret;
1738 }
1739 
1740 int amdgpu_dpm_get_num_cpu_cores(struct amdgpu_device *adev)
1741 {
1742 	struct smu_context *smu = adev->powerplay.pp_handle;
1743 
1744 	if (!is_support_sw_smu(adev))
1745 		return INT_MAX;
1746 
1747 	return smu->cpu_core_num;
1748 }
1749 
1750 void amdgpu_dpm_stb_debug_fs_init(struct amdgpu_device *adev)
1751 {
1752 	if (!is_support_sw_smu(adev))
1753 		return;
1754 
1755 	amdgpu_smu_stb_debug_fs_init(adev);
1756 }
1757 
1758 int amdgpu_dpm_display_configuration_change(struct amdgpu_device *adev,
1759 					    const struct amd_pp_display_configuration *input)
1760 {
1761 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1762 	int ret = 0;
1763 
1764 	if (!pp_funcs->display_configuration_change)
1765 		return 0;
1766 
1767 	mutex_lock(&adev->pm.mutex);
1768 	ret = pp_funcs->display_configuration_change(adev->powerplay.pp_handle,
1769 						     input);
1770 	mutex_unlock(&adev->pm.mutex);
1771 
1772 	return ret;
1773 }
1774 
1775 int amdgpu_dpm_get_clock_by_type(struct amdgpu_device *adev,
1776 				 enum amd_pp_clock_type type,
1777 				 struct amd_pp_clocks *clocks)
1778 {
1779 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1780 	int ret = 0;
1781 
1782 	if (!pp_funcs->get_clock_by_type)
1783 		return 0;
1784 
1785 	mutex_lock(&adev->pm.mutex);
1786 	ret = pp_funcs->get_clock_by_type(adev->powerplay.pp_handle,
1787 					  type,
1788 					  clocks);
1789 	mutex_unlock(&adev->pm.mutex);
1790 
1791 	return ret;
1792 }
1793 
1794 int amdgpu_dpm_get_display_mode_validation_clks(struct amdgpu_device *adev,
1795 						struct amd_pp_simple_clock_info *clocks)
1796 {
1797 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1798 	int ret = 0;
1799 
1800 	if (!pp_funcs->get_display_mode_validation_clocks)
1801 		return 0;
1802 
1803 	mutex_lock(&adev->pm.mutex);
1804 	ret = pp_funcs->get_display_mode_validation_clocks(adev->powerplay.pp_handle,
1805 							   clocks);
1806 	mutex_unlock(&adev->pm.mutex);
1807 
1808 	return ret;
1809 }
1810 
1811 int amdgpu_dpm_get_clock_by_type_with_latency(struct amdgpu_device *adev,
1812 					      enum amd_pp_clock_type type,
1813 					      struct pp_clock_levels_with_latency *clocks)
1814 {
1815 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1816 	int ret = 0;
1817 
1818 	if (!pp_funcs->get_clock_by_type_with_latency)
1819 		return 0;
1820 
1821 	mutex_lock(&adev->pm.mutex);
1822 	ret = pp_funcs->get_clock_by_type_with_latency(adev->powerplay.pp_handle,
1823 						       type,
1824 						       clocks);
1825 	mutex_unlock(&adev->pm.mutex);
1826 
1827 	return ret;
1828 }
1829 
1830 int amdgpu_dpm_get_clock_by_type_with_voltage(struct amdgpu_device *adev,
1831 					      enum amd_pp_clock_type type,
1832 					      struct pp_clock_levels_with_voltage *clocks)
1833 {
1834 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1835 	int ret = 0;
1836 
1837 	if (!pp_funcs->get_clock_by_type_with_voltage)
1838 		return 0;
1839 
1840 	mutex_lock(&adev->pm.mutex);
1841 	ret = pp_funcs->get_clock_by_type_with_voltage(adev->powerplay.pp_handle,
1842 						       type,
1843 						       clocks);
1844 	mutex_unlock(&adev->pm.mutex);
1845 
1846 	return ret;
1847 }
1848 
1849 int amdgpu_dpm_set_watermarks_for_clocks_ranges(struct amdgpu_device *adev,
1850 					       void *clock_ranges)
1851 {
1852 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1853 	int ret = 0;
1854 
1855 	if (!pp_funcs->set_watermarks_for_clocks_ranges)
1856 		return -EOPNOTSUPP;
1857 
1858 	mutex_lock(&adev->pm.mutex);
1859 	ret = pp_funcs->set_watermarks_for_clocks_ranges(adev->powerplay.pp_handle,
1860 							 clock_ranges);
1861 	mutex_unlock(&adev->pm.mutex);
1862 
1863 	return ret;
1864 }
1865 
1866 int amdgpu_dpm_display_clock_voltage_request(struct amdgpu_device *adev,
1867 					     struct pp_display_clock_request *clock)
1868 {
1869 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1870 	int ret = 0;
1871 
1872 	if (!pp_funcs->display_clock_voltage_request)
1873 		return -EOPNOTSUPP;
1874 
1875 	mutex_lock(&adev->pm.mutex);
1876 	ret = pp_funcs->display_clock_voltage_request(adev->powerplay.pp_handle,
1877 						      clock);
1878 	mutex_unlock(&adev->pm.mutex);
1879 
1880 	return ret;
1881 }
1882 
1883 int amdgpu_dpm_get_current_clocks(struct amdgpu_device *adev,
1884 				  struct amd_pp_clock_info *clocks)
1885 {
1886 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1887 	int ret = 0;
1888 
1889 	if (!pp_funcs->get_current_clocks)
1890 		return -EOPNOTSUPP;
1891 
1892 	mutex_lock(&adev->pm.mutex);
1893 	ret = pp_funcs->get_current_clocks(adev->powerplay.pp_handle,
1894 					   clocks);
1895 	mutex_unlock(&adev->pm.mutex);
1896 
1897 	return ret;
1898 }
1899 
1900 void amdgpu_dpm_notify_smu_enable_pwe(struct amdgpu_device *adev)
1901 {
1902 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1903 
1904 	if (!pp_funcs->notify_smu_enable_pwe)
1905 		return;
1906 
1907 	mutex_lock(&adev->pm.mutex);
1908 	pp_funcs->notify_smu_enable_pwe(adev->powerplay.pp_handle);
1909 	mutex_unlock(&adev->pm.mutex);
1910 }
1911 
1912 int amdgpu_dpm_set_active_display_count(struct amdgpu_device *adev,
1913 					uint32_t count)
1914 {
1915 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1916 	int ret = 0;
1917 
1918 	if (!pp_funcs->set_active_display_count)
1919 		return -EOPNOTSUPP;
1920 
1921 	mutex_lock(&adev->pm.mutex);
1922 	ret = pp_funcs->set_active_display_count(adev->powerplay.pp_handle,
1923 						 count);
1924 	mutex_unlock(&adev->pm.mutex);
1925 
1926 	return ret;
1927 }
1928 
1929 int amdgpu_dpm_set_min_deep_sleep_dcefclk(struct amdgpu_device *adev,
1930 					  uint32_t clock)
1931 {
1932 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1933 	int ret = 0;
1934 
1935 	if (!pp_funcs->set_min_deep_sleep_dcefclk)
1936 		return -EOPNOTSUPP;
1937 
1938 	mutex_lock(&adev->pm.mutex);
1939 	ret = pp_funcs->set_min_deep_sleep_dcefclk(adev->powerplay.pp_handle,
1940 						   clock);
1941 	mutex_unlock(&adev->pm.mutex);
1942 
1943 	return ret;
1944 }
1945 
1946 void amdgpu_dpm_set_hard_min_dcefclk_by_freq(struct amdgpu_device *adev,
1947 					     uint32_t clock)
1948 {
1949 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1950 
1951 	if (!pp_funcs->set_hard_min_dcefclk_by_freq)
1952 		return;
1953 
1954 	mutex_lock(&adev->pm.mutex);
1955 	pp_funcs->set_hard_min_dcefclk_by_freq(adev->powerplay.pp_handle,
1956 					       clock);
1957 	mutex_unlock(&adev->pm.mutex);
1958 }
1959 
1960 void amdgpu_dpm_set_hard_min_fclk_by_freq(struct amdgpu_device *adev,
1961 					  uint32_t clock)
1962 {
1963 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1964 
1965 	if (!pp_funcs->set_hard_min_fclk_by_freq)
1966 		return;
1967 
1968 	mutex_lock(&adev->pm.mutex);
1969 	pp_funcs->set_hard_min_fclk_by_freq(adev->powerplay.pp_handle,
1970 					    clock);
1971 	mutex_unlock(&adev->pm.mutex);
1972 }
1973 
1974 int amdgpu_dpm_display_disable_memory_clock_switch(struct amdgpu_device *adev,
1975 						   bool disable_memory_clock_switch)
1976 {
1977 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1978 	int ret = 0;
1979 
1980 	if (!pp_funcs->display_disable_memory_clock_switch)
1981 		return 0;
1982 
1983 	mutex_lock(&adev->pm.mutex);
1984 	ret = pp_funcs->display_disable_memory_clock_switch(adev->powerplay.pp_handle,
1985 							    disable_memory_clock_switch);
1986 	mutex_unlock(&adev->pm.mutex);
1987 
1988 	return ret;
1989 }
1990 
1991 int amdgpu_dpm_get_max_sustainable_clocks_by_dc(struct amdgpu_device *adev,
1992 						struct pp_smu_nv_clock_table *max_clocks)
1993 {
1994 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1995 	int ret = 0;
1996 
1997 	if (!pp_funcs->get_max_sustainable_clocks_by_dc)
1998 		return -EOPNOTSUPP;
1999 
2000 	mutex_lock(&adev->pm.mutex);
2001 	ret = pp_funcs->get_max_sustainable_clocks_by_dc(adev->powerplay.pp_handle,
2002 							 max_clocks);
2003 	mutex_unlock(&adev->pm.mutex);
2004 
2005 	return ret;
2006 }
2007 
2008 enum pp_smu_status amdgpu_dpm_get_uclk_dpm_states(struct amdgpu_device *adev,
2009 						  unsigned int *clock_values_in_khz,
2010 						  unsigned int *num_states)
2011 {
2012 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2013 	int ret = 0;
2014 
2015 	if (!pp_funcs->get_uclk_dpm_states)
2016 		return -EOPNOTSUPP;
2017 
2018 	mutex_lock(&adev->pm.mutex);
2019 	ret = pp_funcs->get_uclk_dpm_states(adev->powerplay.pp_handle,
2020 					    clock_values_in_khz,
2021 					    num_states);
2022 	mutex_unlock(&adev->pm.mutex);
2023 
2024 	return ret;
2025 }
2026 
2027 int amdgpu_dpm_get_dpm_clock_table(struct amdgpu_device *adev,
2028 				   struct dpm_clocks *clock_table)
2029 {
2030 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2031 	int ret = 0;
2032 
2033 	if (!pp_funcs->get_dpm_clock_table)
2034 		return -EOPNOTSUPP;
2035 
2036 	mutex_lock(&adev->pm.mutex);
2037 	ret = pp_funcs->get_dpm_clock_table(adev->powerplay.pp_handle,
2038 					    clock_table);
2039 	mutex_unlock(&adev->pm.mutex);
2040 
2041 	return ret;
2042 }
2043 
2044 /**
2045  * amdgpu_dpm_get_temp_metrics - Retrieve metrics for a specific compute
2046  * partition
2047  * @adev: Pointer to the device.
2048  * @type: Identifier for the temperature type metrics to be fetched.
2049  * @table: Pointer to a buffer where the metrics will be stored. If NULL, the
2050  * function returns the size of the metrics structure.
2051  *
2052  * This function retrieves metrics for a specific temperature type, If the
2053  * table parameter is NULL, the function returns the size of the metrics
2054  * structure without populating it.
2055  *
2056  * Return: Size of the metrics structure on success, or a negative error code on failure.
2057  */
2058 ssize_t amdgpu_dpm_get_temp_metrics(struct amdgpu_device *adev,
2059 				    enum smu_temp_metric_type type, void *table)
2060 {
2061 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2062 	int ret;
2063 
2064 	if (!pp_funcs->get_temp_metrics ||
2065 	    !amdgpu_dpm_is_temp_metrics_supported(adev, type))
2066 		return -EOPNOTSUPP;
2067 
2068 	mutex_lock(&adev->pm.mutex);
2069 	ret = pp_funcs->get_temp_metrics(adev->powerplay.pp_handle, type, table);
2070 	mutex_unlock(&adev->pm.mutex);
2071 
2072 	return ret;
2073 }
2074 
2075 /**
2076  * amdgpu_dpm_is_temp_metrics_supported - Return if specific temperature metrics support
2077  * is available
2078  * @adev: Pointer to the device.
2079  * @type: Identifier for the temperature type metrics to be fetched.
2080  *
2081  * This function returns metrics if specific temperature metrics type is supported or not.
2082  *
2083  * Return: True in case of metrics type supported else false.
2084  */
2085 bool amdgpu_dpm_is_temp_metrics_supported(struct amdgpu_device *adev,
2086 					  enum smu_temp_metric_type type)
2087 {
2088 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2089 	bool support_temp_metrics = false;
2090 
2091 	if (!pp_funcs->temp_metrics_is_supported)
2092 		return support_temp_metrics;
2093 
2094 	if (is_support_sw_smu(adev)) {
2095 		mutex_lock(&adev->pm.mutex);
2096 		support_temp_metrics =
2097 			pp_funcs->temp_metrics_is_supported(adev->powerplay.pp_handle, type);
2098 		mutex_unlock(&adev->pm.mutex);
2099 	}
2100 
2101 	return support_temp_metrics;
2102 }
2103 
2104 /**
2105  * amdgpu_dpm_get_npm_cap - Return NPM sysfs capability bitmap
2106  * @adev: Pointer to the device.
2107  *
2108  * Two bits per field (R then W). Both 0 means the field is unsupported.
2109  *
2110  * Return: Capability bitmap, or 0 if NPM is not supported.
2111  */
2112 u64 amdgpu_dpm_get_npm_cap(struct amdgpu_device *adev)
2113 {
2114 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2115 	u64 cap = 0;
2116 
2117 	if (!pp_funcs || !pp_funcs->get_npm_cap)
2118 		return 0;
2119 
2120 	mutex_lock(&adev->pm.mutex);
2121 	cap = pp_funcs->get_npm_cap(adev->powerplay.pp_handle);
2122 	mutex_unlock(&adev->pm.mutex);
2123 
2124 	return cap;
2125 }
2126 
2127 /**
2128  * amdgpu_dpm_get_xcp_metrics - Retrieve metrics for a specific compute
2129  * partition
2130  * @adev: Pointer to the device.
2131  * @xcp_id: Identifier of the XCP for which metrics are to be retrieved.
2132  * @table: Pointer to a buffer where the metrics will be stored. If NULL, the
2133  * function returns the size of the metrics structure.
2134  *
2135  * This function retrieves metrics for a specific XCP, including details such as
2136  * VCN/JPEG activity, clock frequencies, and other performance metrics. If the
2137  * table parameter is NULL, the function returns the size of the metrics
2138  * structure without populating it.
2139  *
2140  * Return: Size of the metrics structure on success, or a negative error code on failure.
2141  */
2142 ssize_t amdgpu_dpm_get_xcp_metrics(struct amdgpu_device *adev, int xcp_id,
2143 				   void *table)
2144 {
2145 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2146 	int ret = 0;
2147 
2148 	if (!pp_funcs->get_xcp_metrics)
2149 		return 0;
2150 
2151 	mutex_lock(&adev->pm.mutex);
2152 	ret = pp_funcs->get_xcp_metrics(adev->powerplay.pp_handle, xcp_id,
2153 					table);
2154 	mutex_unlock(&adev->pm.mutex);
2155 
2156 	return ret;
2157 }
2158