xref: /linux/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c (revision 4dd10fbbeb9c33709edc89916e19c03c780a0751)
1 /*
2  * Copyright 2008 Advanced Micro Devices, Inc.
3  * Copyright 2008 Red Hat Inc.
4  * Copyright 2009 Jerome Glisse.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22  * OTHER DEALINGS IN THE SOFTWARE.
23  *
24  * Authors: Dave Airlie
25  *          Alex Deucher
26  *          Jerome Glisse
27  */
28 
29 #include "amdgpu.h"
30 #include <drm/amdgpu_drm.h>
31 #include <drm/clients/drm_fbdev_helper.h>
32 #include <drm/drm_drv.h>
33 #include <drm/drm_vblank.h>
34 #include "amdgpu_uvd.h"
35 #include "amdgpu_vce.h"
36 #include "atom.h"
37 
38 #include <linux/vga_switcheroo.h>
39 #include <linux/slab.h>
40 #include <linux/uaccess.h>
41 #include <linux/pci.h>
42 #include <linux/pm_runtime.h>
43 #include "amdgpu_amdkfd.h"
44 #include "amdgpu_gem.h"
45 #include "amdgpu_display.h"
46 #include "amdgpu_ras.h"
47 #include "amdgpu_reset.h"
48 #include "amd_pcie.h"
49 #include "amdgpu_userq.h"
50 #include "amdgpu_video_codecs.h"
51 #include "amdgpu_ras_mgr.h"
52 
53 void amdgpu_unregister_gpu_instance(struct amdgpu_device *adev)
54 {
55 	struct amdgpu_gpu_instance *gpu_instance;
56 	int i;
57 
58 	mutex_lock(&mgpu_info.mutex);
59 
60 	for (i = 0; i < mgpu_info.num_gpu; i++) {
61 		gpu_instance = &(mgpu_info.gpu_ins[i]);
62 		if (gpu_instance->adev == adev) {
63 			mgpu_info.gpu_ins[i] =
64 				mgpu_info.gpu_ins[mgpu_info.num_gpu - 1];
65 			mgpu_info.num_gpu--;
66 			if (adev->flags & AMD_IS_APU)
67 				mgpu_info.num_apu--;
68 			else
69 				mgpu_info.num_dgpu--;
70 			break;
71 		}
72 	}
73 
74 	mutex_unlock(&mgpu_info.mutex);
75 }
76 
77 /**
78  * amdgpu_driver_unload_kms - Main unload function for KMS.
79  *
80  * @dev: drm dev pointer
81  *
82  * This is the main unload function for KMS (all asics).
83  * Returns 0 on success.
84  */
85 void amdgpu_driver_unload_kms(struct drm_device *dev)
86 {
87 	struct amdgpu_device *adev = drm_to_adev(dev);
88 
89 	if (adev == NULL || !adev->num_ip_blocks)
90 		return;
91 
92 	amdgpu_unregister_gpu_instance(adev);
93 
94 	if (adev->rmmio == NULL)
95 		return;
96 
97 	if (amdgpu_acpi_smart_shift_update(adev, AMDGPU_SS_DRV_UNLOAD))
98 		drm_warn(dev, "smart shift update failed\n");
99 
100 	amdgpu_acpi_fini(adev);
101 	amdgpu_device_fini_hw(adev);
102 }
103 
104 void amdgpu_register_gpu_instance(struct amdgpu_device *adev)
105 {
106 	struct amdgpu_gpu_instance *gpu_instance;
107 
108 	mutex_lock(&mgpu_info.mutex);
109 
110 	if (mgpu_info.num_gpu >= MAX_GPU_INSTANCE) {
111 		drm_err(adev_to_drm(adev), "Cannot register more gpu instance\n");
112 		mutex_unlock(&mgpu_info.mutex);
113 		return;
114 	}
115 
116 	gpu_instance = &(mgpu_info.gpu_ins[mgpu_info.num_gpu]);
117 	gpu_instance->adev = adev;
118 	gpu_instance->mgpu_fan_enabled = 0;
119 
120 	mgpu_info.num_gpu++;
121 	if (adev->flags & AMD_IS_APU)
122 		mgpu_info.num_apu++;
123 	else
124 		mgpu_info.num_dgpu++;
125 
126 	mutex_unlock(&mgpu_info.mutex);
127 }
128 
129 /**
130  * amdgpu_driver_load_kms - Main load function for KMS.
131  *
132  * @adev: pointer to struct amdgpu_device
133  * @flags: device flags
134  *
135  * This is the main load function for KMS (all asics).
136  * Returns 0 on success, error on failure.
137  */
138 int amdgpu_driver_load_kms(struct amdgpu_device *adev, unsigned long flags)
139 {
140 	struct drm_device *dev;
141 	int r, acpi_status;
142 
143 	dev = adev_to_drm(adev);
144 
145 	/* amdgpu_device_init should report only fatal error
146 	 * like memory allocation failure or iomapping failure,
147 	 * or memory manager initialization failure, it must
148 	 * properly initialize the GPU MC controller and permit
149 	 * VRAM allocation
150 	 */
151 	r = amdgpu_device_init(adev, flags);
152 	if (r) {
153 		dev_err(dev->dev, "Fatal error during GPU init\n");
154 		goto out;
155 	}
156 
157 	amdgpu_device_detect_runtime_pm_mode(adev);
158 
159 	/* Call ACPI methods: require modeset init
160 	 * but failure is not fatal
161 	 */
162 
163 	acpi_status = amdgpu_acpi_init(adev);
164 	if (acpi_status)
165 		dev_dbg(dev->dev, "Error during ACPI methods call\n");
166 
167 	if (amdgpu_acpi_smart_shift_update(adev, AMDGPU_SS_DRV_LOAD))
168 		drm_warn(dev, "smart shift update failed\n");
169 
170 out:
171 	if (r)
172 		amdgpu_driver_unload_kms(dev);
173 
174 	return r;
175 }
176 
177 static enum amd_ip_block_type
178 	amdgpu_ip_get_block_type(struct amdgpu_device *adev, uint32_t ip)
179 {
180 	enum amd_ip_block_type type;
181 
182 	switch (ip) {
183 	case AMDGPU_HW_IP_GFX:
184 		type = AMD_IP_BLOCK_TYPE_GFX;
185 		break;
186 	case AMDGPU_HW_IP_COMPUTE:
187 		type = AMD_IP_BLOCK_TYPE_GFX;
188 		break;
189 	case AMDGPU_HW_IP_DMA:
190 		type = AMD_IP_BLOCK_TYPE_SDMA;
191 		break;
192 	case AMDGPU_HW_IP_UVD:
193 	case AMDGPU_HW_IP_UVD_ENC:
194 		type = AMD_IP_BLOCK_TYPE_UVD;
195 		break;
196 	case AMDGPU_HW_IP_VCE:
197 		type = AMD_IP_BLOCK_TYPE_VCE;
198 		break;
199 	case AMDGPU_HW_IP_VCN_DEC:
200 	case AMDGPU_HW_IP_VCN_ENC:
201 		type = AMD_IP_BLOCK_TYPE_VCN;
202 		break;
203 	case AMDGPU_HW_IP_VCN_JPEG:
204 		type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ?
205 				   AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN;
206 		break;
207 	case AMDGPU_HW_IP_VPE:
208 		type = AMD_IP_BLOCK_TYPE_VPE;
209 		break;
210 	default:
211 		type = AMD_IP_BLOCK_TYPE_NUM;
212 		break;
213 	}
214 
215 	return type;
216 }
217 
218 static int amdgpu_firmware_info(struct drm_amdgpu_info_firmware *fw_info,
219 				struct drm_amdgpu_query_fw *query_fw,
220 				struct amdgpu_device *adev)
221 {
222 	switch (query_fw->fw_type) {
223 	case AMDGPU_INFO_FW_VCE:
224 		fw_info->ver = adev->vce.fw_version;
225 		fw_info->feature = adev->vce.fb_version;
226 		break;
227 	case AMDGPU_INFO_FW_UVD:
228 		fw_info->ver = adev->uvd.fw_version;
229 		fw_info->feature = 0;
230 		break;
231 	case AMDGPU_INFO_FW_VCN:
232 		fw_info->ver = adev->vcn.fw_version;
233 		fw_info->feature = 0;
234 		break;
235 	case AMDGPU_INFO_FW_GMC:
236 		fw_info->ver = adev->gmc.fw_version;
237 		fw_info->feature = 0;
238 		break;
239 	case AMDGPU_INFO_FW_GFX_ME:
240 		fw_info->ver = adev->gfx.me_fw_version;
241 		fw_info->feature = adev->gfx.me_feature_version;
242 		break;
243 	case AMDGPU_INFO_FW_GFX_PFP:
244 		fw_info->ver = adev->gfx.pfp_fw_version;
245 		fw_info->feature = adev->gfx.pfp_feature_version;
246 		break;
247 	case AMDGPU_INFO_FW_GFX_CE:
248 		fw_info->ver = adev->gfx.ce_fw_version;
249 		fw_info->feature = adev->gfx.ce_feature_version;
250 		break;
251 	case AMDGPU_INFO_FW_GFX_RLC:
252 		fw_info->ver = adev->gfx.rlc_fw_version;
253 		fw_info->feature = adev->gfx.rlc_feature_version;
254 		break;
255 	case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_CNTL:
256 		fw_info->ver = adev->gfx.rlc_srlc_fw_version;
257 		fw_info->feature = adev->gfx.rlc_srlc_feature_version;
258 		break;
259 	case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_GPM_MEM:
260 		fw_info->ver = adev->gfx.rlc_srlg_fw_version;
261 		fw_info->feature = adev->gfx.rlc_srlg_feature_version;
262 		break;
263 	case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_SRM_MEM:
264 		fw_info->ver = adev->gfx.rlc_srls_fw_version;
265 		fw_info->feature = adev->gfx.rlc_srls_feature_version;
266 		break;
267 	case AMDGPU_INFO_FW_GFX_RLCP:
268 		fw_info->ver = adev->gfx.rlcp_ucode_version;
269 		fw_info->feature = adev->gfx.rlcp_ucode_feature_version;
270 		break;
271 	case AMDGPU_INFO_FW_GFX_RLCV:
272 		fw_info->ver = adev->gfx.rlcv_ucode_version;
273 		fw_info->feature = adev->gfx.rlcv_ucode_feature_version;
274 		break;
275 	case AMDGPU_INFO_FW_GFX_MEC:
276 		if (query_fw->index == 0) {
277 			fw_info->ver = adev->gfx.mec_fw_version;
278 			fw_info->feature = adev->gfx.mec_feature_version;
279 		} else if (query_fw->index == 1) {
280 			fw_info->ver = adev->gfx.mec2_fw_version;
281 			fw_info->feature = adev->gfx.mec2_feature_version;
282 		} else
283 			return -EINVAL;
284 		break;
285 	case AMDGPU_INFO_FW_SMC:
286 		fw_info->ver = adev->pm.fw_version;
287 		fw_info->feature = 0;
288 		break;
289 	case AMDGPU_INFO_FW_MP5:
290 		fw_info->ver = adev->pm.mp5_fw_version;
291 		fw_info->feature = 0;
292 		break;
293 	case AMDGPU_INFO_FW_TA:
294 		switch (query_fw->index) {
295 		case TA_FW_TYPE_PSP_XGMI:
296 			fw_info->ver = adev->psp.xgmi_context.context.bin_desc.fw_version;
297 			fw_info->feature = adev->psp.xgmi_context.context
298 						   .bin_desc.feature_version;
299 			break;
300 		case TA_FW_TYPE_PSP_RAS:
301 			fw_info->ver = adev->psp.ras_context.context.bin_desc.fw_version;
302 			fw_info->feature = adev->psp.ras_context.context
303 						   .bin_desc.feature_version;
304 			break;
305 		case TA_FW_TYPE_PSP_HDCP:
306 			fw_info->ver = adev->psp.hdcp_context.context.bin_desc.fw_version;
307 			fw_info->feature = adev->psp.hdcp_context.context
308 						   .bin_desc.feature_version;
309 			break;
310 		case TA_FW_TYPE_PSP_DTM:
311 			fw_info->ver = adev->psp.dtm_context.context.bin_desc.fw_version;
312 			fw_info->feature = adev->psp.dtm_context.context
313 						   .bin_desc.feature_version;
314 			break;
315 		case TA_FW_TYPE_PSP_RAP:
316 			fw_info->ver = adev->psp.rap_context.context.bin_desc.fw_version;
317 			fw_info->feature = adev->psp.rap_context.context
318 						   .bin_desc.feature_version;
319 			break;
320 		case TA_FW_TYPE_PSP_SECUREDISPLAY:
321 			fw_info->ver = adev->psp.securedisplay_context.context.bin_desc.fw_version;
322 			fw_info->feature =
323 				adev->psp.securedisplay_context.context.bin_desc
324 					.feature_version;
325 			break;
326 		default:
327 			return -EINVAL;
328 		}
329 		break;
330 	case AMDGPU_INFO_FW_SDMA:
331 		if (query_fw->index >= adev->sdma.num_instances)
332 			return -EINVAL;
333 		fw_info->ver = adev->sdma.instance[query_fw->index].fw_version;
334 		fw_info->feature = adev->sdma.instance[query_fw->index].feature_version;
335 		break;
336 	case AMDGPU_INFO_FW_SOS:
337 		fw_info->ver = adev->psp.sos.fw_version;
338 		fw_info->feature = adev->psp.sos.feature_version;
339 		break;
340 	case AMDGPU_INFO_FW_ASD:
341 		fw_info->ver = adev->psp.asd_context.bin_desc.fw_version;
342 		fw_info->feature = adev->psp.asd_context.bin_desc.feature_version;
343 		break;
344 	case AMDGPU_INFO_FW_DMCU:
345 		fw_info->ver = adev->dm.dmcu_fw_version;
346 		fw_info->feature = 0;
347 		break;
348 	case AMDGPU_INFO_FW_DMCUB:
349 		fw_info->ver = adev->dm.dmcub_fw_version;
350 		fw_info->feature = 0;
351 		break;
352 	case AMDGPU_INFO_FW_TOC:
353 		fw_info->ver = adev->psp.toc.fw_version;
354 		fw_info->feature = adev->psp.toc.feature_version;
355 		break;
356 	case AMDGPU_INFO_FW_CAP:
357 		fw_info->ver = adev->psp.cap.fw_version;
358 		fw_info->feature = adev->psp.cap.feature_version;
359 		break;
360 	case AMDGPU_INFO_FW_MES_KIQ:
361 		fw_info->ver = adev->mes.kiq_version & AMDGPU_MES_VERSION_MASK;
362 		fw_info->feature = (adev->mes.kiq_version & AMDGPU_MES_FEAT_VERSION_MASK)
363 					>> AMDGPU_MES_FEAT_VERSION_SHIFT;
364 		break;
365 	case AMDGPU_INFO_FW_MES:
366 		fw_info->ver = adev->mes.sched_version & AMDGPU_MES_VERSION_MASK;
367 		fw_info->feature = (adev->mes.sched_version & AMDGPU_MES_FEAT_VERSION_MASK)
368 					>> AMDGPU_MES_FEAT_VERSION_SHIFT;
369 		break;
370 	case AMDGPU_INFO_FW_IMU:
371 		fw_info->ver = adev->gfx.imu_fw_version;
372 		fw_info->feature = 0;
373 		break;
374 	case AMDGPU_INFO_FW_VPE:
375 		fw_info->ver = adev->vpe.fw_version;
376 		fw_info->feature = adev->vpe.feature_version;
377 		break;
378 	default:
379 		return -EINVAL;
380 	}
381 	return 0;
382 }
383 
384 static int amdgpu_userq_metadata_info_gfx(struct amdgpu_device *adev,
385 					  struct drm_amdgpu_info *info,
386 					  struct drm_amdgpu_info_uq_metadata_gfx *meta)
387 {
388 	int ret = -EOPNOTSUPP;
389 
390 	if (adev->gfx.funcs->get_gfx_shadow_info) {
391 		struct amdgpu_gfx_shadow_info shadow = {};
392 
393 		adev->gfx.funcs->get_gfx_shadow_info(adev, &shadow, true);
394 		meta->shadow_size = shadow.shadow_size;
395 		meta->shadow_alignment = shadow.shadow_alignment;
396 		meta->csa_size = shadow.csa_size;
397 		meta->csa_alignment = shadow.csa_alignment;
398 		ret = 0;
399 	}
400 
401 	return ret;
402 }
403 
404 static int amdgpu_userq_metadata_info_compute(struct amdgpu_device *adev,
405 					      struct drm_amdgpu_info *info,
406 					      struct drm_amdgpu_info_uq_metadata_compute *meta)
407 {
408 	int ret = -EOPNOTSUPP;
409 
410 	if (adev->gfx.funcs->get_gfx_shadow_info) {
411 		struct amdgpu_gfx_shadow_info shadow = {};
412 
413 		adev->gfx.funcs->get_gfx_shadow_info(adev, &shadow, true);
414 		meta->eop_size = shadow.eop_size;
415 		meta->eop_alignment = shadow.eop_alignment;
416 		ret = 0;
417 	}
418 
419 	return ret;
420 }
421 
422 static int amdgpu_userq_metadata_info_sdma(struct amdgpu_device *adev,
423 					   struct drm_amdgpu_info *info,
424 					   struct drm_amdgpu_info_uq_metadata_sdma *meta)
425 {
426 	int ret = -EOPNOTSUPP;
427 
428 	if (adev->sdma.get_csa_info) {
429 		struct amdgpu_sdma_csa_info csa = {};
430 
431 		adev->sdma.get_csa_info(adev, &csa);
432 		meta->csa_size = csa.size;
433 		meta->csa_alignment = csa.alignment;
434 		ret = 0;
435 	}
436 
437 	return ret;
438 }
439 
440 static int amdgpu_hw_ip_info(struct amdgpu_device *adev,
441 			     struct drm_amdgpu_info *info,
442 			     struct drm_amdgpu_info_hw_ip *result)
443 {
444 	uint32_t ib_start_alignment = 0;
445 	uint32_t ib_size_alignment = 0;
446 	enum amd_ip_block_type type;
447 	unsigned int num_rings = 0;
448 	uint32_t num_slots = 0;
449 	unsigned int i, j;
450 
451 	if (info->query_hw_ip.ip_instance >= AMDGPU_HW_IP_INSTANCE_MAX_COUNT)
452 		return -EINVAL;
453 
454 	switch (info->query_hw_ip.type) {
455 	case AMDGPU_HW_IP_GFX:
456 		type = AMD_IP_BLOCK_TYPE_GFX;
457 		for (i = 0; i < adev->gfx.num_gfx_rings; i++)
458 			if (adev->gfx.gfx_ring[i].sched.ready &&
459 			    !adev->gfx.gfx_ring[i].no_user_submission)
460 				++num_rings;
461 
462 		if (!adev->gfx.disable_uq) {
463 			for (i = 0; i < AMDGPU_MES_MAX_GFX_PIPES; i++)
464 				num_slots += hweight32(adev->mes.gfx_hqd_mask[i]);
465 		}
466 
467 		ib_start_alignment = 32;
468 		ib_size_alignment = 32;
469 		break;
470 	case AMDGPU_HW_IP_COMPUTE:
471 		type = AMD_IP_BLOCK_TYPE_GFX;
472 		for (i = 0; i < adev->gfx.num_compute_rings; i++)
473 			if (adev->gfx.compute_ring[i].sched.ready &&
474 			    !adev->gfx.compute_ring[i].no_user_submission)
475 				++num_rings;
476 
477 		if (!adev->sdma.disable_uq) {
478 			for (i = 0; i < AMDGPU_MES_MAX_COMPUTE_PIPES; i++)
479 				num_slots += hweight32(adev->mes.compute_hqd_mask[i]);
480 		}
481 
482 		ib_start_alignment = 32;
483 		ib_size_alignment = 32;
484 		break;
485 	case AMDGPU_HW_IP_DMA:
486 		type = AMD_IP_BLOCK_TYPE_SDMA;
487 		for (i = 0; i < adev->sdma.num_instances; i++)
488 			if (adev->sdma.instance[i].ring.sched.ready &&
489 			    !adev->sdma.instance[i].ring.no_user_submission)
490 				++num_rings;
491 
492 		if (!adev->gfx.disable_uq) {
493 			for (i = 0; i < AMDGPU_MES_MAX_SDMA_PIPES; i++)
494 				num_slots += hweight32(adev->mes.sdma_hqd_mask[i]);
495 		}
496 
497 		ib_start_alignment = 256;
498 		ib_size_alignment = 4;
499 		break;
500 	case AMDGPU_HW_IP_UVD:
501 		type = AMD_IP_BLOCK_TYPE_UVD;
502 		for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
503 			if (adev->uvd.harvest_config & (1 << i))
504 				continue;
505 
506 			if (adev->uvd.inst[i].ring.sched.ready &&
507 			    !adev->uvd.inst[i].ring.no_user_submission)
508 				++num_rings;
509 		}
510 		ib_start_alignment = 256;
511 		ib_size_alignment = 64;
512 		break;
513 	case AMDGPU_HW_IP_VCE:
514 		type = AMD_IP_BLOCK_TYPE_VCE;
515 		for (i = 0; i < adev->vce.num_rings; i++)
516 			if (adev->vce.ring[i].sched.ready &&
517 			    !adev->vce.ring[i].no_user_submission)
518 				++num_rings;
519 		ib_start_alignment = 256;
520 		ib_size_alignment = 4;
521 		break;
522 	case AMDGPU_HW_IP_UVD_ENC:
523 		type = AMD_IP_BLOCK_TYPE_UVD;
524 		for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
525 			if (adev->uvd.harvest_config & (1 << i))
526 				continue;
527 
528 			for (j = 0; j < adev->uvd.num_enc_rings; j++)
529 				if (adev->uvd.inst[i].ring_enc[j].sched.ready &&
530 				    !adev->uvd.inst[i].ring_enc[j].no_user_submission)
531 					++num_rings;
532 		}
533 		ib_start_alignment = 256;
534 		ib_size_alignment = 4;
535 		break;
536 	case AMDGPU_HW_IP_VCN_DEC:
537 		type = AMD_IP_BLOCK_TYPE_VCN;
538 		for (i = 0; i < adev->vcn.num_vcn_inst; i++) {
539 			if (adev->vcn.harvest_config & (1 << i))
540 				continue;
541 
542 			if (adev->vcn.inst[i].ring_dec.sched.ready &&
543 			    !adev->vcn.inst[i].ring_dec.no_user_submission)
544 				++num_rings;
545 		}
546 		ib_start_alignment = 256;
547 		ib_size_alignment = 64;
548 		break;
549 	case AMDGPU_HW_IP_VCN_ENC:
550 		type = AMD_IP_BLOCK_TYPE_VCN;
551 		for (i = 0; i < adev->vcn.num_vcn_inst; i++) {
552 			if (adev->vcn.harvest_config & (1 << i))
553 				continue;
554 
555 			for (j = 0; j < adev->vcn.inst[i].num_enc_rings; j++)
556 				if (adev->vcn.inst[i].ring_enc[j].sched.ready &&
557 				    !adev->vcn.inst[i].ring_enc[j].no_user_submission)
558 					++num_rings;
559 		}
560 		ib_start_alignment = 256;
561 		ib_size_alignment = 4;
562 		break;
563 	case AMDGPU_HW_IP_VCN_JPEG:
564 		type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ?
565 			AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN;
566 
567 		for (i = 0; i < adev->jpeg.num_jpeg_inst; i++) {
568 			if (adev->jpeg.harvest_config & (1 << i))
569 				continue;
570 
571 			for (j = 0; j < adev->jpeg.num_jpeg_rings; j++)
572 				if (adev->jpeg.inst[i].ring_dec[j].sched.ready &&
573 				    !adev->jpeg.inst[i].ring_dec[j].no_user_submission)
574 					++num_rings;
575 		}
576 		ib_start_alignment = 256;
577 		ib_size_alignment = 64;
578 		break;
579 	case AMDGPU_HW_IP_VPE:
580 		type = AMD_IP_BLOCK_TYPE_VPE;
581 		if (adev->vpe.ring.sched.ready &&
582 		    !adev->vpe.ring.no_user_submission)
583 			++num_rings;
584 		ib_start_alignment = 256;
585 		ib_size_alignment = 4;
586 		break;
587 	default:
588 		return -EINVAL;
589 	}
590 
591 	for (i = 0; i < adev->num_ip_blocks; i++)
592 		if (adev->ip_blocks[i].version->type == type &&
593 		    adev->ip_blocks[i].status.valid)
594 			break;
595 
596 	if (i == adev->num_ip_blocks)
597 		return 0;
598 
599 	num_rings = min(amdgpu_ctx_num_entities[info->query_hw_ip.type],
600 			num_rings);
601 
602 	result->hw_ip_version_major = adev->ip_blocks[i].version->major;
603 	result->hw_ip_version_minor = adev->ip_blocks[i].version->minor;
604 
605 	if (adev->asic_type >= CHIP_VEGA10) {
606 		switch (type) {
607 		case AMD_IP_BLOCK_TYPE_GFX:
608 			result->ip_discovery_version =
609 				IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, GC_HWIP, 0));
610 			break;
611 		case AMD_IP_BLOCK_TYPE_SDMA:
612 			result->ip_discovery_version =
613 				IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, SDMA0_HWIP, 0));
614 			break;
615 		case AMD_IP_BLOCK_TYPE_UVD:
616 		case AMD_IP_BLOCK_TYPE_VCN:
617 		case AMD_IP_BLOCK_TYPE_JPEG:
618 			result->ip_discovery_version =
619 				IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, UVD_HWIP, 0));
620 			break;
621 		case AMD_IP_BLOCK_TYPE_VCE:
622 			result->ip_discovery_version =
623 				IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, VCE_HWIP, 0));
624 			break;
625 		case AMD_IP_BLOCK_TYPE_VPE:
626 			result->ip_discovery_version =
627 				IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, VPE_HWIP, 0));
628 			break;
629 		default:
630 			result->ip_discovery_version = 0;
631 			break;
632 		}
633 	} else {
634 		result->ip_discovery_version = 0;
635 	}
636 	result->capabilities_flags = 0;
637 	result->available_rings = (1 << num_rings) - 1;
638 	result->userq_num_slots = num_slots;
639 	result->ib_start_alignment = ib_start_alignment;
640 	result->ib_size_alignment = ib_size_alignment;
641 	return 0;
642 }
643 
644 /*
645  * Userspace get information ioctl
646  */
647 /**
648  * amdgpu_info_ioctl - answer a device specific request.
649  *
650  * @dev: drm device pointer
651  * @data: request object
652  * @filp: drm filp
653  *
654  * This function is used to pass device specific parameters to the userspace
655  * drivers.  Examples include: pci device id, pipeline parms, tiling params,
656  * etc. (all asics).
657  * Returns 0 on success, -EINVAL on failure.
658  */
659 int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
660 {
661 	struct amdgpu_device *adev = drm_to_adev(dev);
662 	struct drm_amdgpu_info *info = data;
663 	struct amdgpu_mode_info *minfo = &adev->mode_info;
664 	void __user *out = (void __user *)(uintptr_t)info->return_pointer;
665 	struct amdgpu_fpriv *fpriv;
666 	struct amdgpu_ip_block *ip_block;
667 	enum amd_ip_block_type type;
668 	struct amdgpu_xcp *xcp;
669 	u32 count, inst_mask;
670 	uint32_t size = info->return_size;
671 	struct drm_crtc *crtc;
672 	uint32_t ui32 = 0;
673 	uint64_t ui64 = 0;
674 	int i, found, ret;
675 	int ui32_size = sizeof(ui32);
676 
677 	if (!info->return_size || !info->return_pointer)
678 		return -EINVAL;
679 
680 	switch (info->query) {
681 	case AMDGPU_INFO_ACCEL_WORKING:
682 		ui32 = adev->accel_working;
683 		return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
684 	case AMDGPU_INFO_CRTC_FROM_ID:
685 		for (i = 0, found = 0; i < adev->mode_info.num_crtc; i++) {
686 			crtc = (struct drm_crtc *)minfo->crtcs[i];
687 			if (crtc && crtc->base.id == info->mode_crtc.id) {
688 				struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
689 
690 				ui32 = amdgpu_crtc->crtc_id;
691 				found = 1;
692 				break;
693 			}
694 		}
695 		if (!found) {
696 			DRM_DEBUG_KMS("unknown crtc id %d\n", info->mode_crtc.id);
697 			return -EINVAL;
698 		}
699 		return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
700 	case AMDGPU_INFO_HW_IP_INFO: {
701 		struct drm_amdgpu_info_hw_ip ip = {};
702 
703 		ret = amdgpu_hw_ip_info(adev, info, &ip);
704 		if (ret)
705 			return ret;
706 
707 		ret = copy_to_user(out, &ip, min_t(size_t, size, sizeof(ip)));
708 		return ret ? -EFAULT : 0;
709 	}
710 	case AMDGPU_INFO_HW_IP_COUNT: {
711 		fpriv = (struct amdgpu_fpriv *)filp->driver_priv;
712 		type = amdgpu_ip_get_block_type(adev, info->query_hw_ip.type);
713 		ip_block = amdgpu_device_ip_get_ip_block(adev, type);
714 
715 		if (!ip_block || !ip_block->status.valid)
716 			return -EINVAL;
717 
718 		if (adev->xcp_mgr && adev->xcp_mgr->num_xcps > 0 &&
719 		    fpriv->xcp_id < adev->xcp_mgr->num_xcps) {
720 			xcp = &adev->xcp_mgr->xcp[fpriv->xcp_id];
721 			switch (type) {
722 			case AMD_IP_BLOCK_TYPE_GFX:
723 				ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_GFX, &inst_mask);
724 				if (ret)
725 					return ret;
726 				count = hweight32(inst_mask);
727 				break;
728 			case AMD_IP_BLOCK_TYPE_SDMA:
729 				ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_SDMA, &inst_mask);
730 				if (ret)
731 					return ret;
732 				count = hweight32(inst_mask);
733 				break;
734 			case AMD_IP_BLOCK_TYPE_JPEG:
735 				ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_VCN, &inst_mask);
736 				if (ret)
737 					return ret;
738 				count = hweight32(inst_mask) * adev->jpeg.num_jpeg_rings;
739 				break;
740 			case AMD_IP_BLOCK_TYPE_VCN:
741 				ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_VCN, &inst_mask);
742 				if (ret)
743 					return ret;
744 				count = hweight32(inst_mask);
745 				break;
746 			default:
747 				return -EINVAL;
748 			}
749 
750 			return copy_to_user(out, &count, min(size, 4u)) ? -EFAULT : 0;
751 		}
752 
753 		switch (type) {
754 		case AMD_IP_BLOCK_TYPE_GFX:
755 		case AMD_IP_BLOCK_TYPE_VCE:
756 			count = 1;
757 			break;
758 		case AMD_IP_BLOCK_TYPE_SDMA:
759 			count = adev->sdma.num_instances;
760 			break;
761 		case AMD_IP_BLOCK_TYPE_JPEG:
762 			count = adev->jpeg.num_jpeg_inst * adev->jpeg.num_jpeg_rings;
763 			break;
764 		case AMD_IP_BLOCK_TYPE_VCN:
765 			count = adev->vcn.num_vcn_inst;
766 			break;
767 		case AMD_IP_BLOCK_TYPE_UVD:
768 			count = adev->uvd.num_uvd_inst;
769 			break;
770 		case AMD_IP_BLOCK_TYPE_VPE:
771 			count = adev->vpe.num_instances;
772 			break;
773 		/* For all other IP block types not listed in the switch statement
774 		 * the ip status is valid here and the instance count is one.
775 		 */
776 		default:
777 			count = 1;
778 			break;
779 		}
780 
781 		return copy_to_user(out, &count, min(size, 4u)) ? -EFAULT : 0;
782 	}
783 	case AMDGPU_INFO_TIMESTAMP: {
784 		PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm);
785 
786 		ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
787 		if (ret)
788 			return ret;
789 
790 		ui64 = amdgpu_gfx_get_gpu_clock_counter(adev);
791 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
792 	}
793 	case AMDGPU_INFO_FW_VERSION: {
794 		struct drm_amdgpu_info_firmware fw_info;
795 
796 		/* We only support one instance of each IP block right now. */
797 		if (info->query_fw.ip_instance != 0)
798 			return -EINVAL;
799 
800 		ret = amdgpu_firmware_info(&fw_info, &info->query_fw, adev);
801 		if (ret)
802 			return ret;
803 
804 		return copy_to_user(out, &fw_info,
805 				    min((size_t)size, sizeof(fw_info))) ? -EFAULT : 0;
806 	}
807 	case AMDGPU_INFO_NUM_BYTES_MOVED:
808 		ui64 = atomic64_read(&adev->num_bytes_moved);
809 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
810 	case AMDGPU_INFO_NUM_EVICTIONS:
811 		ui64 = atomic64_read(&adev->num_evictions);
812 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
813 	case AMDGPU_INFO_NUM_VRAM_CPU_PAGE_FAULTS:
814 		ui64 = atomic64_read(&adev->num_vram_cpu_page_faults);
815 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
816 	case AMDGPU_INFO_VRAM_USAGE:
817 		ui64 = ttm_resource_manager_used(&adev->mman.vram_mgr.manager) ?
818 			ttm_resource_manager_usage(&adev->mman.vram_mgr.manager) : 0;
819 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
820 	case AMDGPU_INFO_VIS_VRAM_USAGE:
821 		ui64 = amdgpu_vram_mgr_vis_usage(&adev->mman.vram_mgr);
822 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
823 	case AMDGPU_INFO_GTT_USAGE:
824 		ui64 = ttm_resource_manager_usage(&adev->mman.gtt_mgr.manager);
825 		return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
826 	case AMDGPU_INFO_GDS_CONFIG: {
827 		struct drm_amdgpu_info_gds gds_info;
828 
829 		memset(&gds_info, 0, sizeof(gds_info));
830 		gds_info.compute_partition_size = adev->gds.gds_size;
831 		gds_info.gds_total_size = adev->gds.gds_size;
832 		gds_info.gws_per_compute_partition = adev->gds.gws_size;
833 		gds_info.oa_per_compute_partition = adev->gds.oa_size;
834 		return copy_to_user(out, &gds_info,
835 				    min((size_t)size, sizeof(gds_info))) ? -EFAULT : 0;
836 	}
837 	case AMDGPU_INFO_VRAM_GTT: {
838 		struct drm_amdgpu_info_vram_gtt vram_gtt;
839 
840 		vram_gtt.vram_size = adev->gmc.real_vram_size -
841 			atomic64_read(&adev->vram_pin_size) -
842 			AMDGPU_VM_RESERVED_VRAM;
843 		vram_gtt.vram_cpu_accessible_size =
844 			min(adev->gmc.visible_vram_size -
845 			    atomic64_read(&adev->visible_pin_size),
846 			    vram_gtt.vram_size);
847 		vram_gtt.gtt_size = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT)->size;
848 		vram_gtt.gtt_size -= atomic64_read(&adev->gart_pin_size);
849 		return copy_to_user(out, &vram_gtt,
850 				    min((size_t)size, sizeof(vram_gtt))) ? -EFAULT : 0;
851 	}
852 	case AMDGPU_INFO_MEMORY: {
853 		struct drm_amdgpu_memory_info mem;
854 		struct ttm_resource_manager *gtt_man =
855 			&adev->mman.gtt_mgr.manager;
856 		struct ttm_resource_manager *vram_man =
857 			&adev->mman.vram_mgr.manager;
858 
859 		memset(&mem, 0, sizeof(mem));
860 		mem.vram.total_heap_size = adev->gmc.real_vram_size;
861 		mem.vram.usable_heap_size = adev->gmc.real_vram_size -
862 			atomic64_read(&adev->vram_pin_size) -
863 			AMDGPU_VM_RESERVED_VRAM;
864 		mem.vram.heap_usage = ttm_resource_manager_used(&adev->mman.vram_mgr.manager) ?
865 				ttm_resource_manager_usage(vram_man) : 0;
866 		mem.vram.max_allocation = mem.vram.usable_heap_size * 3 / 4;
867 
868 		mem.cpu_accessible_vram.total_heap_size =
869 			adev->gmc.visible_vram_size;
870 		mem.cpu_accessible_vram.usable_heap_size =
871 			min(adev->gmc.visible_vram_size -
872 			    atomic64_read(&adev->visible_pin_size),
873 			    mem.vram.usable_heap_size);
874 		mem.cpu_accessible_vram.heap_usage =
875 			amdgpu_vram_mgr_vis_usage(&adev->mman.vram_mgr);
876 		mem.cpu_accessible_vram.max_allocation =
877 			mem.cpu_accessible_vram.usable_heap_size * 3 / 4;
878 
879 		mem.gtt.total_heap_size = gtt_man->size;
880 		mem.gtt.usable_heap_size = mem.gtt.total_heap_size -
881 			atomic64_read(&adev->gart_pin_size);
882 		mem.gtt.heap_usage = ttm_resource_manager_usage(gtt_man);
883 		mem.gtt.max_allocation = mem.gtt.usable_heap_size * 3 / 4;
884 
885 		return copy_to_user(out, &mem,
886 				    min((size_t)size, sizeof(mem)))
887 				    ? -EFAULT : 0;
888 	}
889 	case AMDGPU_INFO_READ_MMR_REG: {
890 		unsigned int se_num = (info->read_mmr_reg.instance >>
891 				   AMDGPU_INFO_MMR_SE_INDEX_SHIFT) &
892 				  AMDGPU_INFO_MMR_SE_INDEX_MASK;
893 		unsigned int sh_num = (info->read_mmr_reg.instance >>
894 				   AMDGPU_INFO_MMR_SH_INDEX_SHIFT) &
895 				  AMDGPU_INFO_MMR_SH_INDEX_MASK;
896 		unsigned int alloc_size;
897 		uint32_t *regs;
898 		int ret;
899 
900 		/* set full masks if the userspace set all bits
901 		 * in the bitfields
902 		 */
903 		if (se_num == AMDGPU_INFO_MMR_SE_INDEX_MASK)
904 			se_num = 0xffffffff;
905 		else if (se_num >= AMDGPU_GFX_MAX_SE)
906 			return -EINVAL;
907 
908 		if (sh_num == AMDGPU_INFO_MMR_SH_INDEX_MASK)
909 			sh_num = 0xffffffff;
910 		else if (sh_num >= AMDGPU_GFX_MAX_SH_PER_SE)
911 			return -EINVAL;
912 
913 		if (info->read_mmr_reg.count > 128)
914 			return -EINVAL;
915 
916 		PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm);
917 
918 		ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
919 		if (ret)
920 			return ret;
921 
922 		regs = kmalloc_objs(*regs, info->read_mmr_reg.count);
923 		if (!regs)
924 			return -ENOMEM;
925 
926 		down_read(&adev->reset_domain->sem);
927 		alloc_size = info->read_mmr_reg.count * sizeof(*regs);
928 		amdgpu_gfx_off_ctrl(adev, false);
929 		ret = 0;
930 		for (i = 0; i < info->read_mmr_reg.count; i++) {
931 			if (amdgpu_asic_read_register(adev, se_num, sh_num,
932 						      info->read_mmr_reg.dword_offset + i,
933 						      &regs[i])) {
934 				DRM_DEBUG_KMS("unallowed offset %#x\n",
935 					      info->read_mmr_reg.dword_offset + i);
936 				ret = -EFAULT;
937 				break;
938 			}
939 		}
940 		amdgpu_gfx_off_ctrl(adev, true);
941 		up_read(&adev->reset_domain->sem);
942 
943 		if (!ret) {
944 			ret = copy_to_user(out, regs, min(size, alloc_size))
945 				? -EFAULT : 0;
946 		}
947 		kfree(regs);
948 		return ret;
949 	}
950 	case AMDGPU_INFO_DEV_INFO: {
951 		struct drm_amdgpu_info_device *dev_info;
952 		uint64_t vm_size;
953 		uint32_t pcie_gen_mask, pcie_width_mask;
954 
955 		/* The clock limits are only available while the SMU is up. */
956 		PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm);
957 
958 		ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
959 		if (ret)
960 			return ret;
961 
962 		dev_info = kzalloc_obj(*dev_info);
963 		if (!dev_info)
964 			return -ENOMEM;
965 
966 		dev_info->device_id = adev->pdev->device;
967 		dev_info->chip_rev = adev->rev_id;
968 		dev_info->external_rev = adev->external_rev_id;
969 		dev_info->pci_rev = adev->pdev->revision;
970 		dev_info->family = adev->family;
971 		dev_info->num_shader_engines = adev->gfx.config.max_shader_engines;
972 		dev_info->num_shader_arrays_per_engine = adev->gfx.config.max_sh_per_se;
973 		/* return all clocks in KHz */
974 		dev_info->gpu_counter_freq = amdgpu_asic_get_xclk(adev) * 10;
975 		if (adev->pm.dpm_enabled) {
976 			dev_info->max_engine_clock = amdgpu_dpm_get_sclk(adev, false) * 10;
977 			dev_info->max_memory_clock = amdgpu_dpm_get_mclk(adev, false) * 10;
978 			dev_info->min_engine_clock = amdgpu_dpm_get_sclk(adev, true) * 10;
979 			dev_info->min_memory_clock = amdgpu_dpm_get_mclk(adev, true) * 10;
980 		} else {
981 			dev_info->max_engine_clock =
982 				dev_info->min_engine_clock =
983 					adev->clock.default_sclk * 10;
984 			dev_info->max_memory_clock =
985 				dev_info->min_memory_clock =
986 					adev->clock.default_mclk * 10;
987 		}
988 		dev_info->enabled_rb_pipes_mask = adev->gfx.config.backend_enable_mask;
989 		dev_info->num_rb_pipes = adev->gfx.config.max_backends_per_se *
990 			adev->gfx.config.max_shader_engines;
991 		dev_info->num_hw_gfx_contexts = adev->gfx.config.max_hw_contexts;
992 		dev_info->ids_flags = 0;
993 		if (adev->flags & AMD_IS_APU)
994 			dev_info->ids_flags |= AMDGPU_IDS_FLAGS_FUSION;
995 		if (adev->gfx.mcbp)
996 			dev_info->ids_flags |= AMDGPU_IDS_FLAGS_PREEMPTION;
997 		if (amdgpu_is_tmz(adev))
998 			dev_info->ids_flags |= AMDGPU_IDS_FLAGS_TMZ;
999 		if (adev->gfx.config.ta_cntl2_truncate_coord_mode)
1000 			dev_info->ids_flags |= AMDGPU_IDS_FLAGS_CONFORMANT_TRUNC_COORD;
1001 
1002 		/* Gang submit is not supported under SRIOV currently */
1003 		if (!amdgpu_sriov_vf(adev))
1004 			dev_info->ids_flags |= AMDGPU_IDS_FLAGS_GANG_SUBMIT;
1005 
1006 		if (amdgpu_passthrough(adev))
1007 			dev_info->ids_flags |= (AMDGPU_IDS_FLAGS_MODE_PT <<
1008 						AMDGPU_IDS_FLAGS_MODE_SHIFT) &
1009 						AMDGPU_IDS_FLAGS_MODE_MASK;
1010 		else if (amdgpu_sriov_vf(adev))
1011 			dev_info->ids_flags |= (AMDGPU_IDS_FLAGS_MODE_VF <<
1012 						AMDGPU_IDS_FLAGS_MODE_SHIFT) &
1013 						AMDGPU_IDS_FLAGS_MODE_MASK;
1014 
1015 		vm_size = adev->vm_manager.max_pfn * AMDGPU_GPU_PAGE_SIZE;
1016 		vm_size -= AMDGPU_VA_RESERVED_TOP;
1017 
1018 		/* Older VCE FW versions are buggy and can handle only 40bits */
1019 		if (adev->vce.fw_version &&
1020 		    adev->vce.fw_version < AMDGPU_VCE_FW_53_45)
1021 			vm_size = min(vm_size, 1ULL << 40);
1022 
1023 		dev_info->virtual_address_offset = AMDGPU_VA_RESERVED_BOTTOM;
1024 		dev_info->virtual_address_max =
1025 			min(vm_size, AMDGPU_GMC_HOLE_START);
1026 
1027 		if (vm_size > AMDGPU_GMC_HOLE_START) {
1028 			dev_info->high_va_offset = AMDGPU_GMC_HOLE_END;
1029 			dev_info->high_va_max = AMDGPU_GMC_HOLE_END | vm_size;
1030 		}
1031 		dev_info->virtual_address_alignment = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
1032 		dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;
1033 		dev_info->gart_page_size = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
1034 		dev_info->cu_active_number = adev->gfx.cu_info.number;
1035 		dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;
1036 		dev_info->ce_ram_size = adev->gfx.ce_ram_size;
1037 		memcpy(&dev_info->cu_ao_bitmap[0], &adev->gfx.cu_info.ao_cu_bitmap[0],
1038 		       sizeof(adev->gfx.cu_info.ao_cu_bitmap));
1039 		memcpy(&dev_info->cu_bitmap[0], &adev->gfx.cu_info.bitmap[0],
1040 		       sizeof(dev_info->cu_bitmap));
1041 		dev_info->vram_type = adev->gmc.vram_type;
1042 		dev_info->vram_bit_width = adev->gmc.vram_width;
1043 		dev_info->vce_harvest_config = adev->vce.harvest_config;
1044 		dev_info->gc_double_offchip_lds_buf =
1045 			adev->gfx.config.double_offchip_lds_buf;
1046 		dev_info->wave_front_size = adev->gfx.cu_info.wave_front_size;
1047 		dev_info->num_shader_visible_vgprs = adev->gfx.config.max_gprs;
1048 		dev_info->num_cu_per_sh = adev->gfx.config.max_cu_per_sh;
1049 		dev_info->num_tcc_blocks = adev->gfx.config.max_texture_channel_caches;
1050 		dev_info->gs_vgt_table_depth = adev->gfx.config.gs_vgt_table_depth;
1051 		dev_info->gs_prim_buffer_depth = adev->gfx.config.gs_prim_buffer_depth;
1052 		dev_info->max_gs_waves_per_vgt = adev->gfx.config.max_gs_threads;
1053 
1054 		if (adev->family >= AMDGPU_FAMILY_NV)
1055 			dev_info->pa_sc_tile_steering_override =
1056 				adev->gfx.config.pa_sc_tile_steering_override;
1057 
1058 		dev_info->tcc_disabled_mask = adev->gfx.config.tcc_disabled_mask;
1059 
1060 		/* Combine the chip gen mask with the platform (CPU/mobo) mask. */
1061 		pcie_gen_mask = adev->pm.pcie_gen_mask &
1062 			(adev->pm.pcie_gen_mask >> CAIL_PCIE_LINK_SPEED_SUPPORT_SHIFT);
1063 		pcie_width_mask = adev->pm.pcie_mlw_mask &
1064 			(adev->pm.pcie_mlw_mask >> CAIL_PCIE_LINK_WIDTH_SUPPORT_SHIFT);
1065 		dev_info->pcie_gen = fls(pcie_gen_mask);
1066 		dev_info->pcie_num_lanes =
1067 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X32 ? 32 :
1068 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X16 ? 16 :
1069 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X12 ? 12 :
1070 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X8 ? 8 :
1071 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X4 ? 4 :
1072 			pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X2 ? 2 : 1;
1073 
1074 		dev_info->tcp_cache_size = adev->gfx.config.gc_tcp_l1_size;
1075 		dev_info->num_sqc_per_wgp = adev->gfx.config.gc_num_sqc_per_wgp;
1076 		dev_info->sqc_data_cache_size = adev->gfx.config.gc_l1_data_cache_size_per_sqc;
1077 		dev_info->sqc_inst_cache_size = adev->gfx.config.gc_l1_instruction_cache_size_per_sqc;
1078 		dev_info->gl1c_cache_size = adev->gfx.config.gc_gl1c_size_per_instance *
1079 					    adev->gfx.config.gc_gl1c_per_sa;
1080 		dev_info->gl2c_cache_size = adev->gfx.config.gc_gl2c_per_gpu;
1081 		dev_info->mall_size = adev->gmc.mall_size;
1082 
1083 
1084 		if (adev->gfx.funcs->get_gfx_shadow_info) {
1085 			struct amdgpu_gfx_shadow_info shadow_info;
1086 
1087 			ret = amdgpu_gfx_get_gfx_shadow_info(adev, &shadow_info);
1088 			if (!ret) {
1089 				dev_info->shadow_size = shadow_info.shadow_size;
1090 				dev_info->shadow_alignment = shadow_info.shadow_alignment;
1091 				dev_info->csa_size = shadow_info.csa_size;
1092 				dev_info->csa_alignment = shadow_info.csa_alignment;
1093 			}
1094 		}
1095 
1096 		dev_info->userq_ip_mask = amdgpu_userq_get_supported_ip_mask(adev);
1097 
1098 		ret = copy_to_user(out, dev_info,
1099 				   min((size_t)size, sizeof(*dev_info))) ? -EFAULT : 0;
1100 		kfree(dev_info);
1101 		return ret;
1102 	}
1103 	case AMDGPU_INFO_VCE_CLOCK_TABLE: {
1104 		unsigned int i;
1105 		struct drm_amdgpu_info_vce_clock_table vce_clk_table = {};
1106 		struct amd_vce_state *vce_state;
1107 
1108 		for (i = 0; i < AMDGPU_VCE_CLOCK_TABLE_ENTRIES; i++) {
1109 			vce_state = amdgpu_dpm_get_vce_clock_state(adev, i);
1110 			if (vce_state) {
1111 				vce_clk_table.entries[i].sclk = vce_state->sclk;
1112 				vce_clk_table.entries[i].mclk = vce_state->mclk;
1113 				vce_clk_table.entries[i].eclk = vce_state->evclk;
1114 				vce_clk_table.num_valid_entries++;
1115 			}
1116 		}
1117 
1118 		return copy_to_user(out, &vce_clk_table,
1119 				    min((size_t)size, sizeof(vce_clk_table))) ? -EFAULT : 0;
1120 	}
1121 	case AMDGPU_INFO_VBIOS: {
1122 		uint32_t bios_size = adev->bios_size;
1123 
1124 		switch (info->vbios_info.type) {
1125 		case AMDGPU_INFO_VBIOS_SIZE:
1126 			return copy_to_user(out, &bios_size,
1127 					min((size_t)size, sizeof(bios_size)))
1128 					? -EFAULT : 0;
1129 		case AMDGPU_INFO_VBIOS_IMAGE: {
1130 			uint8_t *bios;
1131 			uint32_t bios_offset = info->vbios_info.offset;
1132 
1133 			if (bios_offset >= bios_size)
1134 				return -EINVAL;
1135 
1136 			bios = adev->bios + bios_offset;
1137 			return copy_to_user(out, bios,
1138 					    min((size_t)size, (size_t)(bios_size - bios_offset)))
1139 					? -EFAULT : 0;
1140 		}
1141 		case AMDGPU_INFO_VBIOS_INFO: {
1142 			struct drm_amdgpu_info_vbios vbios_info = {};
1143 			struct atom_context *atom_context;
1144 
1145 			atom_context = adev->mode_info.atom_context;
1146 			if (atom_context) {
1147 				memcpy(vbios_info.name, atom_context->name,
1148 				       sizeof(atom_context->name));
1149 				memcpy(vbios_info.vbios_pn, atom_context->vbios_pn,
1150 				       sizeof(atom_context->vbios_pn));
1151 				vbios_info.version = atom_context->version;
1152 				memcpy(vbios_info.vbios_ver_str, atom_context->vbios_ver_str,
1153 				       sizeof(atom_context->vbios_ver_str));
1154 				memcpy(vbios_info.date, atom_context->date,
1155 				       sizeof(atom_context->date));
1156 			}
1157 
1158 			return copy_to_user(out, &vbios_info,
1159 						min((size_t)size, sizeof(vbios_info))) ? -EFAULT : 0;
1160 		}
1161 		default:
1162 			DRM_DEBUG_KMS("Invalid request %d\n",
1163 					info->vbios_info.type);
1164 			return -EINVAL;
1165 		}
1166 	}
1167 	case AMDGPU_INFO_NUM_HANDLES: {
1168 		struct drm_amdgpu_info_num_handles handle;
1169 
1170 		switch (info->query_hw_ip.type) {
1171 		case AMDGPU_HW_IP_UVD:
1172 			/* Starting Polaris, we support unlimited UVD handles */
1173 			if (adev->asic_type < CHIP_POLARIS10) {
1174 				handle.uvd_max_handles = adev->uvd.max_handles;
1175 				handle.uvd_used_handles = amdgpu_uvd_used_handles(adev);
1176 
1177 				return copy_to_user(out, &handle,
1178 					min((size_t)size, sizeof(handle))) ? -EFAULT : 0;
1179 			} else {
1180 				return -ENODATA;
1181 			}
1182 
1183 			break;
1184 		default:
1185 			return -EINVAL;
1186 		}
1187 	}
1188 	case AMDGPU_INFO_SENSOR: {
1189 		PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm);
1190 
1191 		ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
1192 		if (ret)
1193 			return ret;
1194 
1195 		if (!adev->pm.dpm_enabled)
1196 			return -ENOENT;
1197 
1198 		switch (info->sensor_info.type) {
1199 		case AMDGPU_INFO_SENSOR_GFX_SCLK:
1200 			/* get sclk in Mhz */
1201 			if (amdgpu_dpm_read_sensor(adev,
1202 						   AMDGPU_PP_SENSOR_GFX_SCLK,
1203 						   (void *)&ui32, &ui32_size)) {
1204 				return -EINVAL;
1205 			}
1206 			ui32 /= 100;
1207 			break;
1208 		case AMDGPU_INFO_SENSOR_GFX_MCLK:
1209 			/* get mclk in Mhz */
1210 			if (amdgpu_dpm_read_sensor(adev,
1211 						   AMDGPU_PP_SENSOR_GFX_MCLK,
1212 						   (void *)&ui32, &ui32_size)) {
1213 				return -EINVAL;
1214 			}
1215 			ui32 /= 100;
1216 			break;
1217 		case AMDGPU_INFO_SENSOR_GPU_TEMP:
1218 			/* get temperature in millidegrees C */
1219 			if (amdgpu_dpm_read_sensor(adev,
1220 						   AMDGPU_PP_SENSOR_GPU_TEMP,
1221 						   (void *)&ui32, &ui32_size)) {
1222 				return -EINVAL;
1223 			}
1224 			break;
1225 		case AMDGPU_INFO_SENSOR_GPU_LOAD:
1226 			/* get GPU load */
1227 			if (amdgpu_dpm_read_sensor(adev,
1228 						   AMDGPU_PP_SENSOR_GPU_LOAD,
1229 						   (void *)&ui32, &ui32_size)) {
1230 				return -EINVAL;
1231 			}
1232 			break;
1233 		case AMDGPU_INFO_SENSOR_GPU_AVG_POWER:
1234 			/* get average GPU power */
1235 			if (amdgpu_dpm_read_sensor(adev,
1236 						   AMDGPU_PP_SENSOR_GPU_AVG_POWER,
1237 						   (void *)&ui32, &ui32_size)) {
1238 				/* fall back to input power for backwards compat */
1239 				if (amdgpu_dpm_read_sensor(adev,
1240 							   AMDGPU_PP_SENSOR_GPU_INPUT_POWER,
1241 							   (void *)&ui32, &ui32_size)) {
1242 					return -EINVAL;
1243 				}
1244 			}
1245 			ui32 /= MILLIWATT_PER_WATT;
1246 			break;
1247 		case AMDGPU_INFO_SENSOR_GPU_INPUT_POWER:
1248 			/* get input GPU power */
1249 			if (amdgpu_dpm_read_sensor(adev,
1250 						   AMDGPU_PP_SENSOR_GPU_INPUT_POWER,
1251 						   (void *)&ui32, &ui32_size)) {
1252 				return -EINVAL;
1253 			}
1254 			ui32 /= MILLIWATT_PER_WATT;
1255 			break;
1256 		case AMDGPU_INFO_SENSOR_VDDNB:
1257 			/* get VDDNB in millivolts */
1258 			if (amdgpu_dpm_read_sensor(adev,
1259 						   AMDGPU_PP_SENSOR_VDDNB,
1260 						   (void *)&ui32, &ui32_size)) {
1261 				return -EINVAL;
1262 			}
1263 			break;
1264 		case AMDGPU_INFO_SENSOR_VDDGFX:
1265 			/* get VDDGFX in millivolts */
1266 			if (amdgpu_dpm_read_sensor(adev,
1267 						   AMDGPU_PP_SENSOR_VDDGFX,
1268 						   (void *)&ui32, &ui32_size)) {
1269 				return -EINVAL;
1270 			}
1271 			break;
1272 		case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_SCLK:
1273 			/* get stable pstate sclk in Mhz */
1274 			if (amdgpu_dpm_read_sensor(adev,
1275 						   AMDGPU_PP_SENSOR_STABLE_PSTATE_SCLK,
1276 						   (void *)&ui32, &ui32_size)) {
1277 				return -EINVAL;
1278 			}
1279 			ui32 /= 100;
1280 			break;
1281 		case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_MCLK:
1282 			/* get stable pstate mclk in Mhz */
1283 			if (amdgpu_dpm_read_sensor(adev,
1284 						   AMDGPU_PP_SENSOR_STABLE_PSTATE_MCLK,
1285 						   (void *)&ui32, &ui32_size)) {
1286 				return -EINVAL;
1287 			}
1288 			ui32 /= 100;
1289 			break;
1290 		case AMDGPU_INFO_SENSOR_PEAK_PSTATE_GFX_SCLK:
1291 			/* get peak pstate sclk in Mhz */
1292 			if (amdgpu_dpm_read_sensor(adev,
1293 						   AMDGPU_PP_SENSOR_PEAK_PSTATE_SCLK,
1294 						   (void *)&ui32, &ui32_size)) {
1295 				return -EINVAL;
1296 			}
1297 			ui32 /= 100;
1298 			break;
1299 		case AMDGPU_INFO_SENSOR_PEAK_PSTATE_GFX_MCLK:
1300 			/* get peak pstate mclk in Mhz */
1301 			if (amdgpu_dpm_read_sensor(adev,
1302 						   AMDGPU_PP_SENSOR_PEAK_PSTATE_MCLK,
1303 						   (void *)&ui32, &ui32_size)) {
1304 				return -EINVAL;
1305 			}
1306 			ui32 /= 100;
1307 			break;
1308 		default:
1309 			DRM_DEBUG_KMS("Invalid request %d\n",
1310 				      info->sensor_info.type);
1311 			return -EINVAL;
1312 		}
1313 		return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
1314 	}
1315 	case AMDGPU_INFO_VRAM_LOST_COUNTER:
1316 		ui32 = atomic_read(&adev->vram_lost_counter);
1317 		return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
1318 	case AMDGPU_INFO_RAS_ENABLED_FEATURES: {
1319 		struct amdgpu_ras *ras = amdgpu_ras_get_context(adev);
1320 		uint64_t ras_mask;
1321 
1322 		if (!ras)
1323 			return -EINVAL;
1324 
1325 		if (amdgpu_uniras_enabled(adev))
1326 			ras_mask = amdgpu_uniras_get_ras_caps(adev);
1327 		else
1328 			ras_mask = (uint64_t)adev->ras_enabled << 32 | ras->features;
1329 
1330 		return copy_to_user(out, &ras_mask,
1331 				min_t(u64, size, sizeof(ras_mask))) ?
1332 			-EFAULT : 0;
1333 	}
1334 	case AMDGPU_INFO_VIDEO_CAPS: {
1335 		const struct amdgpu_video_codecs *codecs;
1336 		struct drm_amdgpu_info_video_caps *caps;
1337 		int r;
1338 
1339 		if (!adev->asic_funcs->query_video_codecs)
1340 			return -EINVAL;
1341 
1342 		switch (info->video_cap.type) {
1343 		case AMDGPU_INFO_VIDEO_CAPS_DECODE:
1344 			r = amdgpu_asic_query_video_codecs(adev, false, &codecs);
1345 			if (r)
1346 				return -EINVAL;
1347 			break;
1348 		case AMDGPU_INFO_VIDEO_CAPS_ENCODE:
1349 			r = amdgpu_asic_query_video_codecs(adev, true, &codecs);
1350 			if (r)
1351 				return -EINVAL;
1352 			break;
1353 		default:
1354 			DRM_DEBUG_KMS("Invalid request %d\n",
1355 				      info->video_cap.type);
1356 			return -EINVAL;
1357 		}
1358 
1359 		caps = kzalloc_obj(*caps);
1360 		if (!caps)
1361 			return -ENOMEM;
1362 
1363 		for (i = 0; i < codecs->codec_count; i++) {
1364 			int idx = codecs->codec_array[i].codec_type;
1365 
1366 			switch (idx) {
1367 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG2:
1368 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4:
1369 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VC1:
1370 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4_AVC:
1371 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_HEVC:
1372 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_JPEG:
1373 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VP9:
1374 			case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_AV1:
1375 				caps->codec_info[idx].valid = 1;
1376 				caps->codec_info[idx].max_width =
1377 					codecs->codec_array[i].max_width;
1378 				caps->codec_info[idx].max_height =
1379 					codecs->codec_array[i].max_height;
1380 				caps->codec_info[idx].max_pixels_per_frame =
1381 					codecs->codec_array[i].max_pixels_per_frame;
1382 				caps->codec_info[idx].max_level =
1383 					codecs->codec_array[i].max_level;
1384 				break;
1385 			default:
1386 				break;
1387 			}
1388 		}
1389 		r = copy_to_user(out, caps,
1390 				 min((size_t)size, sizeof(*caps))) ? -EFAULT : 0;
1391 		kfree(caps);
1392 		return r;
1393 	}
1394 	case AMDGPU_INFO_MAX_IBS: {
1395 		uint32_t max_ibs[AMDGPU_HW_IP_NUM];
1396 
1397 		for (i = 0; i < AMDGPU_HW_IP_NUM; ++i)
1398 			max_ibs[i] = amdgpu_ring_max_ibs(i);
1399 
1400 		return copy_to_user(out, max_ibs,
1401 				    min((size_t)size, sizeof(max_ibs))) ? -EFAULT : 0;
1402 	}
1403 	case AMDGPU_INFO_GPUVM_FAULT: {
1404 		struct amdgpu_fpriv *fpriv = filp->driver_priv;
1405 		struct amdgpu_vm *vm = &fpriv->vm;
1406 		struct drm_amdgpu_info_gpuvm_fault gpuvm_fault;
1407 		unsigned long flags;
1408 
1409 		if (!vm)
1410 			return -EINVAL;
1411 
1412 		memset(&gpuvm_fault, 0, sizeof(gpuvm_fault));
1413 
1414 		amdgpu_pasid_lock(&flags);
1415 		gpuvm_fault.addr = vm->fault_info.addr;
1416 		gpuvm_fault.status = vm->fault_info.status;
1417 		gpuvm_fault.vmhub = vm->fault_info.vmhub;
1418 		amdgpu_pasid_unlock(flags);
1419 
1420 		return copy_to_user(out, &gpuvm_fault,
1421 				    min((size_t)size, sizeof(gpuvm_fault))) ? -EFAULT : 0;
1422 	}
1423 	case AMDGPU_INFO_UQ_FW_AREAS: {
1424 		struct drm_amdgpu_info_uq_metadata meta_info = {};
1425 
1426 		switch (info->query_hw_ip.type) {
1427 		case AMDGPU_HW_IP_GFX:
1428 			ret = amdgpu_userq_metadata_info_gfx(adev, info, &meta_info.gfx);
1429 			if (ret)
1430 				return ret;
1431 
1432 			ret = copy_to_user(out, &meta_info,
1433 						min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0;
1434 			return 0;
1435 		case AMDGPU_HW_IP_COMPUTE:
1436 			ret = amdgpu_userq_metadata_info_compute(adev, info, &meta_info.compute);
1437 			if (ret)
1438 				return ret;
1439 
1440 			ret = copy_to_user(out, &meta_info,
1441 						min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0;
1442 			return 0;
1443 		case AMDGPU_HW_IP_DMA:
1444 			ret = amdgpu_userq_metadata_info_sdma(adev, info, &meta_info.sdma);
1445 			if (ret)
1446 				return ret;
1447 
1448 			ret = copy_to_user(out, &meta_info,
1449 						min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0;
1450 			return 0;
1451 		default:
1452 			return -EINVAL;
1453 		}
1454 	}
1455 	default:
1456 		DRM_DEBUG_KMS("Invalid request %d\n", info->query);
1457 		return -EINVAL;
1458 	}
1459 	return 0;
1460 }
1461 
1462 /**
1463  * amdgpu_proc_options_ioctl - set per-fd user options
1464  *
1465  * @dev: drm dev pointer
1466  * @data: pointer to struct drm_amdgpu_proc_options
1467  * @filp: drm file
1468  *
1469  * Sets options stored on the per-file amdgpu_fpriv. Currently the only
1470  * supported option is %AMDGPU_PROC_OPTIONS_OP_KFD_SIGBUS_DELAY which
1471  * controls how KFD delivers SIGBUS for poison/RAS events to the calling
1472  * process (immediate, suppressed, or delayed by N milliseconds).
1473  */
1474 int amdgpu_proc_options_ioctl(struct drm_device *dev, void *data,
1475 			      struct drm_file *filp)
1476 {
1477 	struct drm_amdgpu_proc_options *args = data;
1478 
1479 	switch (args->op) {
1480 	case AMDGPU_PROC_OPTIONS_OP_KFD_SIGBUS_DELAY:
1481 		return amdgpu_amdkfd_set_sigbus_delay(current,
1482 						      args->kfd_sigbus_delay.value);
1483 	default:
1484 		DRM_DEBUG_KMS("Invalid user option op %u\n", args->op);
1485 		return -EINVAL;
1486 	}
1487 }
1488 
1489 /**
1490  * amdgpu_driver_open_kms - drm callback for open
1491  *
1492  * @dev: drm dev pointer
1493  * @file_priv: drm file
1494  *
1495  * On device open, init vm on cayman+ (all asics).
1496  * Returns 0 on success, error on failure.
1497  */
1498 int amdgpu_driver_open_kms(struct drm_device *dev, struct drm_file *file_priv)
1499 {
1500 	struct amdgpu_device *adev = drm_to_adev(dev);
1501 	struct amdgpu_fpriv *fpriv;
1502 	struct drm_exec exec;
1503 	int r, pasid = 0;
1504 
1505 	/* Ensure IB tests are run on ring */
1506 	flush_delayed_work(&adev->delayed_init_work);
1507 
1508 
1509 	if (amdgpu_ras_intr_triggered()) {
1510 		DRM_ERROR("RAS Intr triggered, device disabled!!");
1511 		return -EHWPOISON;
1512 	}
1513 
1514 	file_priv->driver_priv = NULL;
1515 
1516 	r = pm_runtime_get_sync(dev->dev);
1517 	if (r < 0)
1518 		goto pm_put;
1519 
1520 	fpriv = kzalloc_obj(*fpriv);
1521 	if (unlikely(!fpriv)) {
1522 		r = -ENOMEM;
1523 		goto out_suspend;
1524 	}
1525 
1526 	r = amdgpu_xcp_open_device(adev, fpriv, file_priv);
1527 	if (r)
1528 		goto error_pasid;
1529 
1530 	amdgpu_debugfs_vm_init(file_priv);
1531 
1532 	r = amdgpu_vm_init(adev, &fpriv->vm, fpriv->xcp_id);
1533 	if (r)
1534 		goto error_pasid;
1535 
1536 	pasid = amdgpu_pasid_alloc(16, fpriv);
1537 	if (pasid < 0) {
1538 		dev_warn(adev->dev, "No more PASIDs available!");
1539 		pasid = 0;
1540 	}
1541 	fpriv->vm.pasid = pasid;
1542 
1543 	drm_exec_init(&exec, DRM_EXEC_IGNORE_DUPLICATES, 0);
1544 	drm_exec_until_all_locked(&exec) {
1545 		r = amdgpu_vm_lock_pd(&fpriv->vm, &exec, 0);
1546 		drm_exec_retry_on_contention(&exec);
1547 		if (unlikely(r))
1548 			goto error_vm;
1549 	}
1550 
1551 	fpriv->prt_va = amdgpu_vm_bo_add(adev, &fpriv->vm, NULL);
1552 	drm_exec_fini(&exec);
1553 	if (!fpriv->prt_va) {
1554 		r = -ENOMEM;
1555 		goto error_vm;
1556 	}
1557 
1558 	if (adev->gfx.mcbp) {
1559 		uint64_t csa_addr = amdgpu_csa_vaddr(adev) & AMDGPU_GMC_HOLE_MASK;
1560 
1561 		r = amdgpu_map_static_csa(adev, &fpriv->vm, adev->virt.csa_obj,
1562 						&fpriv->csa_va, csa_addr, AMDGPU_CSA_SIZE);
1563 		if (r)
1564 			goto error_vm;
1565 	}
1566 
1567 	r = amdgpu_seq64_map(adev, &fpriv->vm, &fpriv->seq64_va);
1568 	if (r)
1569 		goto error_vm;
1570 
1571 	xa_init_flags(&fpriv->bo_list_handles, XA_FLAGS_ALLOC1);
1572 
1573 	r = amdgpu_userq_mgr_init(&fpriv->userq_mgr, file_priv, adev);
1574 	if (r)
1575 		drm_warn(adev_to_drm(adev),
1576 			 "Failed to init usermode queue manager (%d), use legacy workload submission only\n",
1577 			 r);
1578 
1579 	amdgpu_evf_mgr_init(&fpriv->evf_mgr);
1580 	amdgpu_ctx_mgr_init(&fpriv->ctx_mgr, adev);
1581 
1582 	file_priv->driver_priv = fpriv;
1583 	goto out_suspend;
1584 
1585 error_vm:
1586 	if (pasid) {
1587 		amdgpu_pasid_free(pasid);
1588 		pasid = 0;
1589 	}
1590 
1591 	amdgpu_vm_fini(adev, &fpriv->vm);
1592 
1593 error_pasid:
1594 	kfree(fpriv);
1595 
1596 out_suspend:
1597 pm_put:
1598 	pm_runtime_put_autosuspend(dev->dev);
1599 
1600 	return r;
1601 }
1602 
1603 /**
1604  * amdgpu_driver_postclose_kms - drm callback for post close
1605  *
1606  * @dev: drm dev pointer
1607  * @file_priv: drm file
1608  *
1609  * On device post close, tear down vm on cayman+ (all asics).
1610  */
1611 void amdgpu_driver_postclose_kms(struct drm_device *dev,
1612 				 struct drm_file *file_priv)
1613 {
1614 	struct amdgpu_device *adev = drm_to_adev(dev);
1615 	struct amdgpu_fpriv *fpriv = file_priv->driver_priv;
1616 	struct amdgpu_bo_list *list;
1617 	struct amdgpu_bo *pd;
1618 	unsigned long handle;
1619 	u32 pasid;
1620 
1621 	if (!fpriv)
1622 		return;
1623 
1624 	pm_runtime_get_sync(dev->dev);
1625 
1626 	if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_UVD) != NULL)
1627 		amdgpu_uvd_free_handles(adev, file_priv);
1628 	if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_VCE) != NULL)
1629 		amdgpu_vce_free_handles(adev, file_priv);
1630 
1631 	if (fpriv->csa_va) {
1632 		uint64_t csa_addr = amdgpu_csa_vaddr(adev) & AMDGPU_GMC_HOLE_MASK;
1633 
1634 		WARN_ON(amdgpu_unmap_static_csa(adev, &fpriv->vm, adev->virt.csa_obj,
1635 						fpriv->csa_va, csa_addr));
1636 		fpriv->csa_va = NULL;
1637 	}
1638 
1639 	amdgpu_seq64_unmap(adev, fpriv);
1640 
1641 	pasid = fpriv->vm.pasid;
1642 	pd = amdgpu_bo_ref(fpriv->vm.root.bo);
1643 	if (!WARN_ON(amdgpu_bo_reserve(pd, true))) {
1644 		amdgpu_vm_bo_del(adev, fpriv->prt_va);
1645 		amdgpu_bo_unreserve(pd);
1646 	}
1647 
1648 	amdgpu_ctx_mgr_fini(&fpriv->ctx_mgr);
1649 
1650 	if (pasid)
1651 		amdgpu_pasid_free_delayed(pd->tbo.base.resv, pasid);
1652 
1653 	amdgpu_vm_fini(adev, &fpriv->vm);
1654 	amdgpu_bo_unref(&pd);
1655 
1656 	xa_for_each(&fpriv->bo_list_handles, handle, list)
1657 		amdgpu_bo_list_put(list);
1658 	xa_destroy(&fpriv->bo_list_handles);
1659 
1660 	kfree(fpriv);
1661 	file_priv->driver_priv = NULL;
1662 
1663 	pm_runtime_put_autosuspend(dev->dev);
1664 }
1665 
1666 
1667 void amdgpu_driver_release_kms(struct drm_device *dev)
1668 {
1669 	struct amdgpu_device *adev = drm_to_adev(dev);
1670 
1671 	amdgpu_device_fini_sw(adev);
1672 	pci_set_drvdata(adev->pdev, NULL);
1673 }
1674 
1675 /*
1676  * VBlank related functions.
1677  */
1678 /**
1679  * amdgpu_get_vblank_counter_kms - get frame count
1680  *
1681  * @crtc: crtc to get the frame count from
1682  *
1683  * Gets the frame count on the requested crtc (all asics).
1684  * Returns frame count on success, -EINVAL on failure.
1685  */
1686 u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc)
1687 {
1688 	struct drm_device *dev = crtc->dev;
1689 	unsigned int pipe = crtc->index;
1690 	struct amdgpu_device *adev = drm_to_adev(dev);
1691 	int vpos, hpos, stat;
1692 	u32 count;
1693 
1694 	if (pipe >= adev->mode_info.num_crtc) {
1695 		DRM_ERROR("Invalid crtc %u\n", pipe);
1696 		return -EINVAL;
1697 	}
1698 	if (!down_read_trylock(&adev->reset_domain->sem))
1699 		return drm_crtc_vblank_count(crtc);
1700 
1701 
1702 	/* The hw increments its frame counter at start of vsync, not at start
1703 	 * of vblank, as is required by DRM core vblank counter handling.
1704 	 * Cook the hw count here to make it appear to the caller as if it
1705 	 * incremented at start of vblank. We measure distance to start of
1706 	 * vblank in vpos. vpos therefore will be >= 0 between start of vblank
1707 	 * and start of vsync, so vpos >= 0 means to bump the hw frame counter
1708 	 * result by 1 to give the proper appearance to caller.
1709 	 */
1710 	if (adev->mode_info.crtcs[pipe]) {
1711 		/* Repeat readout if needed to provide stable result if
1712 		 * we cross start of vsync during the queries.
1713 		 */
1714 		do {
1715 			count = amdgpu_display_vblank_get_counter(adev, pipe);
1716 			/* Ask amdgpu_display_get_crtc_scanoutpos to return
1717 			 * vpos as distance to start of vblank, instead of
1718 			 * regular vertical scanout pos.
1719 			 */
1720 			stat = amdgpu_display_get_crtc_scanoutpos(
1721 				dev, pipe, GET_DISTANCE_TO_VBLANKSTART,
1722 				&vpos, &hpos, NULL, NULL,
1723 				&adev->mode_info.crtcs[pipe]->base.hwmode);
1724 		} while (count != amdgpu_display_vblank_get_counter(adev, pipe));
1725 
1726 		if (((stat & (DRM_SCANOUTPOS_VALID | DRM_SCANOUTPOS_ACCURATE)) !=
1727 		    (DRM_SCANOUTPOS_VALID | DRM_SCANOUTPOS_ACCURATE))) {
1728 			DRM_DEBUG_VBL("Query failed! stat %d\n", stat);
1729 		} else {
1730 			DRM_DEBUG_VBL("crtc %d: dist from vblank start %d\n",
1731 				      pipe, vpos);
1732 
1733 			/* Bump counter if we are at >= leading edge of vblank,
1734 			 * but before vsync where vpos would turn negative and
1735 			 * the hw counter really increments.
1736 			 */
1737 			if (vpos >= 0)
1738 				count++;
1739 		}
1740 	} else {
1741 		/* Fallback to use value as is. */
1742 		count = amdgpu_display_vblank_get_counter(adev, pipe);
1743 		DRM_DEBUG_VBL("NULL mode info! Returned count may be wrong.\n");
1744 	}
1745 
1746 	up_read(&adev->reset_domain->sem);
1747 	return count;
1748 }
1749 
1750 /**
1751  * amdgpu_enable_vblank_kms - enable vblank interrupt
1752  *
1753  * @crtc: crtc to enable vblank interrupt for
1754  *
1755  * Enable the interrupt on the requested crtc (all asics).
1756  * Returns 0 on success, -EINVAL on failure.
1757  */
1758 int amdgpu_enable_vblank_kms(struct drm_crtc *crtc)
1759 {
1760 	struct drm_device *dev = crtc->dev;
1761 	unsigned int pipe = crtc->index;
1762 	struct amdgpu_device *adev = drm_to_adev(dev);
1763 	int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe);
1764 
1765 	return amdgpu_irq_get(adev, &adev->crtc_irq, idx);
1766 }
1767 
1768 /**
1769  * amdgpu_disable_vblank_kms - disable vblank interrupt
1770  *
1771  * @crtc: crtc to disable vblank interrupt for
1772  *
1773  * Disable the interrupt on the requested crtc (all asics).
1774  */
1775 void amdgpu_disable_vblank_kms(struct drm_crtc *crtc)
1776 {
1777 	struct drm_device *dev = crtc->dev;
1778 	unsigned int pipe = crtc->index;
1779 	struct amdgpu_device *adev = drm_to_adev(dev);
1780 	int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe);
1781 
1782 	amdgpu_irq_put(adev, &adev->crtc_irq, idx);
1783 }
1784 
1785 /*
1786  * Debugfs info
1787  */
1788 #if defined(CONFIG_DEBUG_FS)
1789 
1790 static int amdgpu_debugfs_firmware_info_show(struct seq_file *m, void *unused)
1791 {
1792 	struct amdgpu_device *adev = m->private;
1793 	struct drm_amdgpu_info_firmware fw_info;
1794 	struct drm_amdgpu_query_fw query_fw;
1795 	struct atom_context *ctx = adev->mode_info.atom_context;
1796 	uint8_t smu_program, smu_major, smu_minor, smu_debug;
1797 	int ret, i;
1798 
1799 	static const char *ta_fw_name[TA_FW_TYPE_MAX_INDEX] = {
1800 #define TA_FW_NAME(type)[TA_FW_TYPE_PSP_##type] = #type
1801 		TA_FW_NAME(XGMI),
1802 		TA_FW_NAME(RAS),
1803 		TA_FW_NAME(HDCP),
1804 		TA_FW_NAME(DTM),
1805 		TA_FW_NAME(RAP),
1806 		TA_FW_NAME(SECUREDISPLAY),
1807 #undef TA_FW_NAME
1808 	};
1809 
1810 	/* VCE */
1811 	query_fw.fw_type = AMDGPU_INFO_FW_VCE;
1812 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1813 	if (ret)
1814 		return ret;
1815 	seq_printf(m, "VCE feature version: %u, firmware version: 0x%08x\n",
1816 		   fw_info.feature, fw_info.ver);
1817 
1818 	/* UVD */
1819 	query_fw.fw_type = AMDGPU_INFO_FW_UVD;
1820 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1821 	if (ret)
1822 		return ret;
1823 	seq_printf(m, "UVD feature version: %u, firmware version: 0x%08x\n",
1824 		   fw_info.feature, fw_info.ver);
1825 
1826 	/* GMC */
1827 	query_fw.fw_type = AMDGPU_INFO_FW_GMC;
1828 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1829 	if (ret)
1830 		return ret;
1831 	seq_printf(m, "MC feature version: %u, firmware version: 0x%08x\n",
1832 		   fw_info.feature, fw_info.ver);
1833 
1834 	/* ME */
1835 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_ME;
1836 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1837 	if (ret)
1838 		return ret;
1839 	seq_printf(m, "ME feature version: %u, firmware version: 0x%08x\n",
1840 		   fw_info.feature, fw_info.ver);
1841 
1842 	/* PFP */
1843 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_PFP;
1844 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1845 	if (ret)
1846 		return ret;
1847 	seq_printf(m, "PFP feature version: %u, firmware version: 0x%08x\n",
1848 		   fw_info.feature, fw_info.ver);
1849 
1850 	/* CE */
1851 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_CE;
1852 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1853 	if (ret)
1854 		return ret;
1855 	seq_printf(m, "CE feature version: %u, firmware version: 0x%08x\n",
1856 		   fw_info.feature, fw_info.ver);
1857 
1858 	/* RLC */
1859 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC;
1860 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1861 	if (ret)
1862 		return ret;
1863 	seq_printf(m, "RLC feature version: %u, firmware version: 0x%08x\n",
1864 		   fw_info.feature, fw_info.ver);
1865 
1866 	/* RLC SAVE RESTORE LIST CNTL */
1867 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_CNTL;
1868 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1869 	if (ret)
1870 		return ret;
1871 	seq_printf(m, "RLC SRLC feature version: %u, firmware version: 0x%08x\n",
1872 		   fw_info.feature, fw_info.ver);
1873 
1874 	/* RLC SAVE RESTORE LIST GPM MEM */
1875 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_GPM_MEM;
1876 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1877 	if (ret)
1878 		return ret;
1879 	seq_printf(m, "RLC SRLG feature version: %u, firmware version: 0x%08x\n",
1880 		   fw_info.feature, fw_info.ver);
1881 
1882 	/* RLC SAVE RESTORE LIST SRM MEM */
1883 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_SRM_MEM;
1884 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1885 	if (ret)
1886 		return ret;
1887 	seq_printf(m, "RLC SRLS feature version: %u, firmware version: 0x%08x\n",
1888 		   fw_info.feature, fw_info.ver);
1889 
1890 	/* RLCP */
1891 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLCP;
1892 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1893 	if (ret)
1894 		return ret;
1895 	seq_printf(m, "RLCP feature version: %u, firmware version: 0x%08x\n",
1896 		   fw_info.feature, fw_info.ver);
1897 
1898 	/* RLCV */
1899 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLCV;
1900 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1901 	if (ret)
1902 		return ret;
1903 	seq_printf(m, "RLCV feature version: %u, firmware version: 0x%08x\n",
1904 		   fw_info.feature, fw_info.ver);
1905 
1906 	/* MEC */
1907 	query_fw.fw_type = AMDGPU_INFO_FW_GFX_MEC;
1908 	query_fw.index = 0;
1909 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1910 	if (ret)
1911 		return ret;
1912 	seq_printf(m, "MEC feature version: %u, firmware version: 0x%08x\n",
1913 		   fw_info.feature, fw_info.ver);
1914 
1915 	/* MEC2 */
1916 	if (adev->gfx.mec2_fw) {
1917 		query_fw.index = 1;
1918 		ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1919 		if (ret)
1920 			return ret;
1921 		seq_printf(m, "MEC2 feature version: %u, firmware version: 0x%08x\n",
1922 			   fw_info.feature, fw_info.ver);
1923 	}
1924 
1925 	/* IMU */
1926 	query_fw.fw_type = AMDGPU_INFO_FW_IMU;
1927 	query_fw.index = 0;
1928 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1929 	if (ret)
1930 		return ret;
1931 	seq_printf(m, "IMU feature version: %u, firmware version: 0x%08x\n",
1932 		   fw_info.feature, fw_info.ver);
1933 
1934 	/* PSP SOS */
1935 	query_fw.fw_type = AMDGPU_INFO_FW_SOS;
1936 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1937 	if (ret)
1938 		return ret;
1939 	seq_printf(m, "SOS feature version: %u, firmware version: 0x%08x\n",
1940 		   fw_info.feature, fw_info.ver);
1941 
1942 
1943 	/* PSP ASD */
1944 	query_fw.fw_type = AMDGPU_INFO_FW_ASD;
1945 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1946 	if (ret)
1947 		return ret;
1948 	seq_printf(m, "ASD feature version: %u, firmware version: 0x%08x\n",
1949 		   fw_info.feature, fw_info.ver);
1950 
1951 	query_fw.fw_type = AMDGPU_INFO_FW_TA;
1952 	for (i = TA_FW_TYPE_PSP_XGMI; i < TA_FW_TYPE_MAX_INDEX; i++) {
1953 		query_fw.index = i;
1954 		ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1955 		if (ret)
1956 			continue;
1957 
1958 		seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
1959 			   ta_fw_name[i], fw_info.feature, fw_info.ver);
1960 	}
1961 
1962 	/* SMC */
1963 	query_fw.fw_type = AMDGPU_INFO_FW_SMC;
1964 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1965 	if (ret)
1966 		return ret;
1967 	smu_program = (fw_info.ver >> 24) & 0xff;
1968 	smu_major = (fw_info.ver >> 16) & 0xff;
1969 	smu_minor = (fw_info.ver >> 8) & 0xff;
1970 	smu_debug = (fw_info.ver >> 0) & 0xff;
1971 	seq_printf(m, "SMC feature version: %u, program: %d, firmware version: 0x%08x (%d.%d.%d)\n",
1972 		   fw_info.feature, smu_program, fw_info.ver, smu_major, smu_minor, smu_debug);
1973 
1974 	/* MP5 */
1975 	query_fw.fw_type = AMDGPU_INFO_FW_MP5;
1976 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1977 	if (ret)
1978 		return ret;
1979 	seq_printf(m, "MP5 feature version: %u, firmware version: 0x%08x\n",
1980 		   fw_info.feature, fw_info.ver);
1981 
1982 	/* SDMA */
1983 	query_fw.fw_type = AMDGPU_INFO_FW_SDMA;
1984 	for (i = 0; i < adev->sdma.num_instances; i++) {
1985 		query_fw.index = i;
1986 		ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1987 		if (ret)
1988 			return ret;
1989 		seq_printf(m, "SDMA%d feature version: %u, firmware version: 0x%08x\n",
1990 			   i, fw_info.feature, fw_info.ver);
1991 	}
1992 
1993 	/* VCN */
1994 	query_fw.fw_type = AMDGPU_INFO_FW_VCN;
1995 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1996 	if (ret)
1997 		return ret;
1998 	seq_printf(m, "VCN feature version: %u, firmware version: 0x%08x\n",
1999 		   fw_info.feature, fw_info.ver);
2000 
2001 	/* DMCU */
2002 	query_fw.fw_type = AMDGPU_INFO_FW_DMCU;
2003 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2004 	if (ret)
2005 		return ret;
2006 	seq_printf(m, "DMCU feature version: %u, firmware version: 0x%08x\n",
2007 		   fw_info.feature, fw_info.ver);
2008 
2009 	/* DMCUB */
2010 	query_fw.fw_type = AMDGPU_INFO_FW_DMCUB;
2011 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2012 	if (ret)
2013 		return ret;
2014 	seq_printf(m, "DMCUB feature version: %u, firmware version: 0x%08x\n",
2015 		   fw_info.feature, fw_info.ver);
2016 
2017 	/* TOC */
2018 	query_fw.fw_type = AMDGPU_INFO_FW_TOC;
2019 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2020 	if (ret)
2021 		return ret;
2022 	seq_printf(m, "TOC feature version: %u, firmware version: 0x%08x\n",
2023 		   fw_info.feature, fw_info.ver);
2024 
2025 	/* CAP */
2026 	if (adev->psp.cap_fw) {
2027 		query_fw.fw_type = AMDGPU_INFO_FW_CAP;
2028 		ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2029 		if (ret)
2030 			return ret;
2031 		seq_printf(m, "CAP feature version: %u, firmware version: 0x%08x\n",
2032 				fw_info.feature, fw_info.ver);
2033 	}
2034 
2035 	/* MES_KIQ */
2036 	query_fw.fw_type = AMDGPU_INFO_FW_MES_KIQ;
2037 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2038 	if (ret)
2039 		return ret;
2040 	seq_printf(m, "MES_KIQ feature version: %u, firmware version: 0x%08x\n",
2041 		   fw_info.feature, fw_info.ver);
2042 
2043 	/* MES */
2044 	query_fw.fw_type = AMDGPU_INFO_FW_MES;
2045 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2046 	if (ret)
2047 		return ret;
2048 	seq_printf(m, "MES feature version: %u, firmware version: 0x%08x\n",
2049 		   fw_info.feature, fw_info.ver);
2050 
2051 	/* VPE */
2052 	query_fw.fw_type = AMDGPU_INFO_FW_VPE;
2053 	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
2054 	if (ret)
2055 		return ret;
2056 	seq_printf(m, "VPE feature version: %u, firmware version: 0x%08x\n",
2057 		   fw_info.feature, fw_info.ver);
2058 
2059 	seq_printf(m, "VBIOS version: %s\n", ctx->vbios_pn);
2060 
2061 	return 0;
2062 }
2063 
2064 DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_firmware_info);
2065 
2066 #endif
2067 
2068 void amdgpu_debugfs_firmware_init(struct amdgpu_device *adev)
2069 {
2070 #if defined(CONFIG_DEBUG_FS)
2071 	struct drm_minor *minor = adev_to_drm(adev)->primary;
2072 	struct dentry *root = minor->debugfs_root;
2073 
2074 	debugfs_create_file("amdgpu_firmware_info", 0444, root,
2075 			    adev, &amdgpu_debugfs_firmware_info_fops);
2076 
2077 #endif
2078 }
2079