Merge tag 'backlight-next-5.13' of git://git.kernel.org/pub/scm/linux/kernel/git...

[linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_debugfs.c

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
index 43059ead733bdc60a86557e5d1b838971794da54..bcaf271b39bf52e3792decd63fe0bdc745f1b562 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
@@ -28,7 +28,6 @@
 #include <linux/uaccess.h>
 #include <linux/pm_runtime.h>
 #include <linux/poll.h>
 #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"
 
 #include "amdgpu.h"
 #include "amdgpu_pm.h"


@@ -38,45 +37,6 @@
 #include "amdgpu_securedisplay.h"
 #include "amdgpu_fw_attestation.h"
 
 #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)
 int amdgpu_debugfs_wait_dump(struct amdgpu_device *adev)
 {
 #if defined(CONFIG_DEBUG_FS)


@@ -1228,22 +1188,20 @@ int amdgpu_debugfs_regs_init(struct amdgpu_device *adev)
                                          adev, debugfs_regs[i]);
                if (!i && !IS_ERR_OR_NULL(ent))
                        i_size_write(ent->d_inode, adev->rmmio_size);
                                          adev, debugfs_regs[i]);
                if (!i && !IS_ERR_OR_NULL(ent))
                        i_size_write(ent->d_inode, adev->rmmio_size);

-               adev->debugfs_regs[i] = ent;

        }
 
        return 0;
 }
 
        }
 
        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) {
        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;
        }
 
                return r;
        }
 


@@ -1285,30 +1243,19 @@ static int amdgpu_debugfs_test_ib(struct seq_file *m, void *data)
        return 0;
 }
 
        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) {
        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;
        }
 
                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);
 
        pm_runtime_mark_last_busy(dev->dev);
        pm_runtime_put_autosuspend(dev->dev);


@@ -1316,11 +1263,11 @@ static int amdgpu_debugfs_evict_vram(struct seq_file *m, void *data)
        return 0;
 }
 
        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;
 
        struct ttm_resource_manager *man;
        int r;
 


@@ -1331,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);
        }
 
        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);
 
        pm_runtime_mark_last_busy(dev->dev);
        pm_runtime_put_autosuspend(dev->dev);


@@ -1340,10 +1286,11 @@ static int amdgpu_debugfs_evict_gtt(struct seq_file *m, void *data)
        return 0;
 }
 
        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;
 
        struct drm_file *file;
        int r;
 


@@ -1369,13 +1316,12 @@ static int amdgpu_debugfs_vm_info(struct seq_file *m, void *data)
        return r;
 }
 
        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)
 
 static void amdgpu_ib_preempt_fences_swap(struct amdgpu_ring *ring,
                                          struct dma_fence **fences)


@@ -1586,71 +1532,50 @@ static int amdgpu_debugfs_sclk_set(void *data, u64 val)
        return 0;
 }
 
        return 0;
 }
 

-DEFINE_SIMPLE_ATTRIBUTE(fops_ib_preempt, NULL,
+DEFINE_DEBUGFS_ATTRIBUTE(fops_ib_preempt, NULL,

                        amdgpu_debugfs_ib_preempt, "%llu\n");
 
                        amdgpu_debugfs_ib_preempt, "%llu\n");
 

-DEFINE_SIMPLE_ATTRIBUTE(fops_sclk_set, NULL,
+DEFINE_DEBUGFS_ATTRIBUTE(fops_sclk_set, NULL,

                        amdgpu_debugfs_sclk_set, "%llu\n");
 
 int amdgpu_debugfs_init(struct amdgpu_device *adev)
 {
                        amdgpu_debugfs_sclk_set, "%llu\n");
 
 int amdgpu_debugfs_init(struct amdgpu_device *adev)
 {

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

        int r, i;
 
        int r, i;
 

-       adev->debugfs_preempt =
-               debugfs_create_file("amdgpu_preempt_ib", 0600,
-                                   adev_to_drm(adev)->primary->debugfs_root, adev,
-                                   &fops_ib_preempt);
-       if (!(adev->debugfs_preempt)) {
+
+
+       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;
        }
 
                DRM_ERROR("unable to create amdgpu_preempt_ib debugsfs file\n");
                return -EIO;
        }
 

-       adev->smu.debugfs_sclk =
-               debugfs_create_file("amdgpu_force_sclk", 0200,
-                                   adev_to_drm(adev)->primary->debugfs_root, adev,
-                                   &fops_sclk_set);
-       if (!(adev->smu.debugfs_sclk)) {
+       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");
                return -EIO;
        }
 
        /* Register debugfs entries for amdgpu_ttm */
                DRM_ERROR("unable to create amdgpu_set_sclk debugsfs file\n");
                return -EIO;
        }
 
        /* Register debugfs entries for amdgpu_ttm */

-       r = amdgpu_ttm_debugfs_init(adev);
-       if (r) {
-               DRM_ERROR("Failed to init debugfs\n");
-               return r;
-       }
-
-       r = amdgpu_debugfs_pm_init(adev);
-       if (r) {
-               DRM_ERROR("Failed to register debugfs file for dpm!\n");
-               return r;
-       }
-
-       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_ttm_debugfs_init(adev);
+       amdgpu_debugfs_pm_init(adev);
+       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_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 defined(CONFIG_DRM_AMD_DC)

-       if (amdgpu_device_has_dc_support(adev)) {
-               if (dtn_debugfs_init(adev))
-                       DRM_ERROR("amdgpu: failed initialize dtn debugfs support.\n");
-       }
+       if (amdgpu_device_has_dc_support(adev))
+               dtn_debugfs_init(adev);

 #endif
 
        for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
 #endif
 
        for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {


@@ -1665,17 +1590,26 @@ int amdgpu_debugfs_init(struct amdgpu_device *adev)
        }
 
        amdgpu_ras_debugfs_create_all(adev);
        }
 
        amdgpu_ras_debugfs_create_all(adev);

-

        amdgpu_debugfs_autodump_init(adev);
        amdgpu_debugfs_autodump_init(adev);

-

        amdgpu_rap_debugfs_init(adev);
        amdgpu_rap_debugfs_init(adev);

-

        amdgpu_securedisplay_debugfs_init(adev);
        amdgpu_securedisplay_debugfs_init(adev);

-

        amdgpu_fw_attestation_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
 }
 
 #else