~hc/RK356X_SDK_RELEASE.git

..	..	@@ -25,8 +25,9 @@
25	25	* Alex Deucher
26	26	* Jerome Glisse
27	27	*/
28		-#include <drm/drmP.h>
	28	+
29	29	#include "amdgpu.h"
	30	+#include <drm/drm_debugfs.h>
30	31	#include <drm/amdgpu_drm.h>
31	32	#include "amdgpu_sched.h"
32	33	#include "amdgpu_uvd.h"
..	..	@@ -35,8 +36,37 @@
35	36
36	37	#include <linux/vga_switcheroo.h>
37	38	#include <linux/slab.h>
	39	+#include <linux/uaccess.h>
	40	+#include <linux/pci.h>
38	41	#include <linux/pm_runtime.h>
39	42	#include "amdgpu_amdkfd.h"
	43	+#include "amdgpu_gem.h"
	44	+#include "amdgpu_display.h"
	45	+#include "amdgpu_ras.h"
	46	+
	47	+void amdgpu_unregister_gpu_instance(struct amdgpu_device *adev)
	48	+{
	49	+ struct amdgpu_gpu_instance *gpu_instance;
	50	+ int i;
	51	+
	52	+ mutex_lock(&mgpu_info.mutex);
	53	+
	54	+ for (i = 0; i < mgpu_info.num_gpu; i++) {
	55	+ gpu_instance = &(mgpu_info.gpu_ins[i]);
	56	+ if (gpu_instance->adev == adev) {
	57	+ mgpu_info.gpu_ins[i] =
	58	+ mgpu_info.gpu_ins[mgpu_info.num_gpu - 1];
	59	+ mgpu_info.num_gpu--;
	60	+ if (adev->flags & AMD_IS_APU)
	61	+ mgpu_info.num_apu--;
	62	+ else
	63	+ mgpu_info.num_dgpu--;
	64	+ break;
	65	+ }
	66	+ }
	67	+
	68	+ mutex_unlock(&mgpu_info.mutex);
	69	+}
40	70
41	71	/**
42	72	* amdgpu_driver_unload_kms - Main unload function for KMS.
..	..	@@ -48,53 +78,67 @@
48	78	*/
49	79	void amdgpu_driver_unload_kms(struct drm_device *dev)
50	80	{
51		- struct amdgpu_device *adev = dev->dev_private;
	81	+ struct amdgpu_device *adev = drm_to_adev(dev);
52	82
53	83	if (adev == NULL)
54	84	return;
55	85
	86	+ amdgpu_unregister_gpu_instance(adev);
	87	+
56	88	if (adev->rmmio == NULL)
57		- goto done_free;
	89	+ return;
58	90
59		- if (amdgpu_sriov_vf(adev))
60		- amdgpu_virt_request_full_gpu(adev, false);
61		-
62		- if (amdgpu_device_is_px(dev)) {
	91	+ if (adev->runpm) {
63	92	pm_runtime_get_sync(dev->dev);
64	93	pm_runtime_forbid(dev->dev);
65	94	}
66	95
67	96	amdgpu_acpi_fini(adev);
68		-
69	97	amdgpu_device_fini(adev);
	98	+}
70	99
71		-done_free:
72		- kfree(adev);
73		- dev->dev_private = NULL;
	100	+void amdgpu_register_gpu_instance(struct amdgpu_device *adev)
	101	+{
	102	+ struct amdgpu_gpu_instance *gpu_instance;
	103	+
	104	+ mutex_lock(&mgpu_info.mutex);
	105	+
	106	+ if (mgpu_info.num_gpu >= MAX_GPU_INSTANCE) {
	107	+ DRM_ERROR("Cannot register more gpu instance\n");
	108	+ mutex_unlock(&mgpu_info.mutex);
	109	+ return;
	110	+ }
	111	+
	112	+ gpu_instance = &(mgpu_info.gpu_ins[mgpu_info.num_gpu]);
	113	+ gpu_instance->adev = adev;
	114	+ gpu_instance->mgpu_fan_enabled = 0;
	115	+
	116	+ mgpu_info.num_gpu++;
	117	+ if (adev->flags & AMD_IS_APU)
	118	+ mgpu_info.num_apu++;
	119	+ else
	120	+ mgpu_info.num_dgpu++;
	121	+
	122	+ mutex_unlock(&mgpu_info.mutex);
74	123	}
75	124
76	125	/**
77	126	* amdgpu_driver_load_kms - Main load function for KMS.
78	127	*
79		- * @dev: drm dev pointer
	128	+ * @adev: pointer to struct amdgpu_device
80	129	* @flags: device flags
81	130	*
82	131	* This is the main load function for KMS (all asics).
83	132	* Returns 0 on success, error on failure.
84	133	*/
85		-int amdgpu_driver_load_kms(struct drm_device *dev, unsigned long flags)
	134	+int amdgpu_driver_load_kms(struct amdgpu_device *adev, unsigned long flags)
86	135	{
87		- struct amdgpu_device *adev;
	136	+ struct drm_device *dev;
88	137	int r, acpi_status;
89	138
90		- adev = kzalloc(sizeof(struct amdgpu_device), GFP_KERNEL);
91		- if (adev == NULL) {
92		- return -ENOMEM;
93		- }
94		- dev->dev_private = (void *)adev;
	139	+ dev = adev_to_drm(adev);
95	140
96		- if ((amdgpu_runtime_pm != 0) &&
97		- amdgpu_has_atpx() &&
	141	+ if (amdgpu_has_atpx() &&
98	142	(amdgpu_is_atpx_hybrid() \|\|
99	143	amdgpu_has_atpx_dgpu_power_cntl()) &&
100	144	((flags & AMD_IS_APU) == 0) &&
..	..	@@ -107,27 +151,57 @@
107	151	* properly initialize the GPU MC controller and permit
108	152	* VRAM allocation
109	153	*/
110		- r = amdgpu_device_init(adev, dev, dev->pdev, flags);
	154	+ r = amdgpu_device_init(adev, flags);
111	155	if (r) {
112	156	dev_err(&dev->pdev->dev, "Fatal error during GPU init\n");
113	157	goto out;
114	158	}
115	159
	160	+ if (amdgpu_device_supports_boco(dev) &&
	161	+ (amdgpu_runtime_pm != 0)) { /* enable runpm by default for boco */
	162	+ adev->runpm = true;
	163	+ } else if (amdgpu_device_supports_baco(dev) &&
	164	+ (amdgpu_runtime_pm != 0)) {
	165	+ switch (adev->asic_type) {
	166	+#ifdef CONFIG_DRM_AMDGPU_CIK
	167	+ case CHIP_BONAIRE:
	168	+ case CHIP_HAWAII:
	169	+#endif
	170	+ case CHIP_VEGA20:
	171	+ case CHIP_ARCTURUS:
	172	+ case CHIP_SIENNA_CICHLID:
	173	+ case CHIP_NAVY_FLOUNDER:
	174	+ /* enable runpm if runpm=1 */
	175	+ if (amdgpu_runtime_pm > 0)
	176	+ adev->runpm = true;
	177	+ break;
	178	+ case CHIP_VEGA10:
	179	+ /* turn runpm on if noretry=0 */
	180	+ if (!adev->gmc.noretry)
	181	+ adev->runpm = true;
	182	+ break;
	183	+ default:
	184	+ /* enable runpm on VI+ */
	185	+ adev->runpm = true;
	186	+ break;
	187	+ }
	188	+ }
	189	+
116	190	/* Call ACPI methods: require modeset init
117	191	* but failure is not fatal
118	192	*/
119		- if (!r) {
120		- acpi_status = amdgpu_acpi_init(adev);
121		- if (acpi_status)
122		- dev_dbg(&dev->pdev->dev,
123		- "Error during ACPI methods call\n");
124		- }
125	193
126		- if (amdgpu_device_is_px(dev)) {
127		- dev_pm_set_driver_flags(dev->dev, DPM_FLAG_NEVER_SKIP);
	194	+ acpi_status = amdgpu_acpi_init(adev);
	195	+ if (acpi_status)
	196	+ dev_dbg(&dev->pdev->dev, "Error during ACPI methods call\n");
	197	+
	198	+ if (adev->runpm) {
	199	+ /* only need to skip on ATPX */
	200	+ if (amdgpu_device_supports_boco(dev) &&
	201	+ !amdgpu_is_atpx_hybrid())
	202	+ dev_pm_set_driver_flags(dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE);
128	203	pm_runtime_use_autosuspend(dev->dev);
129	204	pm_runtime_set_autosuspend_delay(dev->dev, 5000);
130		- pm_runtime_set_active(dev->dev);
131	205	pm_runtime_allow(dev->dev);
132	206	pm_runtime_mark_last_busy(dev->dev);
133	207	pm_runtime_put_autosuspend(dev->dev);
..	..	@@ -136,7 +210,7 @@
136	210	out:
137	211	if (r) {
138	212	/* balance pm_runtime_get_sync in amdgpu_driver_unload_kms */
139		- if (adev->rmmio && amdgpu_device_is_px(dev))
	213	+ if (adev->rmmio && adev->runpm)
140	214	pm_runtime_put_noidle(dev->dev);
141	215	amdgpu_driver_unload_kms(dev);
142	216	}
..	..	@@ -207,6 +281,28 @@
207	281	fw_info->ver = adev->pm.fw_version;
208	282	fw_info->feature = 0;
209	283	break;
	284	+ case AMDGPU_INFO_FW_TA:
	285	+ switch (query_fw->index) {
	286	+ case 0:
	287	+ fw_info->ver = adev->psp.ta_fw_version;
	288	+ fw_info->feature = adev->psp.ta_xgmi_ucode_version;
	289	+ break;
	290	+ case 1:
	291	+ fw_info->ver = adev->psp.ta_fw_version;
	292	+ fw_info->feature = adev->psp.ta_ras_ucode_version;
	293	+ break;
	294	+ case 2:
	295	+ fw_info->ver = adev->psp.ta_fw_version;
	296	+ fw_info->feature = adev->psp.ta_hdcp_ucode_version;
	297	+ break;
	298	+ case 3:
	299	+ fw_info->ver = adev->psp.ta_fw_version;
	300	+ fw_info->feature = adev->psp.ta_dtm_ucode_version;
	301	+ break;
	302	+ default:
	303	+ return -EINVAL;
	304	+ }
	305	+ break;
210	306	case AMDGPU_INFO_FW_SDMA:
211	307	if (query_fw->index >= adev->sdma.num_instances)
212	308	return -EINVAL;
..	..	@@ -221,9 +317,151 @@
221	317	fw_info->ver = adev->psp.asd_fw_version;
222	318	fw_info->feature = adev->psp.asd_feature_version;
223	319	break;
	320	+ case AMDGPU_INFO_FW_DMCU:
	321	+ fw_info->ver = adev->dm.dmcu_fw_version;
	322	+ fw_info->feature = 0;
	323	+ break;
	324	+ case AMDGPU_INFO_FW_DMCUB:
	325	+ fw_info->ver = adev->dm.dmcub_fw_version;
	326	+ fw_info->feature = 0;
	327	+ break;
224	328	default:
225	329	return -EINVAL;
226	330	}
	331	+ return 0;
	332	+}
	333	+
	334	+static int amdgpu_hw_ip_info(struct amdgpu_device *adev,
	335	+ struct drm_amdgpu_info *info,
	336	+ struct drm_amdgpu_info_hw_ip *result)
	337	+{
	338	+ uint32_t ib_start_alignment = 0;
	339	+ uint32_t ib_size_alignment = 0;
	340	+ enum amd_ip_block_type type;
	341	+ unsigned int num_rings = 0;
	342	+ unsigned int i, j;
	343	+
	344	+ if (info->query_hw_ip.ip_instance >= AMDGPU_HW_IP_INSTANCE_MAX_COUNT)
	345	+ return -EINVAL;
	346	+
	347	+ switch (info->query_hw_ip.type) {
	348	+ case AMDGPU_HW_IP_GFX:
	349	+ type = AMD_IP_BLOCK_TYPE_GFX;
	350	+ for (i = 0; i < adev->gfx.num_gfx_rings; i++)
	351	+ if (adev->gfx.gfx_ring[i].sched.ready)
	352	+ ++num_rings;
	353	+ ib_start_alignment = 32;
	354	+ ib_size_alignment = 32;
	355	+ break;
	356	+ case AMDGPU_HW_IP_COMPUTE:
	357	+ type = AMD_IP_BLOCK_TYPE_GFX;
	358	+ for (i = 0; i < adev->gfx.num_compute_rings; i++)
	359	+ if (adev->gfx.compute_ring[i].sched.ready)
	360	+ ++num_rings;
	361	+ ib_start_alignment = 32;
	362	+ ib_size_alignment = 32;
	363	+ break;
	364	+ case AMDGPU_HW_IP_DMA:
	365	+ type = AMD_IP_BLOCK_TYPE_SDMA;
	366	+ for (i = 0; i < adev->sdma.num_instances; i++)
	367	+ if (adev->sdma.instance[i].ring.sched.ready)
	368	+ ++num_rings;
	369	+ ib_start_alignment = 256;
	370	+ ib_size_alignment = 4;
	371	+ break;
	372	+ case AMDGPU_HW_IP_UVD:
	373	+ type = AMD_IP_BLOCK_TYPE_UVD;
	374	+ for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
	375	+ if (adev->uvd.harvest_config & (1 << i))
	376	+ continue;
	377	+
	378	+ if (adev->uvd.inst[i].ring.sched.ready)
	379	+ ++num_rings;
	380	+ }
	381	+ ib_start_alignment = 64;
	382	+ ib_size_alignment = 64;
	383	+ break;
	384	+ case AMDGPU_HW_IP_VCE:
	385	+ type = AMD_IP_BLOCK_TYPE_VCE;
	386	+ for (i = 0; i < adev->vce.num_rings; i++)
	387	+ if (adev->vce.ring[i].sched.ready)
	388	+ ++num_rings;
	389	+ ib_start_alignment = 4;
	390	+ ib_size_alignment = 1;
	391	+ break;
	392	+ case AMDGPU_HW_IP_UVD_ENC:
	393	+ type = AMD_IP_BLOCK_TYPE_UVD;
	394	+ for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
	395	+ if (adev->uvd.harvest_config & (1 << i))
	396	+ continue;
	397	+
	398	+ for (j = 0; j < adev->uvd.num_enc_rings; j++)
	399	+ if (adev->uvd.inst[i].ring_enc[j].sched.ready)
	400	+ ++num_rings;
	401	+ }
	402	+ ib_start_alignment = 64;
	403	+ ib_size_alignment = 64;
	404	+ break;
	405	+ case AMDGPU_HW_IP_VCN_DEC:
	406	+ type = AMD_IP_BLOCK_TYPE_VCN;
	407	+ for (i = 0; i < adev->vcn.num_vcn_inst; i++) {
	408	+ if (adev->uvd.harvest_config & (1 << i))
	409	+ continue;
	410	+
	411	+ if (adev->vcn.inst[i].ring_dec.sched.ready)
	412	+ ++num_rings;
	413	+ }
	414	+ ib_start_alignment = 16;
	415	+ ib_size_alignment = 16;
	416	+ break;
	417	+ case AMDGPU_HW_IP_VCN_ENC:
	418	+ type = AMD_IP_BLOCK_TYPE_VCN;
	419	+ for (i = 0; i < adev->vcn.num_vcn_inst; i++) {
	420	+ if (adev->uvd.harvest_config & (1 << i))
	421	+ continue;
	422	+
	423	+ for (j = 0; j < adev->vcn.num_enc_rings; j++)
	424	+ if (adev->vcn.inst[i].ring_enc[j].sched.ready)
	425	+ ++num_rings;
	426	+ }
	427	+ ib_start_alignment = 64;
	428	+ ib_size_alignment = 1;
	429	+ break;
	430	+ case AMDGPU_HW_IP_VCN_JPEG:
	431	+ type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ?
	432	+ AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN;
	433	+
	434	+ for (i = 0; i < adev->jpeg.num_jpeg_inst; i++) {
	435	+ if (adev->jpeg.harvest_config & (1 << i))
	436	+ continue;
	437	+
	438	+ if (adev->jpeg.inst[i].ring_dec.sched.ready)
	439	+ ++num_rings;
	440	+ }
	441	+ ib_start_alignment = 16;
	442	+ ib_size_alignment = 16;
	443	+ break;
	444	+ default:
	445	+ return -EINVAL;
	446	+ }
	447	+
	448	+ for (i = 0; i < adev->num_ip_blocks; i++)
	449	+ if (adev->ip_blocks[i].version->type == type &&
	450	+ adev->ip_blocks[i].status.valid)
	451	+ break;
	452	+
	453	+ if (i == adev->num_ip_blocks)
	454	+ return 0;
	455	+
	456	+ num_rings = min(amdgpu_ctx_num_entities[info->query_hw_ip.type],
	457	+ num_rings);
	458	+
	459	+ result->hw_ip_version_major = adev->ip_blocks[i].version->major;
	460	+ result->hw_ip_version_minor = adev->ip_blocks[i].version->minor;
	461	+ result->capabilities_flags = 0;
	462	+ result->available_rings = (1 << num_rings) - 1;
	463	+ result->ib_start_alignment = ib_start_alignment;
	464	+ result->ib_size_alignment = ib_size_alignment;
227	465	return 0;
228	466	}
229	467
..	..	@@ -244,7 +482,7 @@
244	482	*/
245	483	static int amdgpu_info_ioctl(struct drm_device dev, void data, struct drm_file *filp)
246	484	{
247		- struct amdgpu_device *adev = dev->dev_private;
	485	+ struct amdgpu_device *adev = drm_to_adev(dev);
248	486	struct drm_amdgpu_info *info = data;
249	487	struct amdgpu_mode_info *minfo = &adev->mode_info;
250	488	void __user out = (void __user )(uintptr_t)info->return_pointer;
..	..	@@ -252,7 +490,7 @@
252	490	struct drm_crtc *crtc;
253	491	uint32_t ui32 = 0;
254	492	uint64_t ui64 = 0;
255		- int i, j, found;
	493	+ int i, found;
256	494	int ui32_size = sizeof(ui32);
257	495
258	496	if (!info->return_size \|\| !info->return_pointer)
..	..	@@ -279,101 +517,14 @@
279	517	return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
280	518	case AMDGPU_INFO_HW_IP_INFO: {
281	519	struct drm_amdgpu_info_hw_ip ip = {};
282		- enum amd_ip_block_type type;
283		- uint32_t ring_mask = 0;
284		- uint32_t ib_start_alignment = 0;
285		- uint32_t ib_size_alignment = 0;
	520	+ int ret;
286	521
287		- if (info->query_hw_ip.ip_instance >= AMDGPU_HW_IP_INSTANCE_MAX_COUNT)
288		- return -EINVAL;
	522	+ ret = amdgpu_hw_ip_info(adev, info, &ip);
	523	+ if (ret)
	524	+ return ret;
289	525
290		- switch (info->query_hw_ip.type) {
291		- case AMDGPU_HW_IP_GFX:
292		- type = AMD_IP_BLOCK_TYPE_GFX;
293		- for (i = 0; i < adev->gfx.num_gfx_rings; i++)
294		- ring_mask \|= adev->gfx.gfx_ring[i].ready << i;
295		- ib_start_alignment = 32;
296		- ib_size_alignment = 32;
297		- break;
298		- case AMDGPU_HW_IP_COMPUTE:
299		- type = AMD_IP_BLOCK_TYPE_GFX;
300		- for (i = 0; i < adev->gfx.num_compute_rings; i++)
301		- ring_mask \|= adev->gfx.compute_ring[i].ready << i;
302		- ib_start_alignment = 32;
303		- ib_size_alignment = 32;
304		- break;
305		- case AMDGPU_HW_IP_DMA:
306		- type = AMD_IP_BLOCK_TYPE_SDMA;
307		- for (i = 0; i < adev->sdma.num_instances; i++)
308		- ring_mask \|= adev->sdma.instance[i].ring.ready << i;
309		- ib_start_alignment = 256;
310		- ib_size_alignment = 4;
311		- break;
312		- case AMDGPU_HW_IP_UVD:
313		- type = AMD_IP_BLOCK_TYPE_UVD;
314		- for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
315		- if (adev->uvd.harvest_config & (1 << i))
316		- continue;
317		- ring_mask \|= adev->uvd.inst[i].ring.ready;
318		- }
319		- ib_start_alignment = 64;
320		- ib_size_alignment = 64;
321		- break;
322		- case AMDGPU_HW_IP_VCE:
323		- type = AMD_IP_BLOCK_TYPE_VCE;
324		- for (i = 0; i < adev->vce.num_rings; i++)
325		- ring_mask \|= adev->vce.ring[i].ready << i;
326		- ib_start_alignment = 4;
327		- ib_size_alignment = 1;
328		- break;
329		- case AMDGPU_HW_IP_UVD_ENC:
330		- type = AMD_IP_BLOCK_TYPE_UVD;
331		- for (i = 0; i < adev->uvd.num_uvd_inst; i++) {
332		- if (adev->uvd.harvest_config & (1 << i))
333		- continue;
334		- for (j = 0; j < adev->uvd.num_enc_rings; j++)
335		- ring_mask \|= adev->uvd.inst[i].ring_enc[j].ready << j;
336		- }
337		- ib_start_alignment = 64;
338		- ib_size_alignment = 64;
339		- break;
340		- case AMDGPU_HW_IP_VCN_DEC:
341		- type = AMD_IP_BLOCK_TYPE_VCN;
342		- ring_mask = adev->vcn.ring_dec.ready;
343		- ib_start_alignment = 16;
344		- ib_size_alignment = 16;
345		- break;
346		- case AMDGPU_HW_IP_VCN_ENC:
347		- type = AMD_IP_BLOCK_TYPE_VCN;
348		- for (i = 0; i < adev->vcn.num_enc_rings; i++)
349		- ring_mask \|= adev->vcn.ring_enc[i].ready << i;
350		- ib_start_alignment = 64;
351		- ib_size_alignment = 1;
352		- break;
353		- case AMDGPU_HW_IP_VCN_JPEG:
354		- type = AMD_IP_BLOCK_TYPE_VCN;
355		- ring_mask = adev->vcn.ring_jpeg.ready;
356		- ib_start_alignment = 16;
357		- ib_size_alignment = 16;
358		- break;
359		- default:
360		- return -EINVAL;
361		- }
362		-
363		- for (i = 0; i < adev->num_ip_blocks; i++) {
364		- if (adev->ip_blocks[i].version->type == type &&
365		- adev->ip_blocks[i].status.valid) {
366		- ip.hw_ip_version_major = adev->ip_blocks[i].version->major;
367		- ip.hw_ip_version_minor = adev->ip_blocks[i].version->minor;
368		- ip.capabilities_flags = 0;
369		- ip.available_rings = ring_mask;
370		- ip.ib_start_alignment = ib_start_alignment;
371		- ip.ib_size_alignment = ib_size_alignment;
372		- break;
373		- }
374		- }
375		- return copy_to_user(out, &ip,
376		- min((size_t)size, sizeof(ip))) ? -EFAULT : 0;
	526	+ ret = copy_to_user(out, &ip, min((size_t)size, sizeof(ip)));
	527	+ return ret ? -EFAULT : 0;
377	528	}
378	529	case AMDGPU_INFO_HW_IP_COUNT: {
379	530	enum amd_ip_block_type type;
..	..	@@ -400,8 +551,11 @@
400	551	break;
401	552	case AMDGPU_HW_IP_VCN_DEC:
402	553	case AMDGPU_HW_IP_VCN_ENC:
403		- case AMDGPU_HW_IP_VCN_JPEG:
404	554	type = AMD_IP_BLOCK_TYPE_VCN;
	555	+ break;
	556	+ case AMDGPU_HW_IP_VCN_JPEG:
	557	+ type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ?
	558	+ AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN;
405	559	break;
406	560	default:
407	561	return -EINVAL;
..	..	@@ -443,25 +597,22 @@
443	597	ui64 = atomic64_read(&adev->num_vram_cpu_page_faults);
444	598	return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
445	599	case AMDGPU_INFO_VRAM_USAGE:
446		- ui64 = amdgpu_vram_mgr_usage(&adev->mman.bdev.man[TTM_PL_VRAM]);
	600	+ ui64 = amdgpu_vram_mgr_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM));
447	601	return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
448	602	case AMDGPU_INFO_VIS_VRAM_USAGE:
449		- ui64 = amdgpu_vram_mgr_vis_usage(&adev->mman.bdev.man[TTM_PL_VRAM]);
	603	+ ui64 = amdgpu_vram_mgr_vis_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM));
450	604	return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
451	605	case AMDGPU_INFO_GTT_USAGE:
452		- ui64 = amdgpu_gtt_mgr_usage(&adev->mman.bdev.man[TTM_PL_TT]);
	606	+ ui64 = amdgpu_gtt_mgr_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_TT));
453	607	return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0;
454	608	case AMDGPU_INFO_GDS_CONFIG: {
455	609	struct drm_amdgpu_info_gds gds_info;
456	610
457	611	memset(&gds_info, 0, sizeof(gds_info));
458		- gds_info.gds_gfx_partition_size = adev->gds.mem.gfx_partition_size >> AMDGPU_GDS_SHIFT;
459		- gds_info.compute_partition_size = adev->gds.mem.cs_partition_size >> AMDGPU_GDS_SHIFT;
460		- gds_info.gds_total_size = adev->gds.mem.total_size >> AMDGPU_GDS_SHIFT;
461		- gds_info.gws_per_gfx_partition = adev->gds.gws.gfx_partition_size >> AMDGPU_GWS_SHIFT;
462		- gds_info.gws_per_compute_partition = adev->gds.gws.cs_partition_size >> AMDGPU_GWS_SHIFT;
463		- gds_info.oa_per_gfx_partition = adev->gds.oa.gfx_partition_size >> AMDGPU_OA_SHIFT;
464		- gds_info.oa_per_compute_partition = adev->gds.oa.cs_partition_size >> AMDGPU_OA_SHIFT;
	612	+ gds_info.compute_partition_size = adev->gds.gds_size;
	613	+ gds_info.gds_total_size = adev->gds.gds_size;
	614	+ gds_info.gws_per_compute_partition = adev->gds.gws_size;
	615	+ gds_info.oa_per_compute_partition = adev->gds.oa_size;
465	616	return copy_to_user(out, &gds_info,
466	617	min((size_t)size, sizeof(gds_info))) ? -EFAULT : 0;
467	618	}
..	..	@@ -469,10 +620,13 @@
469	620	struct drm_amdgpu_info_vram_gtt vram_gtt;
470	621
471	622	vram_gtt.vram_size = adev->gmc.real_vram_size -
472		- atomic64_read(&adev->vram_pin_size);
473		- vram_gtt.vram_cpu_accessible_size = adev->gmc.visible_vram_size -
474		- atomic64_read(&adev->visible_pin_size);
475		- vram_gtt.gtt_size = adev->mman.bdev.man[TTM_PL_TT].size;
	623	+ atomic64_read(&adev->vram_pin_size) -
	624	+ AMDGPU_VM_RESERVED_VRAM;
	625	+ vram_gtt.vram_cpu_accessible_size =
	626	+ min(adev->gmc.visible_vram_size -
	627	+ atomic64_read(&adev->visible_pin_size),
	628	+ vram_gtt.vram_size);
	629	+ vram_gtt.gtt_size = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT)->size;
476	630	vram_gtt.gtt_size *= PAGE_SIZE;
477	631	vram_gtt.gtt_size -= atomic64_read(&adev->gart_pin_size);
478	632	return copy_to_user(out, &vram_gtt,
..	..	@@ -480,30 +634,36 @@
480	634	}
481	635	case AMDGPU_INFO_MEMORY: {
482	636	struct drm_amdgpu_memory_info mem;
483		-
	637	+ struct ttm_resource_manager *vram_man =
	638	+ ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM);
	639	+ struct ttm_resource_manager *gtt_man =
	640	+ ttm_manager_type(&adev->mman.bdev, TTM_PL_TT);
484	641	memset(&mem, 0, sizeof(mem));
485	642	mem.vram.total_heap_size = adev->gmc.real_vram_size;
486	643	mem.vram.usable_heap_size = adev->gmc.real_vram_size -
487		- atomic64_read(&adev->vram_pin_size);
	644	+ atomic64_read(&adev->vram_pin_size) -
	645	+ AMDGPU_VM_RESERVED_VRAM;
488	646	mem.vram.heap_usage =
489		- amdgpu_vram_mgr_usage(&adev->mman.bdev.man[TTM_PL_VRAM]);
	647	+ amdgpu_vram_mgr_usage(vram_man);
490	648	mem.vram.max_allocation = mem.vram.usable_heap_size * 3 / 4;
491	649
492	650	mem.cpu_accessible_vram.total_heap_size =
493	651	adev->gmc.visible_vram_size;
494		- mem.cpu_accessible_vram.usable_heap_size = adev->gmc.visible_vram_size -
495		- atomic64_read(&adev->visible_pin_size);
	652	+ mem.cpu_accessible_vram.usable_heap_size =
	653	+ min(adev->gmc.visible_vram_size -
	654	+ atomic64_read(&adev->visible_pin_size),
	655	+ mem.vram.usable_heap_size);
496	656	mem.cpu_accessible_vram.heap_usage =
497		- amdgpu_vram_mgr_vis_usage(&adev->mman.bdev.man[TTM_PL_VRAM]);
	657	+ amdgpu_vram_mgr_vis_usage(vram_man);
498	658	mem.cpu_accessible_vram.max_allocation =
499	659	mem.cpu_accessible_vram.usable_heap_size * 3 / 4;
500	660
501		- mem.gtt.total_heap_size = adev->mman.bdev.man[TTM_PL_TT].size;
	661	+ mem.gtt.total_heap_size = gtt_man->size;
502	662	mem.gtt.total_heap_size *= PAGE_SIZE;
503	663	mem.gtt.usable_heap_size = mem.gtt.total_heap_size -
504	664	atomic64_read(&adev->gart_pin_size);
505	665	mem.gtt.heap_usage =
506		- amdgpu_gtt_mgr_usage(&adev->mman.bdev.man[TTM_PL_TT]);
	666	+ amdgpu_gtt_mgr_usage(gtt_man);
507	667	mem.gtt.max_allocation = mem.gtt.usable_heap_size * 3 / 4;
508	668
509	669	return copy_to_user(out, &mem,
..	..	@@ -539,15 +699,19 @@
539	699	return -ENOMEM;
540	700	alloc_size = info->read_mmr_reg.count * sizeof(*regs);
541	701
542		- for (i = 0; i < info->read_mmr_reg.count; i++)
	702	+ amdgpu_gfx_off_ctrl(adev, false);
	703	+ for (i = 0; i < info->read_mmr_reg.count; i++) {
543	704	if (amdgpu_asic_read_register(adev, se_num, sh_num,
544	705	info->read_mmr_reg.dword_offset + i,
545	706	&regs[i])) {
546	707	DRM_DEBUG_KMS("unallowed offset %#x\n",
547	708	info->read_mmr_reg.dword_offset + i);
548	709	kfree(regs);
	710	+ amdgpu_gfx_off_ctrl(adev, true);
549	711	return -EFAULT;
550	712	}
	713	+ }
	714	+ amdgpu_gfx_off_ctrl(adev, true);
551	715	n = copy_to_user(out, regs, min(size, alloc_size));
552	716	kfree(regs);
553	717	return n ? -EFAULT : 0;
..	..	@@ -581,27 +745,30 @@
581	745	dev_info.ids_flags = 0;
582	746	if (adev->flags & AMD_IS_APU)
583	747	dev_info.ids_flags \|= AMDGPU_IDS_FLAGS_FUSION;
584		- if (amdgpu_sriov_vf(adev))
	748	+ if (amdgpu_mcbp \|\| amdgpu_sriov_vf(adev))
585	749	dev_info.ids_flags \|= AMDGPU_IDS_FLAGS_PREEMPTION;
	750	+ if (amdgpu_is_tmz(adev))
	751	+ dev_info.ids_flags \|= AMDGPU_IDS_FLAGS_TMZ;
586	752
587	753	vm_size = adev->vm_manager.max_pfn * AMDGPU_GPU_PAGE_SIZE;
588	754	vm_size -= AMDGPU_VA_RESERVED_SIZE;
589	755
590	756	/* Older VCE FW versions are buggy and can handle only 40bits */
591		- if (adev->vce.fw_version < AMDGPU_VCE_FW_53_45)
	757	+ if (adev->vce.fw_version &&
	758	+ adev->vce.fw_version < AMDGPU_VCE_FW_53_45)
592	759	vm_size = min(vm_size, 1ULL << 40);
593	760
594	761	dev_info.virtual_address_offset = AMDGPU_VA_RESERVED_SIZE;
595	762	dev_info.virtual_address_max =
596		- min(vm_size, AMDGPU_VA_HOLE_START);
	763	+ min(vm_size, AMDGPU_GMC_HOLE_START);
597	764
598		- if (vm_size > AMDGPU_VA_HOLE_START) {
599		- dev_info.high_va_offset = AMDGPU_VA_HOLE_END;
600		- dev_info.high_va_max = AMDGPU_VA_HOLE_END \| vm_size;
	765	+ if (vm_size > AMDGPU_GMC_HOLE_START) {
	766	+ dev_info.high_va_offset = AMDGPU_GMC_HOLE_END;
	767	+ dev_info.high_va_max = AMDGPU_GMC_HOLE_END \| vm_size;
601	768	}
602		- dev_info.virtual_address_alignment = max((int)PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
	769	+ dev_info.virtual_address_alignment = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
603	770	dev_info.pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;
604		- dev_info.gart_page_size = AMDGPU_GPU_PAGE_SIZE;
	771	+ dev_info.gart_page_size = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
605	772	dev_info.cu_active_number = adev->gfx.cu_info.number;
606	773	dev_info.cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;
607	774	dev_info.ce_ram_size = adev->gfx.ce_ram_size;
..	..	@@ -614,17 +781,6 @@
614	781	dev_info.vce_harvest_config = adev->vce.harvest_config;
615	782	dev_info.gc_double_offchip_lds_buf =
616	783	adev->gfx.config.double_offchip_lds_buf;
617		-
618		- if (amdgpu_ngg) {
619		- dev_info.prim_buf_gpu_addr = adev->gfx.ngg.buf[NGG_PRIM].gpu_addr;
620		- dev_info.prim_buf_size = adev->gfx.ngg.buf[NGG_PRIM].size;
621		- dev_info.pos_buf_gpu_addr = adev->gfx.ngg.buf[NGG_POS].gpu_addr;
622		- dev_info.pos_buf_size = adev->gfx.ngg.buf[NGG_POS].size;
623		- dev_info.cntl_sb_buf_gpu_addr = adev->gfx.ngg.buf[NGG_CNTL].gpu_addr;
624		- dev_info.cntl_sb_buf_size = adev->gfx.ngg.buf[NGG_CNTL].size;
625		- dev_info.param_buf_gpu_addr = adev->gfx.ngg.buf[NGG_PARAM].gpu_addr;
626		- dev_info.param_buf_size = adev->gfx.ngg.buf[NGG_PARAM].size;
627		- }
628	784	dev_info.wave_front_size = adev->gfx.cu_info.wave_front_size;
629	785	dev_info.num_shader_visible_vgprs = adev->gfx.config.max_gprs;
630	786	dev_info.num_cu_per_sh = adev->gfx.config.max_cu_per_sh;
..	..	@@ -632,6 +788,12 @@
632	788	dev_info.gs_vgt_table_depth = adev->gfx.config.gs_vgt_table_depth;
633	789	dev_info.gs_prim_buffer_depth = adev->gfx.config.gs_prim_buffer_depth;
634	790	dev_info.max_gs_waves_per_vgt = adev->gfx.config.max_gs_threads;
	791	+
	792	+ if (adev->family >= AMDGPU_FAMILY_NV)
	793	+ dev_info.pa_sc_tile_steering_override =
	794	+ adev->gfx.config.pa_sc_tile_steering_override;
	795	+
	796	+ dev_info.tcc_disabled_mask = adev->gfx.config.tcc_disabled_mask;
635	797
636	798	return copy_to_user(out, &dev_info,
637	799	min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0;
..	..	@@ -793,6 +955,18 @@
793	955	case AMDGPU_INFO_VRAM_LOST_COUNTER:
794	956	ui32 = atomic_read(&adev->vram_lost_counter);
795	957	return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0;
	958	+ case AMDGPU_INFO_RAS_ENABLED_FEATURES: {
	959	+ struct amdgpu_ras *ras = amdgpu_ras_get_context(adev);
	960	+ uint64_t ras_mask;
	961	+
	962	+ if (!ras)
	963	+ return -EINVAL;
	964	+ ras_mask = (uint64_t)ras->supported << 32 \| ras->features;
	965	+
	966	+ return copy_to_user(out, &ras_mask,
	967	+ min_t(u64, size, sizeof(ras_mask))) ?
	968	+ -EFAULT : 0;
	969	+ }
796	970	default:
797	971	DRM_DEBUG_KMS("Invalid request %d\n", info->query);
798	972	return -EINVAL;
..	..	@@ -828,12 +1002,18 @@
828	1002	*/
829	1003	int amdgpu_driver_open_kms(struct drm_device dev, struct drm_file file_priv)
830	1004	{
831		- struct amdgpu_device *adev = dev->dev_private;
	1005	+ struct amdgpu_device *adev = drm_to_adev(dev);
832	1006	struct amdgpu_fpriv *fpriv;
833	1007	int r, pasid;
834	1008
835	1009	/* Ensure IB tests are run on ring */
836		- flush_delayed_work(&adev->late_init_work);
	1010	+ flush_delayed_work(&adev->delayed_init_work);
	1011	+
	1012	+
	1013	+ if (amdgpu_ras_intr_triggered()) {
	1014	+ DRM_ERROR("RAS Intr triggered, device disabled!!");
	1015	+ return -EHWPOISON;
	1016	+ }
837	1017
838	1018	file_priv->driver_priv = NULL;
839	1019
..	..	@@ -862,8 +1042,11 @@
862	1042	goto error_vm;
863	1043	}
864	1044
865		- if (amdgpu_sriov_vf(adev)) {
866		- r = amdgpu_map_static_csa(adev, &fpriv->vm, &fpriv->csa_va);
	1045	+ if (amdgpu_mcbp \|\| amdgpu_sriov_vf(adev)) {
	1046	+ uint64_t csa_addr = amdgpu_csa_vaddr(adev) & AMDGPU_GMC_HOLE_MASK;
	1047	+
	1048	+ r = amdgpu_map_static_csa(adev, &fpriv->vm, adev->virt.csa_obj,
	1049	+ &fpriv->csa_va, csa_addr, AMDGPU_CSA_SIZE);
867	1050	if (r)
868	1051	goto error_vm;
869	1052	}
..	..	@@ -904,11 +1087,11 @@
904	1087	void amdgpu_driver_postclose_kms(struct drm_device *dev,
905	1088	struct drm_file *file_priv)
906	1089	{
907		- struct amdgpu_device *adev = dev->dev_private;
	1090	+ struct amdgpu_device *adev = drm_to_adev(dev);
908	1091	struct amdgpu_fpriv *fpriv = file_priv->driver_priv;
909	1092	struct amdgpu_bo_list *list;
910	1093	struct amdgpu_bo *pd;
911		- unsigned int pasid;
	1094	+ u32 pasid;
912	1095	int handle;
913	1096
914	1097	if (!fpriv)
..	..	@@ -916,14 +1099,14 @@
916	1099
917	1100	pm_runtime_get_sync(dev->dev);
918	1101
919		- if (adev->asic_type != CHIP_RAVEN) {
	1102	+ if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_UVD) != NULL)
920	1103	amdgpu_uvd_free_handles(adev, file_priv);
	1104	+ if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_VCE) != NULL)
921	1105	amdgpu_vce_free_handles(adev, file_priv);
922		- }
923	1106
924	1107	amdgpu_vm_bo_rmv(adev, fpriv->prt_va);
925	1108
926		- if (amdgpu_sriov_vf(adev)) {
	1109	+ if (amdgpu_mcbp \|\| amdgpu_sriov_vf(adev)) {
927	1110	/* TODO: how to handle reserve failure */
928	1111	BUG_ON(amdgpu_bo_reserve(adev->virt.csa_obj, true));
929	1112	amdgpu_vm_bo_rmv(adev, fpriv->csa_va);
..	..	@@ -934,11 +1117,11 @@
934	1117	pasid = fpriv->vm.pasid;
935	1118	pd = amdgpu_bo_ref(fpriv->vm.root.base.bo);
936	1119
937		- amdgpu_vm_fini(adev, &fpriv->vm);
938	1120	amdgpu_ctx_mgr_fini(&fpriv->ctx_mgr);
	1121	+ amdgpu_vm_fini(adev, &fpriv->vm);
939	1122
940	1123	if (pasid)
941		- amdgpu_pasid_free_delayed(pd->tbo.resv, pasid);
	1124	+ amdgpu_pasid_free_delayed(pd->tbo.base.resv, pasid);
942	1125	amdgpu_bo_unref(&pd);
943	1126
944	1127	idr_for_each_entry(&fpriv->bo_list_handles, list, handle)
..	..	@@ -960,15 +1143,16 @@
960	1143	/**
961	1144	* amdgpu_get_vblank_counter_kms - get frame count
962	1145	*
963		- * @dev: drm dev pointer
964		- * @pipe: crtc to get the frame count from
	1146	+ * @crtc: crtc to get the frame count from
965	1147	*
966	1148	* Gets the frame count on the requested crtc (all asics).
967	1149	* Returns frame count on success, -EINVAL on failure.
968	1150	*/
969		-u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, unsigned int pipe)
	1151	+u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc)
970	1152	{
971		- struct amdgpu_device *adev = dev->dev_private;
	1153	+ struct drm_device *dev = crtc->dev;
	1154	+ unsigned int pipe = crtc->index;
	1155	+ struct amdgpu_device *adev = drm_to_adev(dev);
972	1156	int vpos, hpos, stat;
973	1157	u32 count;
974	1158
..	..	@@ -1027,15 +1211,16 @@
1027	1211	/**
1028	1212	* amdgpu_enable_vblank_kms - enable vblank interrupt
1029	1213	*
1030		- * @dev: drm dev pointer
1031		- * @pipe: crtc to enable vblank interrupt for
	1214	+ * @crtc: crtc to enable vblank interrupt for
1032	1215	*
1033	1216	* Enable the interrupt on the requested crtc (all asics).
1034	1217	* Returns 0 on success, -EINVAL on failure.
1035	1218	*/
1036		-int amdgpu_enable_vblank_kms(struct drm_device *dev, unsigned int pipe)
	1219	+int amdgpu_enable_vblank_kms(struct drm_crtc *crtc)
1037	1220	{
1038		- struct amdgpu_device *adev = dev->dev_private;
	1221	+ struct drm_device *dev = crtc->dev;
	1222	+ unsigned int pipe = crtc->index;
	1223	+ struct amdgpu_device *adev = drm_to_adev(dev);
1039	1224	int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe);
1040	1225
1041	1226	return amdgpu_irq_get(adev, &adev->crtc_irq, idx);
..	..	@@ -1044,14 +1229,15 @@
1044	1229	/**
1045	1230	* amdgpu_disable_vblank_kms - disable vblank interrupt
1046	1231	*
1047		- * @dev: drm dev pointer
1048		- * @pipe: crtc to disable vblank interrupt for
	1232	+ * @crtc: crtc to disable vblank interrupt for
1049	1233	*
1050	1234	* Disable the interrupt on the requested crtc (all asics).
1051	1235	*/
1052		-void amdgpu_disable_vblank_kms(struct drm_device *dev, unsigned int pipe)
	1236	+void amdgpu_disable_vblank_kms(struct drm_crtc *crtc)
1053	1237	{
1054		- struct amdgpu_device *adev = dev->dev_private;
	1238	+ struct drm_device *dev = crtc->dev;
	1239	+ unsigned int pipe = crtc->index;
	1240	+ struct amdgpu_device *adev = drm_to_adev(dev);
1055	1241	int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe);
1056	1242
1057	1243	amdgpu_irq_put(adev, &adev->crtc_irq, idx);
..	..	@@ -1087,7 +1273,7 @@
1087	1273	{
1088	1274	struct drm_info_node node = (struct drm_info_node ) m->private;
1089	1275	struct drm_device *dev = node->minor->dev;
1090		- struct amdgpu_device *adev = dev->dev_private;
	1276	+ struct amdgpu_device *adev = drm_to_adev(dev);
1091	1277	struct drm_amdgpu_info_firmware fw_info;
1092	1278	struct drm_amdgpu_query_fw query_fw;
1093	1279	struct atom_context *ctx = adev->mode_info.atom_context;
..	..	@@ -1183,8 +1369,7 @@
1183	1369	fw_info.feature, fw_info.ver);
1184	1370
1185	1371	/* MEC2 */
1186		- if (adev->asic_type == CHIP_KAVERI \|\|
1187		- (adev->asic_type > CHIP_TOPAZ && adev->asic_type != CHIP_STONEY)) {
	1372	+ if (adev->gfx.mec2_fw) {
1188	1373	query_fw.index = 1;
1189	1374	ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
1190	1375	if (ret)
..	..	@@ -1209,6 +1394,34 @@
1209	1394	return ret;
1210	1395	seq_printf(m, "ASD feature version: %u, firmware version: 0x%08x\n",
1211	1396	fw_info.feature, fw_info.ver);
	1397	+
	1398	+ query_fw.fw_type = AMDGPU_INFO_FW_TA;
	1399	+ for (i = 0; i < 4; i++) {
	1400	+ query_fw.index = i;
	1401	+ ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
	1402	+ if (ret)
	1403	+ continue;
	1404	+ switch (query_fw.index) {
	1405	+ case 0:
	1406	+ seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
	1407	+ "RAS", fw_info.feature, fw_info.ver);
	1408	+ break;
	1409	+ case 1:
	1410	+ seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
	1411	+ "XGMI", fw_info.feature, fw_info.ver);
	1412	+ break;
	1413	+ case 2:
	1414	+ seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
	1415	+ "HDCP", fw_info.feature, fw_info.ver);
	1416	+ break;
	1417	+ case 3:
	1418	+ seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
	1419	+ "DTM", fw_info.feature, fw_info.ver);
	1420	+ break;
	1421	+ default:
	1422	+ return -EINVAL;
	1423	+ }
	1424	+ }
1212	1425
1213	1426	/* SMC */
1214	1427	query_fw.fw_type = AMDGPU_INFO_FW_SMC;
..	..	@@ -1237,6 +1450,22 @@
1237	1450	seq_printf(m, "VCN feature version: %u, firmware version: 0x%08x\n",
1238	1451	fw_info.feature, fw_info.ver);
1239	1452
	1453	+ /* DMCU */
	1454	+ query_fw.fw_type = AMDGPU_INFO_FW_DMCU;
	1455	+ ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
	1456	+ if (ret)
	1457	+ return ret;
	1458	+ seq_printf(m, "DMCU feature version: %u, firmware version: 0x%08x\n",
	1459	+ fw_info.feature, fw_info.ver);
	1460	+
	1461	+ /* DMCUB */
	1462	+ query_fw.fw_type = AMDGPU_INFO_FW_DMCUB;
	1463	+ ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
	1464	+ if (ret)
	1465	+ return ret;
	1466	+ seq_printf(m, "DMCUB feature version: %u, firmware version: 0x%08x\n",
	1467	+ fw_info.feature, fw_info.ver);
	1468	+
1240	1469
1241	1470	seq_printf(m, "VBIOS version: %s\n", ctx->vbios_version);
1242	1471