Commit 98d28ac2 authored by Nirmoy Das's avatar Nirmoy Das Committed by Alex Deucher
Browse files

drm/amdgpu: do not use drm middle layer for debugfs 



Use debugfs API directly instead of drm middle layer.

This also includes following debugfs file output changes:
1 amdgpu_evict_vram/amdgpu_evict_gtt output will not contain any braces.
  e.g. (0) --> 0
2 amdgpu_gpu_recover output will print return value of
  amdgpu_device_gpu_recover() instead of not so important "gpu recover"
  message.

v2: * checkpatch.pl: use '0444' instead of S_IRUGO.
    * remove S_IFREG from mode.
    * remove mode variable.

Signed-off-by: default avatarNirmoy Das <nirmoy.das@amd.com>
Reviewed-by: default avatarChristian König <christian.koenig@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 373720f7

drivers/gpu/drm/amd/amdgpu/amdgpu.h

+1 −2
Original line number Diff line number Diff line
@@ -791,8 +791,7 @@ struct amdgpu_device { 
	bool				accel_working;

	struct notifier_block		acpi_nb;

	struct amdgpu_i2c_chan		*i2c_bus[AMDGPU_MAX_I2C_BUS];

	struct amdgpu_debugfs		debugfs[AMDGPU_DEBUGFS_MAX_COMPONENTS];

	unsigned			debugfs_count;

	struct debugfs_blob_wrapper     debugfs_vbios_blob;

	struct amdgpu_atif		*atif;

	struct amdgpu_atcs		atcs;

	struct mutex			srbm_mutex;

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

+49 −107
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#include <linux/uaccess.h>

#include <linux/pm_runtime.h>

#include <linux/poll.h>

#include <drm/drm_debugfs.h>



#include "amdgpu.h"

#include "amdgpu_pm.h"
@@ -38,45 +37,6 @@ 
#include "amdgpu_securedisplay.h"

#include "amdgpu_fw_attestation.h"



/**

 * amdgpu_debugfs_add_files - Add simple debugfs entries

 *

 * @adev:  Device to attach debugfs entries to

 * @files:  Array of function callbacks that respond to reads

 * @nfiles: Number of callbacks to register

 *

 */

int amdgpu_debugfs_add_files(struct amdgpu_device *adev,

			     const struct drm_info_list *files,

			     unsigned nfiles)

{

	unsigned i;



	for (i = 0; i < adev->debugfs_count; i++) {

		if (adev->debugfs[i].files == files) {

			/* Already registered */

			return 0;

		}

	}



	i = adev->debugfs_count + 1;

	if (i > AMDGPU_DEBUGFS_MAX_COMPONENTS) {

		DRM_ERROR("Reached maximum number of debugfs components.\n");

		DRM_ERROR("Report so we increase "

			  "AMDGPU_DEBUGFS_MAX_COMPONENTS.\n");

		return -EINVAL;

	}

	adev->debugfs[adev->debugfs_count].files = files;

	adev->debugfs[adev->debugfs_count].num_files = nfiles;

	adev->debugfs_count = i;

#if defined(CONFIG_DEBUG_FS)

	drm_debugfs_create_files(files, nfiles,

				 adev_to_drm(adev)->primary->debugfs_root,

				 adev_to_drm(adev)->primary);

#endif

	return 0;

}



int amdgpu_debugfs_wait_dump(struct amdgpu_device *adev)

{

#if defined(CONFIG_DEBUG_FS)
@@ -1233,16 +1193,15 @@ int amdgpu_debugfs_regs_init(struct amdgpu_device *adev) 
	return 0;

}



static int amdgpu_debugfs_test_ib(struct seq_file *m, void *data)

static int amdgpu_debugfs_test_ib_show(struct seq_file *m, void *unused)

{

	struct drm_info_node *node = (struct drm_info_node *) m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct amdgpu_device *adev = (struct amdgpu_device *)m->private;

	struct drm_device *dev = adev_to_drm(adev);

	int r = 0, i;



	r = pm_runtime_get_sync(dev->dev);

	if (r < 0) {

		pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);

		pm_runtime_put_autosuspend(dev->dev);

		return r;

	}
@@ -1284,30 +1243,19 @@ static int amdgpu_debugfs_test_ib(struct seq_file *m, void *data) 
	return 0;

}



static int amdgpu_debugfs_get_vbios_dump(struct seq_file *m, void *data)

static int amdgpu_debugfs_evict_vram(void *data, u64 *val)

{

	struct drm_info_node *node = (struct drm_info_node *) m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);



	seq_write(m, adev->bios, adev->bios_size);

	return 0;

}



static int amdgpu_debugfs_evict_vram(struct seq_file *m, void *data)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct amdgpu_device *adev = (struct amdgpu_device *)data;

	struct drm_device *dev = adev_to_drm(adev);

	int r;



	r = pm_runtime_get_sync(dev->dev);

	if (r < 0) {

		pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);

		pm_runtime_put_autosuspend(dev->dev);

		return r;

	}



	seq_printf(m, "(%d)\n", amdgpu_bo_evict_vram(adev));

	*val = amdgpu_bo_evict_vram(adev);



	pm_runtime_mark_last_busy(dev->dev);

	pm_runtime_put_autosuspend(dev->dev);
@@ -1315,11 +1263,11 @@ static int amdgpu_debugfs_evict_vram(struct seq_file *m, void *data) 
	return 0;

}



static int amdgpu_debugfs_evict_gtt(struct seq_file *m, void *data)



static int amdgpu_debugfs_evict_gtt(void *data, u64 *val)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct amdgpu_device *adev = (struct amdgpu_device *)data;

	struct drm_device *dev = adev_to_drm(adev);

	struct ttm_resource_manager *man;

	int r;
@@ -1330,8 +1278,7 @@ static int amdgpu_debugfs_evict_gtt(struct seq_file *m, void *data) 
	}



	man = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT);

	r = ttm_resource_manager_evict_all(&adev->mman.bdev, man);

	seq_printf(m, "(%d)\n", r);

	*val = ttm_resource_manager_evict_all(&adev->mman.bdev, man);



	pm_runtime_mark_last_busy(dev->dev);

	pm_runtime_put_autosuspend(dev->dev);
@@ -1339,10 +1286,11 @@ static int amdgpu_debugfs_evict_gtt(struct seq_file *m, void *data) 
	return 0;

}



static int amdgpu_debugfs_vm_info(struct seq_file *m, void *data)



static int amdgpu_debugfs_vm_info_show(struct seq_file *m, void *unused)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = (struct amdgpu_device *)m->private;

	struct drm_device *dev = adev_to_drm(adev);

	struct drm_file *file;

	int r;
@@ -1368,13 +1316,12 @@ static int amdgpu_debugfs_vm_info(struct seq_file *m, void *data) 
	return r;

}



static const struct drm_info_list amdgpu_debugfs_list[] = {

	{"amdgpu_vbios", amdgpu_debugfs_get_vbios_dump},

	{"amdgpu_test_ib", &amdgpu_debugfs_test_ib},

	{"amdgpu_evict_vram", &amdgpu_debugfs_evict_vram},

	{"amdgpu_evict_gtt", &amdgpu_debugfs_evict_gtt},

	{"amdgpu_vm_info", &amdgpu_debugfs_vm_info},

};

DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_test_ib);

DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_vm_info);

DEFINE_DEBUGFS_ATTRIBUTE(amdgpu_evict_vram_fops, amdgpu_debugfs_evict_vram,

			 NULL, "%lld\n");

DEFINE_DEBUGFS_ATTRIBUTE(amdgpu_evict_gtt_fops, amdgpu_debugfs_evict_gtt,

			 NULL, "%lld\n");



static void amdgpu_ib_preempt_fences_swap(struct amdgpu_ring *ring,

					  struct dma_fence **fences)
@@ -1593,19 +1540,20 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_sclk_set, NULL, 


int amdgpu_debugfs_init(struct amdgpu_device *adev)

{

	struct dentry *root = adev_to_drm(adev)->primary->debugfs_root;

	struct dentry *ent;

	int r, i;



	ent = debugfs_create_file("amdgpu_preempt_ib", 0600,

				  adev_to_drm(adev)->primary->debugfs_root, adev,





	ent = debugfs_create_file("amdgpu_preempt_ib", 0600, root, adev,

				  &fops_ib_preempt);

	if (!ent) {

		DRM_ERROR("unable to create amdgpu_preempt_ib debugsfs file\n");

		return -EIO;

	}



	ent = debugfs_create_file("amdgpu_force_sclk", 0200,

				  adev_to_drm(adev)->primary->debugfs_root, adev,

	ent = debugfs_create_file("amdgpu_force_sclk", 0200, root, adev,

				  &fops_sclk_set);

	if (!ent) {

		DRM_ERROR("unable to create amdgpu_set_sclk debugsfs file\n");
@@ -1613,32 +1561,17 @@ int amdgpu_debugfs_init(struct amdgpu_device *adev) 
	}



	/* Register debugfs entries for amdgpu_ttm */

	r = amdgpu_ttm_debugfs_init(adev);

	if (r) {

		DRM_ERROR("Failed to init debugfs\n");

		return r;

	}



	amdgpu_ttm_debugfs_init(adev);

	amdgpu_debugfs_pm_init(adev);



	if (amdgpu_debugfs_sa_init(adev)) {

		dev_err(adev->dev, "failed to register debugfs file for SA\n");

	}



	if (amdgpu_debugfs_fence_init(adev))

		dev_err(adev->dev, "fence debugfs file creation failed\n");



	r = amdgpu_debugfs_gem_init(adev);

	if (r)

		DRM_ERROR("registering gem debugfs failed (%d).\n", r);

	amdgpu_debugfs_sa_init(adev);

	amdgpu_debugfs_fence_init(adev);

	amdgpu_debugfs_gem_init(adev);



	r = amdgpu_debugfs_regs_init(adev);

	if (r)

		DRM_ERROR("registering register debugfs failed (%d).\n", r);



	r = amdgpu_debugfs_firmware_init(adev);

	if (r)

		DRM_ERROR("registering firmware debugfs failed (%d).\n", r);

	amdgpu_debugfs_firmware_init(adev);



#if defined(CONFIG_DRM_AMD_DC)

	if (amdgpu_device_has_dc_support(adev))
@@ -1657,17 +1590,26 @@ int amdgpu_debugfs_init(struct amdgpu_device *adev) 
	}



	amdgpu_ras_debugfs_create_all(adev);



	amdgpu_debugfs_autodump_init(adev);



	amdgpu_rap_debugfs_init(adev);



	amdgpu_securedisplay_debugfs_init(adev);



	amdgpu_fw_attestation_debugfs_init(adev);



	return amdgpu_debugfs_add_files(adev, amdgpu_debugfs_list,

					ARRAY_SIZE(amdgpu_debugfs_list));

	debugfs_create_file("amdgpu_evict_vram", 0444, root, adev,

			    &amdgpu_evict_vram_fops);

	debugfs_create_file("amdgpu_evict_gtt", 0444, root, adev,

			    &amdgpu_evict_gtt_fops);

	debugfs_create_file("amdgpu_test_ib", 0444, root, adev,

			    &amdgpu_debugfs_test_ib_fops);

	debugfs_create_file("amdgpu_vm_info", 0444, root, adev,

			    &amdgpu_debugfs_vm_info_fops);



	adev->debugfs_vbios_blob.data = adev->bios;

	adev->debugfs_vbios_blob.size = adev->bios_size;

	debugfs_create_blob("amdgpu_vbios", 0444, root,

			    &adev->debugfs_vbios_blob);



	return 0;

}



#else

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.h

+3 −11
Original line number Diff line number Diff line
@@ -26,11 +26,6 @@ 
/*

 * Debugfs

 */

struct amdgpu_debugfs {

	const struct drm_info_list	*files;

	unsigned		num_files;

};



struct amdgpu_autodump {

	struct completion		dumping;

	struct wait_queue_head		gpu_hang;
@@ -39,10 +34,7 @@ struct amdgpu_autodump { 
int amdgpu_debugfs_regs_init(struct amdgpu_device *adev);

int amdgpu_debugfs_init(struct amdgpu_device *adev);

void amdgpu_debugfs_fini(struct amdgpu_device *adev);

int amdgpu_debugfs_add_files(struct amdgpu_device *adev,

			     const struct drm_info_list *files,

			     unsigned nfiles);

int amdgpu_debugfs_fence_init(struct amdgpu_device *adev);

int amdgpu_debugfs_firmware_init(struct amdgpu_device *adev);

int amdgpu_debugfs_gem_init(struct amdgpu_device *adev);

void amdgpu_debugfs_fence_init(struct amdgpu_device *adev);

void amdgpu_debugfs_firmware_init(struct amdgpu_device *adev);

void amdgpu_debugfs_gem_init(struct amdgpu_device *adev);

int amdgpu_debugfs_wait_dump(struct amdgpu_device *adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c

+19 −27
Original line number Diff line number Diff line
@@ -36,8 +36,6 @@ 
#include <linux/firmware.h>

#include <linux/pm_runtime.h>



#include <drm/drm_debugfs.h>



#include "amdgpu.h"

#include "amdgpu_trace.h"
@@ -697,11 +695,9 @@ static const struct dma_fence_ops amdgpu_fence_ops = { 
 * Fence debugfs

 */

#if defined(CONFIG_DEBUG_FS)

static int amdgpu_debugfs_fence_info(struct seq_file *m, void *data)

static int amdgpu_debugfs_fence_info_show(struct seq_file *m, void *unused)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct amdgpu_device *adev = (struct amdgpu_device *)m->private;

	int i;



	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
@@ -746,11 +742,10 @@ static int amdgpu_debugfs_fence_info(struct seq_file *m, void *data) 
 *

 * Manually trigger a gpu reset at the next fence wait.

 */

static int amdgpu_debugfs_gpu_recover(struct seq_file *m, void *data)

static int gpu_recover_get(void *data, u64 *val)

{

	struct drm_info_node *node = (struct drm_info_node *) m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct amdgpu_device *adev = (struct amdgpu_device *)data;

	struct drm_device *dev = adev_to_drm(adev);

	int r;



	r = pm_runtime_get_sync(dev->dev);
@@ -759,8 +754,7 @@ static int amdgpu_debugfs_gpu_recover(struct seq_file *m, void *data) 
		return 0;

	}



	seq_printf(m, "gpu recover\n");

	amdgpu_device_gpu_recover(adev, NULL);

	*val = amdgpu_device_gpu_recover(adev, NULL);



	pm_runtime_mark_last_busy(dev->dev);

	pm_runtime_put_autosuspend(dev->dev);
@@ -768,26 +762,24 @@ static int amdgpu_debugfs_gpu_recover(struct seq_file *m, void *data) 
	return 0;

}



static const struct drm_info_list amdgpu_debugfs_fence_list[] = {

	{"amdgpu_fence_info", &amdgpu_debugfs_fence_info, 0, NULL},

	{"amdgpu_gpu_recover", &amdgpu_debugfs_gpu_recover, 0, NULL}

};

DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_fence_info);

DEFINE_DEBUGFS_ATTRIBUTE(amdgpu_debugfs_gpu_recover_fops, gpu_recover_get, NULL,

			 "%lld\n");



static const struct drm_info_list amdgpu_debugfs_fence_list_sriov[] = {

	{"amdgpu_fence_info", &amdgpu_debugfs_fence_info, 0, NULL},

};

#endif



int amdgpu_debugfs_fence_init(struct amdgpu_device *adev)

void amdgpu_debugfs_fence_init(struct amdgpu_device *adev)

{

#if defined(CONFIG_DEBUG_FS)

	if (amdgpu_sriov_vf(adev))

		return amdgpu_debugfs_add_files(adev, amdgpu_debugfs_fence_list_sriov,

						ARRAY_SIZE(amdgpu_debugfs_fence_list_sriov));

	return amdgpu_debugfs_add_files(adev, amdgpu_debugfs_fence_list,

					ARRAY_SIZE(amdgpu_debugfs_fence_list));

#else

	return 0;

	struct drm_minor *minor = adev_to_drm(adev)->primary;

	struct dentry *root = minor->debugfs_root;



	debugfs_create_file("amdgpu_fence_info", 0444, root, adev,

			    &amdgpu_debugfs_fence_info_fops);



	if (!amdgpu_sriov_vf(adev))

		debugfs_create_file("amdgpu_gpu_recover", 0444, root, adev,

				    &amdgpu_debugfs_gpu_recover_fops);

#endif

}

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c

+11 −11
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ 
#include <linux/dma-buf.h>



#include <drm/amdgpu_drm.h>

#include <drm/drm_debugfs.h>

#include <drm/drm_gem_ttm_helper.h>



#include "amdgpu.h"
@@ -855,10 +854,10 @@ int amdgpu_mode_dumb_create(struct drm_file *file_priv, 
}



#if defined(CONFIG_DEBUG_FS)

static int amdgpu_debugfs_gem_info(struct seq_file *m, void *data)

static int amdgpu_debugfs_gem_info_show(struct seq_file *m, void *unused)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct amdgpu_device *adev = (struct amdgpu_device *)m->private;

	struct drm_device *dev = adev_to_drm(adev);

	struct drm_file *file;

	int r;
@@ -896,16 +895,17 @@ static int amdgpu_debugfs_gem_info(struct seq_file *m, void *data) 
	return 0;

}



static const struct drm_info_list amdgpu_debugfs_gem_list[] = {

	{"amdgpu_gem_info", &amdgpu_debugfs_gem_info, 0, NULL},

};

DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_gem_info);



#endif



int amdgpu_debugfs_gem_init(struct amdgpu_device *adev)

void amdgpu_debugfs_gem_init(struct amdgpu_device *adev)

{

#if defined(CONFIG_DEBUG_FS)

	return amdgpu_debugfs_add_files(adev, amdgpu_debugfs_gem_list,

					ARRAY_SIZE(amdgpu_debugfs_gem_list));

	struct drm_minor *minor = adev_to_drm(adev)->primary;

	struct dentry *root = minor->debugfs_root;



	debugfs_create_file("amdgpu_gem_info", 0444, root, adev,

			    &amdgpu_debugfs_gem_info_fops);

#endif

	return 0;

}