xref: /linux/drivers/gpu/drm/amd/pm/amdgpu_dpm.c (revision 4dd10fbbeb9c33709edc89916e19c03c780a0751)
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 /**
1086  * amdgpu_dpm_reapply_umd_profile - Restore the active UMD profile
1087  * @adev: amdgpu device
1088  *
1089  * Resume and reset retain the selected DPM level in software, but the
1090  * underlying GFX and PMFW state is lost. Reapply a retained UMD profile
1091  * after the common resume path has restored its default CG and PG state.
1092  */
1093 int amdgpu_dpm_reapply_umd_profile(struct amdgpu_device *adev)
1094 {
1095 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1096 	enum amd_dpm_forced_level level;
1097 	int ret, fallback_ret;
1098 
1099 	if (!pp_funcs || !pp_funcs->reapply_performance_level ||
1100 	    !pp_funcs->force_performance_level)
1101 		return 0;
1102 
1103 	/* Serialize the retained level with the GFX and PMFW reprogramming. */
1104 	mutex_lock(&adev->pm.mutex);
1105 	if (adev->pm.dpm.thermal_active) {
1106 		dev_warn(adev->dev,
1107 			 "Cannot restore UMD profile while thermal control is active\n");
1108 		ret = 0;
1109 		goto unlock;
1110 	}
1111 
1112 	if (pp_funcs->get_performance_level)
1113 		level = pp_funcs->get_performance_level(adev->powerplay.pp_handle);
1114 	else
1115 		level = adev->pm.dpm.forced_level;
1116 
1117 	switch (level) {
1118 	case AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD:
1119 	case AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK:
1120 	case AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK:
1121 	case AMD_DPM_FORCED_LEVEL_PROFILE_PEAK:
1122 		break;
1123 	default:
1124 		ret = 0;
1125 		goto unlock;
1126 	}
1127 
1128 	/* The active profile already owns the GFX PG reference. */
1129 	ret = amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1130 					      AMD_CG_STATE_UNGATE);
1131 	if (ret)
1132 		goto fallback_auto;
1133 
1134 	ret = amdgpu_asic_update_umd_stable_pstate(adev, true);
1135 	if (ret)
1136 		goto fallback_auto;
1137 
1138 	ret = pp_funcs->reapply_performance_level(adev->powerplay.pp_handle,
1139 						     level);
1140 	if (ret)
1141 		goto fallback_auto;
1142 
1143 unlock:
1144 	mutex_unlock(&adev->pm.mutex);
1145 
1146 	return ret;
1147 
1148 fallback_auto:
1149 	dev_warn(adev->dev, "Failed to restore UMD profile state: %d\n", ret);
1150 
1151 	/* Restore normal CG before releasing the profile's PG reference. */
1152 	amdgpu_asic_update_umd_stable_pstate(adev, false);
1153 	amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX,
1154 					       AMD_CG_STATE_GATE);
1155 	mutex_unlock(&adev->pm.mutex);
1156 
1157 	mutex_lock(&adev->pm.stable_pstate_ctx_lock);
1158 	fallback_ret = amdgpu_dpm_force_performance_level(adev,
1159 						   AMD_DPM_FORCED_LEVEL_AUTO);
1160 	if (fallback_ret)
1161 		dev_warn(adev->dev, "Failed to fall back to AUTO performance level: %d\n",
1162 			 fallback_ret);
1163 	else
1164 		adev->pm.stable_pstate_ctx = NULL;
1165 	mutex_unlock(&adev->pm.stable_pstate_ctx_lock);
1166 
1167 	return 0;
1168 }
1169 
1170 int amdgpu_dpm_force_performance_level(struct amdgpu_device *adev,
1171 				       enum amd_dpm_forced_level level)
1172 {
1173 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1174 	enum amd_dpm_forced_level current_level;
1175 	uint32_t profile_mode_mask = AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD |
1176 					AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK |
1177 					AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK |
1178 					AMD_DPM_FORCED_LEVEL_PROFILE_PEAK;
1179 
1180 	if (!pp_funcs || !pp_funcs->force_performance_level)
1181 		return 0;
1182 
1183 	if (adev->pm.dpm.thermal_active)
1184 		return -EINVAL;
1185 
1186 	current_level = amdgpu_dpm_get_performance_level(adev);
1187 	if (current_level == level)
1188 		return 0;
1189 
1190 	if (!(current_level & profile_mode_mask) &&
1191 	    (level == AMD_DPM_FORCED_LEVEL_PROFILE_EXIT))
1192 		return -EINVAL;
1193 
1194 	if (adev->asic_type == CHIP_RAVEN) {
1195 		if (!(adev->apu_flags & AMD_APU_IS_RAVEN2)) {
1196 			if (current_level != AMD_DPM_FORCED_LEVEL_MANUAL &&
1197 			    level == AMD_DPM_FORCED_LEVEL_MANUAL)
1198 				amdgpu_gfx_off_ctrl(adev, false);
1199 			else if (current_level == AMD_DPM_FORCED_LEVEL_MANUAL &&
1200 				 level != AMD_DPM_FORCED_LEVEL_MANUAL)
1201 				amdgpu_gfx_off_ctrl(adev, true);
1202 		}
1203 	}
1204 
1205 	if (!(current_level & profile_mode_mask) && (level & profile_mode_mask))
1206 		amdgpu_dpm_enter_umd_state(adev);
1207 	else if ((current_level & profile_mode_mask) &&
1208 		 !(level & profile_mode_mask))
1209 		amdgpu_dpm_exit_umd_state(adev);
1210 
1211 	mutex_lock(&adev->pm.mutex);
1212 
1213 	if (pp_funcs->force_performance_level(adev->powerplay.pp_handle,
1214 					      level)) {
1215 		mutex_unlock(&adev->pm.mutex);
1216 		/* If new level failed, retain the umd state as before */
1217 		if (!(current_level & profile_mode_mask) &&
1218 		    (level & profile_mode_mask))
1219 			amdgpu_dpm_exit_umd_state(adev);
1220 		else if ((current_level & profile_mode_mask) &&
1221 			 !(level & profile_mode_mask))
1222 			amdgpu_dpm_enter_umd_state(adev);
1223 
1224 		return -EINVAL;
1225 	}
1226 
1227 	adev->pm.dpm.forced_level = level;
1228 
1229 	mutex_unlock(&adev->pm.mutex);
1230 
1231 	return 0;
1232 }
1233 
1234 int amdgpu_dpm_get_pp_num_states(struct amdgpu_device *adev,
1235 				 struct pp_states_info *states)
1236 {
1237 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1238 	int ret = 0;
1239 
1240 	if (!pp_funcs->get_pp_num_states)
1241 		return -EOPNOTSUPP;
1242 
1243 	mutex_lock(&adev->pm.mutex);
1244 	ret = pp_funcs->get_pp_num_states(adev->powerplay.pp_handle,
1245 					  states);
1246 	mutex_unlock(&adev->pm.mutex);
1247 
1248 	return ret;
1249 }
1250 
1251 int amdgpu_dpm_dispatch_task(struct amdgpu_device *adev,
1252 			      enum amd_pp_task task_id,
1253 			      enum amd_pm_state_type *user_state)
1254 {
1255 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1256 	int ret = 0;
1257 
1258 	if (!pp_funcs->dispatch_tasks)
1259 		return -EOPNOTSUPP;
1260 
1261 	mutex_lock(&adev->pm.mutex);
1262 	ret = pp_funcs->dispatch_tasks(adev->powerplay.pp_handle,
1263 				       task_id,
1264 				       user_state);
1265 	mutex_unlock(&adev->pm.mutex);
1266 
1267 	return ret;
1268 }
1269 
1270 static bool amdgpu_dpm_is_pp_table_allowed(struct amdgpu_device *adev)
1271 {
1272 	return !amdgpu_sriov_vf(adev) &&
1273 	       !(adev->flags & AMD_IS_APU) &&
1274 	       !adev->scpm_enabled;
1275 }
1276 
1277 int amdgpu_dpm_get_pp_table(struct amdgpu_device *adev, char *table,
1278 			    size_t size)
1279 {
1280 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1281 	char *pptable = NULL;
1282 	int ret = 0;
1283 
1284 	if ((!table && size) || (table && !size))
1285 		return -EINVAL;
1286 
1287 	if (!amdgpu_dpm_is_pp_table_allowed(adev) ||
1288 	    !pp_funcs->get_pp_table)
1289 		return -EOPNOTSUPP;
1290 
1291 	mutex_lock(&adev->pm.mutex);
1292 	ret = pp_funcs->get_pp_table(adev->powerplay.pp_handle,
1293 				     &pptable);
1294 	if (ret > 0 && !pptable) {
1295 		ret = -EINVAL;
1296 	} else if (ret > 0 && table) {
1297 		ret = min_t(size_t, ret, size);
1298 		memcpy(table, pptable, ret);
1299 	}
1300 	mutex_unlock(&adev->pm.mutex);
1301 
1302 	return ret;
1303 }
1304 
1305 int amdgpu_dpm_set_fine_grain_clk_vol(struct amdgpu_device *adev,
1306 				      uint32_t type,
1307 				      long *input,
1308 				      uint32_t size)
1309 {
1310 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1311 	int ret = 0;
1312 
1313 	if (!pp_funcs->set_fine_grain_clk_vol)
1314 		return 0;
1315 
1316 	mutex_lock(&adev->pm.mutex);
1317 	ret = pp_funcs->set_fine_grain_clk_vol(adev->powerplay.pp_handle,
1318 					       type,
1319 					       input,
1320 					       size);
1321 	mutex_unlock(&adev->pm.mutex);
1322 
1323 	return ret;
1324 }
1325 
1326 int amdgpu_dpm_odn_edit_dpm_table(struct amdgpu_device *adev,
1327 				  uint32_t type,
1328 				  long *input,
1329 				  uint32_t size)
1330 {
1331 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1332 	int ret = 0;
1333 
1334 	if (!pp_funcs->odn_edit_dpm_table)
1335 		return 0;
1336 
1337 	mutex_lock(&adev->pm.mutex);
1338 	ret = pp_funcs->odn_edit_dpm_table(adev->powerplay.pp_handle,
1339 					   type,
1340 					   input,
1341 					   size);
1342 	mutex_unlock(&adev->pm.mutex);
1343 
1344 	return ret;
1345 }
1346 
1347 int amdgpu_dpm_emit_clock_levels(struct amdgpu_device *adev,
1348 				  enum pp_clock_type type,
1349 				  char *buf,
1350 				  int *offset)
1351 {
1352 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1353 	int ret = 0;
1354 
1355 	if (!pp_funcs->emit_clock_levels)
1356 		return -ENOENT;
1357 
1358 	mutex_lock(&adev->pm.mutex);
1359 	ret = pp_funcs->emit_clock_levels(adev->powerplay.pp_handle,
1360 					   type,
1361 					   buf,
1362 					   offset);
1363 	mutex_unlock(&adev->pm.mutex);
1364 
1365 	return ret;
1366 }
1367 
1368 int amdgpu_dpm_set_ppfeature_status(struct amdgpu_device *adev,
1369 				    uint64_t ppfeature_masks)
1370 {
1371 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1372 	int ret = 0;
1373 
1374 	if (!pp_funcs->set_ppfeature_status)
1375 		return 0;
1376 
1377 	mutex_lock(&adev->pm.mutex);
1378 	ret = pp_funcs->set_ppfeature_status(adev->powerplay.pp_handle,
1379 					     ppfeature_masks);
1380 	mutex_unlock(&adev->pm.mutex);
1381 
1382 	return ret;
1383 }
1384 
1385 int amdgpu_dpm_get_ppfeature_status(struct amdgpu_device *adev, char *buf)
1386 {
1387 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1388 	int ret = 0;
1389 
1390 	if (!pp_funcs->get_ppfeature_status)
1391 		return 0;
1392 
1393 	mutex_lock(&adev->pm.mutex);
1394 	ret = pp_funcs->get_ppfeature_status(adev->powerplay.pp_handle,
1395 					     buf);
1396 	mutex_unlock(&adev->pm.mutex);
1397 
1398 	return ret;
1399 }
1400 
1401 int amdgpu_dpm_force_clock_level(struct amdgpu_device *adev,
1402 				 enum pp_clock_type type,
1403 				 uint32_t mask)
1404 {
1405 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1406 	int ret = 0;
1407 
1408 	if (!pp_funcs->force_clock_level)
1409 		return 0;
1410 
1411 	mutex_lock(&adev->pm.mutex);
1412 	ret = pp_funcs->force_clock_level(adev->powerplay.pp_handle,
1413 					  type,
1414 					  mask);
1415 	mutex_unlock(&adev->pm.mutex);
1416 
1417 	return ret;
1418 }
1419 
1420 int amdgpu_dpm_get_sclk_od(struct amdgpu_device *adev)
1421 {
1422 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1423 	int ret = 0;
1424 
1425 	if (!pp_funcs->get_sclk_od)
1426 		return -EOPNOTSUPP;
1427 
1428 	mutex_lock(&adev->pm.mutex);
1429 	ret = pp_funcs->get_sclk_od(adev->powerplay.pp_handle);
1430 	mutex_unlock(&adev->pm.mutex);
1431 
1432 	return ret;
1433 }
1434 
1435 int amdgpu_dpm_set_sclk_od(struct amdgpu_device *adev, uint32_t value)
1436 {
1437 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1438 
1439 	if (is_support_sw_smu(adev))
1440 		return -EOPNOTSUPP;
1441 
1442 	mutex_lock(&adev->pm.mutex);
1443 	if (pp_funcs->set_sclk_od)
1444 		pp_funcs->set_sclk_od(adev->powerplay.pp_handle, value);
1445 	mutex_unlock(&adev->pm.mutex);
1446 
1447 	if (amdgpu_dpm_dispatch_task(adev,
1448 				     AMD_PP_TASK_READJUST_POWER_STATE,
1449 				     NULL) == -EOPNOTSUPP) {
1450 		adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
1451 		amdgpu_dpm_compute_clocks(adev);
1452 	}
1453 
1454 	return 0;
1455 }
1456 
1457 int amdgpu_dpm_get_mclk_od(struct amdgpu_device *adev)
1458 {
1459 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1460 	int ret = 0;
1461 
1462 	if (!pp_funcs->get_mclk_od)
1463 		return -EOPNOTSUPP;
1464 
1465 	mutex_lock(&adev->pm.mutex);
1466 	ret = pp_funcs->get_mclk_od(adev->powerplay.pp_handle);
1467 	mutex_unlock(&adev->pm.mutex);
1468 
1469 	return ret;
1470 }
1471 
1472 int amdgpu_dpm_set_mclk_od(struct amdgpu_device *adev, uint32_t value)
1473 {
1474 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1475 
1476 	if (is_support_sw_smu(adev))
1477 		return -EOPNOTSUPP;
1478 
1479 	mutex_lock(&adev->pm.mutex);
1480 	if (pp_funcs->set_mclk_od)
1481 		pp_funcs->set_mclk_od(adev->powerplay.pp_handle, value);
1482 	mutex_unlock(&adev->pm.mutex);
1483 
1484 	if (amdgpu_dpm_dispatch_task(adev,
1485 				     AMD_PP_TASK_READJUST_POWER_STATE,
1486 				     NULL) == -EOPNOTSUPP) {
1487 		adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps;
1488 		amdgpu_dpm_compute_clocks(adev);
1489 	}
1490 
1491 	return 0;
1492 }
1493 
1494 int amdgpu_dpm_get_power_profile_mode(struct amdgpu_device *adev,
1495 				      char *buf)
1496 {
1497 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1498 	int ret = 0;
1499 
1500 	if (!pp_funcs->get_power_profile_mode)
1501 		return -EOPNOTSUPP;
1502 
1503 	mutex_lock(&adev->pm.mutex);
1504 	ret = pp_funcs->get_power_profile_mode(adev->powerplay.pp_handle,
1505 					       buf);
1506 	mutex_unlock(&adev->pm.mutex);
1507 
1508 	return ret;
1509 }
1510 
1511 int amdgpu_dpm_set_power_profile_mode(struct amdgpu_device *adev,
1512 				      long *input, uint32_t size)
1513 {
1514 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1515 	int ret = 0;
1516 
1517 	if (!pp_funcs->set_power_profile_mode)
1518 		return 0;
1519 
1520 	mutex_lock(&adev->pm.mutex);
1521 	ret = pp_funcs->set_power_profile_mode(adev->powerplay.pp_handle,
1522 					       input,
1523 					       size);
1524 	mutex_unlock(&adev->pm.mutex);
1525 
1526 	return ret;
1527 }
1528 
1529 ssize_t amdgpu_dpm_get_gpu_metrics(struct amdgpu_device *adev, void *buf,
1530 				   size_t size)
1531 {
1532 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1533 	void *table;
1534 	ssize_t ret;
1535 
1536 	if (!pp_funcs->get_gpu_metrics)
1537 		return 0;
1538 
1539 	mutex_lock(&adev->pm.mutex);
1540 	ret = pp_funcs->get_gpu_metrics(adev->powerplay.pp_handle,
1541 					&table);
1542 	if (ret > 0) {
1543 		ret = min_t(ssize_t, ret, size);
1544 		memcpy(buf, table, ret);
1545 	}
1546 	mutex_unlock(&adev->pm.mutex);
1547 
1548 	return ret;
1549 }
1550 
1551 ssize_t amdgpu_dpm_get_pm_metrics(struct amdgpu_device *adev, void *pm_metrics,
1552 				  size_t size)
1553 {
1554 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1555 	int ret = 0;
1556 
1557 	if (!pp_funcs->get_pm_metrics)
1558 		return -EOPNOTSUPP;
1559 
1560 	mutex_lock(&adev->pm.mutex);
1561 	ret = pp_funcs->get_pm_metrics(adev->powerplay.pp_handle, pm_metrics,
1562 				       size);
1563 	mutex_unlock(&adev->pm.mutex);
1564 
1565 	return ret;
1566 }
1567 
1568 int amdgpu_dpm_get_fan_control_mode(struct amdgpu_device *adev,
1569 				    uint32_t *fan_mode)
1570 {
1571 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1572 	int ret = 0;
1573 
1574 	if (!pp_funcs->get_fan_control_mode)
1575 		return -EOPNOTSUPP;
1576 
1577 	mutex_lock(&adev->pm.mutex);
1578 	ret = pp_funcs->get_fan_control_mode(adev->powerplay.pp_handle,
1579 					     fan_mode);
1580 	mutex_unlock(&adev->pm.mutex);
1581 
1582 	return ret;
1583 }
1584 
1585 int amdgpu_dpm_set_fan_speed_pwm(struct amdgpu_device *adev,
1586 				 uint32_t speed)
1587 {
1588 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1589 	int ret = 0;
1590 
1591 	if (!pp_funcs->set_fan_speed_pwm)
1592 		return -EOPNOTSUPP;
1593 
1594 	mutex_lock(&adev->pm.mutex);
1595 	ret = pp_funcs->set_fan_speed_pwm(adev->powerplay.pp_handle,
1596 					  speed);
1597 	mutex_unlock(&adev->pm.mutex);
1598 
1599 	return ret;
1600 }
1601 
1602 int amdgpu_dpm_get_fan_speed_pwm(struct amdgpu_device *adev,
1603 				 uint32_t *speed)
1604 {
1605 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1606 	int ret = 0;
1607 
1608 	if (!pp_funcs->get_fan_speed_pwm)
1609 		return -EOPNOTSUPP;
1610 
1611 	mutex_lock(&adev->pm.mutex);
1612 	ret = pp_funcs->get_fan_speed_pwm(adev->powerplay.pp_handle,
1613 					  speed);
1614 	mutex_unlock(&adev->pm.mutex);
1615 
1616 	return ret;
1617 }
1618 
1619 int amdgpu_dpm_get_fan_speed_rpm(struct amdgpu_device *adev,
1620 				 uint32_t *speed)
1621 {
1622 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1623 	int ret = 0;
1624 
1625 	if (!pp_funcs->get_fan_speed_rpm)
1626 		return -EOPNOTSUPP;
1627 
1628 	mutex_lock(&adev->pm.mutex);
1629 	ret = pp_funcs->get_fan_speed_rpm(adev->powerplay.pp_handle,
1630 					  speed);
1631 	mutex_unlock(&adev->pm.mutex);
1632 
1633 	return ret;
1634 }
1635 
1636 int amdgpu_dpm_set_fan_speed_rpm(struct amdgpu_device *adev,
1637 				 uint32_t speed)
1638 {
1639 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1640 	int ret = 0;
1641 
1642 	if (!pp_funcs->set_fan_speed_rpm)
1643 		return -EOPNOTSUPP;
1644 
1645 	mutex_lock(&adev->pm.mutex);
1646 	ret = pp_funcs->set_fan_speed_rpm(adev->powerplay.pp_handle,
1647 					  speed);
1648 	mutex_unlock(&adev->pm.mutex);
1649 
1650 	return ret;
1651 }
1652 
1653 int amdgpu_dpm_set_fan_control_mode(struct amdgpu_device *adev,
1654 				    uint32_t mode)
1655 {
1656 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1657 	int ret = 0;
1658 
1659 	if (!pp_funcs->set_fan_control_mode)
1660 		return -EOPNOTSUPP;
1661 
1662 	mutex_lock(&adev->pm.mutex);
1663 	ret = pp_funcs->set_fan_control_mode(adev->powerplay.pp_handle,
1664 					     mode);
1665 	mutex_unlock(&adev->pm.mutex);
1666 
1667 	return ret;
1668 }
1669 
1670 int amdgpu_dpm_get_power_limit(struct amdgpu_device *adev,
1671 			       uint32_t *limit,
1672 			       enum pp_power_limit_level pp_limit_level,
1673 			       enum pp_power_type power_type)
1674 {
1675 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1676 	int ret = 0;
1677 
1678 	if (!pp_funcs->get_power_limit)
1679 		return -EOPNOTSUPP;
1680 
1681 	mutex_lock(&adev->pm.mutex);
1682 	ret = pp_funcs->get_power_limit(adev->powerplay.pp_handle,
1683 					limit,
1684 					pp_limit_level,
1685 					power_type);
1686 	mutex_unlock(&adev->pm.mutex);
1687 
1688 	return ret;
1689 }
1690 
1691 int amdgpu_dpm_set_power_limit(struct amdgpu_device *adev,
1692 			       uint32_t limit_type,
1693 			       uint32_t limit)
1694 {
1695 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1696 	int ret = 0;
1697 
1698 	if (!pp_funcs->set_power_limit)
1699 		return -EINVAL;
1700 
1701 	mutex_lock(&adev->pm.mutex);
1702 	ret = pp_funcs->set_power_limit(adev->powerplay.pp_handle,
1703 					limit_type, limit);
1704 	mutex_unlock(&adev->pm.mutex);
1705 
1706 	return ret;
1707 }
1708 
1709 int amdgpu_dpm_is_cclk_dpm_supported(struct amdgpu_device *adev)
1710 {
1711 	bool cclk_dpm_supported = false;
1712 
1713 	if (!is_support_sw_smu(adev))
1714 		return false;
1715 
1716 	mutex_lock(&adev->pm.mutex);
1717 	cclk_dpm_supported = is_support_cclk_dpm(adev);
1718 	mutex_unlock(&adev->pm.mutex);
1719 
1720 	return (int)cclk_dpm_supported;
1721 }
1722 
1723 int amdgpu_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev,
1724 						       struct seq_file *m)
1725 {
1726 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1727 
1728 	if (!pp_funcs->debugfs_print_current_performance_level)
1729 		return -EOPNOTSUPP;
1730 
1731 	mutex_lock(&adev->pm.mutex);
1732 	pp_funcs->debugfs_print_current_performance_level(adev->powerplay.pp_handle,
1733 							  m);
1734 	mutex_unlock(&adev->pm.mutex);
1735 
1736 	return 0;
1737 }
1738 
1739 int amdgpu_dpm_get_smu_prv_buf_details(struct amdgpu_device *adev,
1740 				       void **addr,
1741 				       size_t *size)
1742 {
1743 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1744 	int ret = 0;
1745 
1746 	if (!pp_funcs->get_smu_prv_buf_details)
1747 		return -ENOSYS;
1748 
1749 	mutex_lock(&adev->pm.mutex);
1750 	ret = pp_funcs->get_smu_prv_buf_details(adev->powerplay.pp_handle,
1751 						addr,
1752 						size);
1753 	mutex_unlock(&adev->pm.mutex);
1754 
1755 	return ret;
1756 }
1757 
1758 int amdgpu_dpm_is_overdrive_supported(struct amdgpu_device *adev)
1759 {
1760 	if (is_support_sw_smu(adev)) {
1761 		struct smu_context *smu = adev->powerplay.pp_handle;
1762 
1763 		return (smu->od_enabled || smu->is_apu);
1764 	} else {
1765 		struct pp_hwmgr *hwmgr;
1766 
1767 		/*
1768 		 * dpm on some legacy asics don't carry od_enabled member
1769 		 * as its pp_handle is casted directly from adev.
1770 		 */
1771 		if (amdgpu_dpm_is_legacy_dpm(adev))
1772 			return false;
1773 
1774 		hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle;
1775 
1776 		return hwmgr->od_enabled;
1777 	}
1778 }
1779 
1780 int amdgpu_dpm_is_overdrive_enabled(struct amdgpu_device *adev)
1781 {
1782 	if (is_support_sw_smu(adev)) {
1783 		struct smu_context *smu = adev->powerplay.pp_handle;
1784 
1785 		return smu->od_enabled;
1786 	} else {
1787 		struct pp_hwmgr *hwmgr;
1788 
1789 		/*
1790 		 * dpm on some legacy asics don't carry od_enabled member
1791 		 * as its pp_handle is casted directly from adev.
1792 		 */
1793 		if (amdgpu_dpm_is_legacy_dpm(adev))
1794 			return false;
1795 
1796 		hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle;
1797 
1798 		return hwmgr->od_enabled;
1799 	}
1800 }
1801 
1802 int amdgpu_dpm_set_pp_table(struct amdgpu_device *adev,
1803 			    const char *buf,
1804 			    size_t size)
1805 {
1806 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1807 	int ret = 0;
1808 
1809 	if (!buf || !size)
1810 		return -EINVAL;
1811 
1812 	if (!amdgpu_dpm_is_pp_table_allowed(adev) ||
1813 	    !pp_funcs->set_pp_table)
1814 		return -EOPNOTSUPP;
1815 
1816 	mutex_lock(&adev->pm.mutex);
1817 	ret = pp_funcs->set_pp_table(adev->powerplay.pp_handle,
1818 				     buf,
1819 				     size);
1820 	mutex_unlock(&adev->pm.mutex);
1821 
1822 	return ret;
1823 }
1824 
1825 int amdgpu_dpm_get_num_cpu_cores(struct amdgpu_device *adev)
1826 {
1827 	struct smu_context *smu = adev->powerplay.pp_handle;
1828 
1829 	if (!is_support_sw_smu(adev))
1830 		return INT_MAX;
1831 
1832 	return smu->cpu_core_num;
1833 }
1834 
1835 void amdgpu_dpm_stb_debug_fs_init(struct amdgpu_device *adev)
1836 {
1837 	if (!is_support_sw_smu(adev))
1838 		return;
1839 
1840 	amdgpu_smu_stb_debug_fs_init(adev);
1841 }
1842 
1843 int amdgpu_dpm_display_configuration_change(struct amdgpu_device *adev,
1844 					    const struct amd_pp_display_configuration *input)
1845 {
1846 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1847 	int ret = 0;
1848 
1849 	if (!pp_funcs->display_configuration_change)
1850 		return 0;
1851 
1852 	mutex_lock(&adev->pm.mutex);
1853 	ret = pp_funcs->display_configuration_change(adev->powerplay.pp_handle,
1854 						     input);
1855 	mutex_unlock(&adev->pm.mutex);
1856 
1857 	return ret;
1858 }
1859 
1860 int amdgpu_dpm_get_clock_by_type(struct amdgpu_device *adev,
1861 				 enum amd_pp_clock_type type,
1862 				 struct amd_pp_clocks *clocks)
1863 {
1864 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1865 	int ret = 0;
1866 
1867 	if (!pp_funcs->get_clock_by_type)
1868 		return 0;
1869 
1870 	mutex_lock(&adev->pm.mutex);
1871 	ret = pp_funcs->get_clock_by_type(adev->powerplay.pp_handle,
1872 					  type,
1873 					  clocks);
1874 	mutex_unlock(&adev->pm.mutex);
1875 
1876 	return ret;
1877 }
1878 
1879 int amdgpu_dpm_get_display_mode_validation_clks(struct amdgpu_device *adev,
1880 						struct amd_pp_simple_clock_info *clocks)
1881 {
1882 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1883 	int ret = 0;
1884 
1885 	if (!pp_funcs->get_display_mode_validation_clocks)
1886 		return 0;
1887 
1888 	mutex_lock(&adev->pm.mutex);
1889 	ret = pp_funcs->get_display_mode_validation_clocks(adev->powerplay.pp_handle,
1890 							   clocks);
1891 	mutex_unlock(&adev->pm.mutex);
1892 
1893 	return ret;
1894 }
1895 
1896 int amdgpu_dpm_get_clock_by_type_with_latency(struct amdgpu_device *adev,
1897 					      enum amd_pp_clock_type type,
1898 					      struct pp_clock_levels_with_latency *clocks)
1899 {
1900 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1901 	int ret = 0;
1902 
1903 	if (!pp_funcs->get_clock_by_type_with_latency)
1904 		return 0;
1905 
1906 	mutex_lock(&adev->pm.mutex);
1907 	ret = pp_funcs->get_clock_by_type_with_latency(adev->powerplay.pp_handle,
1908 						       type,
1909 						       clocks);
1910 	mutex_unlock(&adev->pm.mutex);
1911 
1912 	return ret;
1913 }
1914 
1915 int amdgpu_dpm_get_clock_by_type_with_voltage(struct amdgpu_device *adev,
1916 					      enum amd_pp_clock_type type,
1917 					      struct pp_clock_levels_with_voltage *clocks)
1918 {
1919 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1920 	int ret = 0;
1921 
1922 	if (!pp_funcs->get_clock_by_type_with_voltage)
1923 		return 0;
1924 
1925 	mutex_lock(&adev->pm.mutex);
1926 	ret = pp_funcs->get_clock_by_type_with_voltage(adev->powerplay.pp_handle,
1927 						       type,
1928 						       clocks);
1929 	mutex_unlock(&adev->pm.mutex);
1930 
1931 	return ret;
1932 }
1933 
1934 int amdgpu_dpm_set_watermarks_for_clocks_ranges(struct amdgpu_device *adev,
1935 					       void *clock_ranges)
1936 {
1937 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1938 	int ret = 0;
1939 
1940 	if (!pp_funcs->set_watermarks_for_clocks_ranges)
1941 		return -EOPNOTSUPP;
1942 
1943 	mutex_lock(&adev->pm.mutex);
1944 	ret = pp_funcs->set_watermarks_for_clocks_ranges(adev->powerplay.pp_handle,
1945 							 clock_ranges);
1946 	mutex_unlock(&adev->pm.mutex);
1947 
1948 	return ret;
1949 }
1950 
1951 int amdgpu_dpm_display_clock_voltage_request(struct amdgpu_device *adev,
1952 					     struct pp_display_clock_request *clock)
1953 {
1954 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1955 	int ret = 0;
1956 
1957 	if (!pp_funcs->display_clock_voltage_request)
1958 		return -EOPNOTSUPP;
1959 
1960 	mutex_lock(&adev->pm.mutex);
1961 	ret = pp_funcs->display_clock_voltage_request(adev->powerplay.pp_handle,
1962 						      clock);
1963 	mutex_unlock(&adev->pm.mutex);
1964 
1965 	return ret;
1966 }
1967 
1968 int amdgpu_dpm_get_current_clocks(struct amdgpu_device *adev,
1969 				  struct amd_pp_clock_info *clocks)
1970 {
1971 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1972 	int ret = 0;
1973 
1974 	if (!pp_funcs->get_current_clocks)
1975 		return -EOPNOTSUPP;
1976 
1977 	mutex_lock(&adev->pm.mutex);
1978 	ret = pp_funcs->get_current_clocks(adev->powerplay.pp_handle,
1979 					   clocks);
1980 	mutex_unlock(&adev->pm.mutex);
1981 
1982 	return ret;
1983 }
1984 
1985 void amdgpu_dpm_notify_smu_enable_pwe(struct amdgpu_device *adev)
1986 {
1987 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
1988 
1989 	if (!pp_funcs->notify_smu_enable_pwe)
1990 		return;
1991 
1992 	mutex_lock(&adev->pm.mutex);
1993 	pp_funcs->notify_smu_enable_pwe(adev->powerplay.pp_handle);
1994 	mutex_unlock(&adev->pm.mutex);
1995 }
1996 
1997 int amdgpu_dpm_set_active_display_count(struct amdgpu_device *adev,
1998 					uint32_t count)
1999 {
2000 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2001 	int ret = 0;
2002 
2003 	if (!pp_funcs->set_active_display_count)
2004 		return -EOPNOTSUPP;
2005 
2006 	mutex_lock(&adev->pm.mutex);
2007 	ret = pp_funcs->set_active_display_count(adev->powerplay.pp_handle,
2008 						 count);
2009 	mutex_unlock(&adev->pm.mutex);
2010 
2011 	return ret;
2012 }
2013 
2014 int amdgpu_dpm_set_min_deep_sleep_dcefclk(struct amdgpu_device *adev,
2015 					  uint32_t clock)
2016 {
2017 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2018 	int ret = 0;
2019 
2020 	if (!pp_funcs->set_min_deep_sleep_dcefclk)
2021 		return -EOPNOTSUPP;
2022 
2023 	mutex_lock(&adev->pm.mutex);
2024 	ret = pp_funcs->set_min_deep_sleep_dcefclk(adev->powerplay.pp_handle,
2025 						   clock);
2026 	mutex_unlock(&adev->pm.mutex);
2027 
2028 	return ret;
2029 }
2030 
2031 void amdgpu_dpm_set_hard_min_dcefclk_by_freq(struct amdgpu_device *adev,
2032 					     uint32_t clock)
2033 {
2034 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2035 
2036 	if (!pp_funcs->set_hard_min_dcefclk_by_freq)
2037 		return;
2038 
2039 	mutex_lock(&adev->pm.mutex);
2040 	pp_funcs->set_hard_min_dcefclk_by_freq(adev->powerplay.pp_handle,
2041 					       clock);
2042 	mutex_unlock(&adev->pm.mutex);
2043 }
2044 
2045 void amdgpu_dpm_set_hard_min_fclk_by_freq(struct amdgpu_device *adev,
2046 					  uint32_t clock)
2047 {
2048 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2049 
2050 	if (!pp_funcs->set_hard_min_fclk_by_freq)
2051 		return;
2052 
2053 	mutex_lock(&adev->pm.mutex);
2054 	pp_funcs->set_hard_min_fclk_by_freq(adev->powerplay.pp_handle,
2055 					    clock);
2056 	mutex_unlock(&adev->pm.mutex);
2057 }
2058 
2059 int amdgpu_dpm_display_disable_memory_clock_switch(struct amdgpu_device *adev,
2060 						   bool disable_memory_clock_switch)
2061 {
2062 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2063 	int ret = 0;
2064 
2065 	if (!pp_funcs->display_disable_memory_clock_switch)
2066 		return 0;
2067 
2068 	mutex_lock(&adev->pm.mutex);
2069 	ret = pp_funcs->display_disable_memory_clock_switch(adev->powerplay.pp_handle,
2070 							    disable_memory_clock_switch);
2071 	mutex_unlock(&adev->pm.mutex);
2072 
2073 	return ret;
2074 }
2075 
2076 int amdgpu_dpm_get_max_sustainable_clocks_by_dc(struct amdgpu_device *adev,
2077 						struct pp_smu_nv_clock_table *max_clocks)
2078 {
2079 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2080 	int ret = 0;
2081 
2082 	if (!pp_funcs->get_max_sustainable_clocks_by_dc)
2083 		return -EOPNOTSUPP;
2084 
2085 	mutex_lock(&adev->pm.mutex);
2086 	ret = pp_funcs->get_max_sustainable_clocks_by_dc(adev->powerplay.pp_handle,
2087 							 max_clocks);
2088 	mutex_unlock(&adev->pm.mutex);
2089 
2090 	return ret;
2091 }
2092 
2093 enum pp_smu_status amdgpu_dpm_get_uclk_dpm_states(struct amdgpu_device *adev,
2094 						  unsigned int *clock_values_in_khz,
2095 						  unsigned int *num_states)
2096 {
2097 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2098 	int ret = 0;
2099 
2100 	if (!pp_funcs->get_uclk_dpm_states)
2101 		return -EOPNOTSUPP;
2102 
2103 	mutex_lock(&adev->pm.mutex);
2104 	ret = pp_funcs->get_uclk_dpm_states(adev->powerplay.pp_handle,
2105 					    clock_values_in_khz,
2106 					    num_states);
2107 	mutex_unlock(&adev->pm.mutex);
2108 
2109 	return ret;
2110 }
2111 
2112 int amdgpu_dpm_get_dpm_clock_table(struct amdgpu_device *adev,
2113 				   struct dpm_clocks *clock_table)
2114 {
2115 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2116 	int ret = 0;
2117 
2118 	if (!pp_funcs->get_dpm_clock_table)
2119 		return -EOPNOTSUPP;
2120 
2121 	mutex_lock(&adev->pm.mutex);
2122 	ret = pp_funcs->get_dpm_clock_table(adev->powerplay.pp_handle,
2123 					    clock_table);
2124 	mutex_unlock(&adev->pm.mutex);
2125 
2126 	return ret;
2127 }
2128 
2129 /**
2130  * amdgpu_dpm_get_temp_metrics - Retrieve metrics for a specific compute
2131  * partition
2132  * @adev: Pointer to the device.
2133  * @type: Identifier for the temperature type metrics to be fetched.
2134  * @table: Pointer to a buffer where the metrics will be stored. If NULL, the
2135  * function returns the size of the metrics structure.
2136  *
2137  * This function retrieves metrics for a specific temperature type, If the
2138  * table parameter is NULL, the function returns the size of the metrics
2139  * structure without populating it.
2140  *
2141  * Return: Size of the metrics structure on success, or a negative error code on failure.
2142  */
2143 ssize_t amdgpu_dpm_get_temp_metrics(struct amdgpu_device *adev,
2144 				    enum smu_temp_metric_type type, void *table)
2145 {
2146 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2147 	int ret;
2148 
2149 	if (!pp_funcs->get_temp_metrics ||
2150 	    !amdgpu_dpm_is_temp_metrics_supported(adev, type))
2151 		return -EOPNOTSUPP;
2152 
2153 	mutex_lock(&adev->pm.mutex);
2154 	ret = pp_funcs->get_temp_metrics(adev->powerplay.pp_handle, type, table);
2155 	mutex_unlock(&adev->pm.mutex);
2156 
2157 	return ret;
2158 }
2159 
2160 /**
2161  * amdgpu_dpm_is_temp_metrics_supported - Return if specific temperature metrics support
2162  * is available
2163  * @adev: Pointer to the device.
2164  * @type: Identifier for the temperature type metrics to be fetched.
2165  *
2166  * This function returns metrics if specific temperature metrics type is supported or not.
2167  *
2168  * Return: True in case of metrics type supported else false.
2169  */
2170 bool amdgpu_dpm_is_temp_metrics_supported(struct amdgpu_device *adev,
2171 					  enum smu_temp_metric_type type)
2172 {
2173 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2174 	bool support_temp_metrics = false;
2175 
2176 	if (!pp_funcs->temp_metrics_is_supported)
2177 		return support_temp_metrics;
2178 
2179 	if (is_support_sw_smu(adev)) {
2180 		mutex_lock(&adev->pm.mutex);
2181 		support_temp_metrics =
2182 			pp_funcs->temp_metrics_is_supported(adev->powerplay.pp_handle, type);
2183 		mutex_unlock(&adev->pm.mutex);
2184 	}
2185 
2186 	return support_temp_metrics;
2187 }
2188 
2189 /**
2190  * amdgpu_dpm_get_npm_cap - Return NPM sysfs capability bitmap
2191  * @adev: Pointer to the device.
2192  *
2193  * Two bits per field (R then W). Both 0 means the field is unsupported.
2194  *
2195  * Return: Capability bitmap, or 0 if NPM is not supported.
2196  */
2197 u64 amdgpu_dpm_get_npm_cap(struct amdgpu_device *adev)
2198 {
2199 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2200 	u64 cap = 0;
2201 
2202 	if (!pp_funcs || !pp_funcs->get_npm_cap)
2203 		return 0;
2204 
2205 	mutex_lock(&adev->pm.mutex);
2206 	cap = pp_funcs->get_npm_cap(adev->powerplay.pp_handle);
2207 	mutex_unlock(&adev->pm.mutex);
2208 
2209 	return cap;
2210 }
2211 
2212 int amdgpu_dpm_set_npm_limit(struct amdgpu_device *adev, uint32_t limit)
2213 {
2214 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2215 	int ret;
2216 
2217 	if (!pp_funcs || !pp_funcs->set_npm_limit)
2218 		return -EOPNOTSUPP;
2219 
2220 	if (amdgpu_sriov_vf(adev))
2221 		return -EPERM;
2222 
2223 	mutex_lock(&adev->pm.mutex);
2224 	ret = pp_funcs->set_npm_limit(adev->powerplay.pp_handle, limit);
2225 	mutex_unlock(&adev->pm.mutex);
2226 
2227 	return ret;
2228 }
2229 
2230 /**
2231  * amdgpu_dpm_get_xcp_metrics - Retrieve metrics for a specific compute
2232  * partition
2233  * @adev: Pointer to the device.
2234  * @xcp_id: Identifier of the XCP for which metrics are to be retrieved.
2235  * @table: Pointer to a buffer where the metrics will be stored. If NULL, the
2236  * function returns the size of the metrics structure.
2237  *
2238  * This function retrieves metrics for a specific XCP, including details such as
2239  * VCN/JPEG activity, clock frequencies, and other performance metrics. If the
2240  * table parameter is NULL, the function returns the size of the metrics
2241  * structure without populating it.
2242  *
2243  * Return: Size of the metrics structure on success, or a negative error code on failure.
2244  */
2245 ssize_t amdgpu_dpm_get_xcp_metrics(struct amdgpu_device *adev, int xcp_id,
2246 				   void *table)
2247 {
2248 	const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs;
2249 	int ret = 0;
2250 
2251 	if (!pp_funcs->get_xcp_metrics)
2252 		return 0;
2253 
2254 	mutex_lock(&adev->pm.mutex);
2255 	ret = pp_funcs->get_xcp_metrics(adev->powerplay.pp_handle, xcp_id,
2256 					table);
2257 	mutex_unlock(&adev->pm.mutex);
2258 
2259 	return ret;
2260 }
2261