drivers/gpu/drm/msm/msm_debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2013-2016 Red Hat
   4  * Author: Rob Clark <[email protected]>
   5  */
   6
   7 #ifdef CONFIG_DEBUG_FS
   8
   9 #include <linux/debugfs.h>
  10
  11 #include <drm/drm_debugfs.h>
  12 #include <drm/drm_file.h>
  13
  14 #include "msm_drv.h"
  15 #include "msm_gpu.h"
  16 #include "msm_kms.h"
  17 #include "msm_debugfs.h"
  18
  19 struct msm_gpu_show_priv {
  20         struct msm_gpu_state *state;
  21         struct drm_device *dev;
  22 };
  23
  24 static int msm_gpu_show(struct seq_file *m, void *arg)
  25 {
  26         struct drm_printer p = drm_seq_file_printer(m);
  27         struct msm_gpu_show_priv *show_priv = m->private;
  28         struct msm_drm_private *priv = show_priv->dev->dev_private;
  29         struct msm_gpu *gpu = priv->gpu;
  30         int ret;
  31
  32         ret = mutex_lock_interruptible(&show_priv->dev->struct_mutex);
  33         if (ret)
  34                 return ret;
  35
  36         drm_printf(&p, "%s Status:\n", gpu->name);
  37         gpu->funcs->show(gpu, show_priv->state, &p);
  38
  39         mutex_unlock(&show_priv->dev->struct_mutex);
  40
  41         return 0;
  42 }
  43
  44 static int msm_gpu_release(struct inode *inode, struct file *file)
  45 {
  46         struct seq_file *m = file->private_data;
  47         struct msm_gpu_show_priv *show_priv = m->private;
  48         struct msm_drm_private *priv = show_priv->dev->dev_private;
  49         struct msm_gpu *gpu = priv->gpu;
  50         int ret;
  51
  52         ret = mutex_lock_interruptible(&show_priv->dev->struct_mutex);
  53         if (ret)
  54                 return ret;
  55
  56         gpu->funcs->gpu_state_put(show_priv->state);
  57         mutex_unlock(&show_priv->dev->struct_mutex);
  58
  59         kfree(show_priv);
  60
  61         return single_release(inode, file);
  62 }
  63
  64 static int msm_gpu_open(struct inode *inode, struct file *file)
  65 {
  66         struct drm_device *dev = inode->i_private;
  67         struct msm_drm_private *priv = dev->dev_private;
  68         struct msm_gpu *gpu = priv->gpu;
  69         struct msm_gpu_show_priv *show_priv;
  70         int ret;
  71
  72         if (!gpu || !gpu->funcs->gpu_state_get)
  73                 return -ENODEV;
  74
  75         show_priv = kmalloc(sizeof(*show_priv), GFP_KERNEL);
  76         if (!show_priv)
  77                 return -ENOMEM;
  78
  79         ret = mutex_lock_interruptible(&dev->struct_mutex);
  80         if (ret)
  81                 goto free_priv;
  82
  83         pm_runtime_get_sync(&gpu->pdev->dev);
  84         show_priv->state = gpu->funcs->gpu_state_get(gpu);
  85         pm_runtime_put_sync(&gpu->pdev->dev);
  86
  87         mutex_unlock(&dev->struct_mutex);
  88
  89         if (IS_ERR(show_priv->state)) {
  90                 ret = PTR_ERR(show_priv->state);
  91                 goto free_priv;
  92         }
  93
  94         show_priv->dev = dev;
  95
  96         ret = single_open(file, msm_gpu_show, show_priv);
  97         if (ret)
  98                 goto free_priv;
  99
 100         return 0;
 101
 102 free_priv:
 103         kfree(show_priv);
 104         return ret;
 105 }
 106
 107 static const struct file_operations msm_gpu_fops = {
 108         .owner = THIS_MODULE,
 109         .open = msm_gpu_open,
 110         .read = seq_read,
 111         .llseek = seq_lseek,
 112         .release = msm_gpu_release,
 113 };
 114
 115 static int msm_gem_show(struct drm_device *dev, struct seq_file *m)
 116 {
 117         struct msm_drm_private *priv = dev->dev_private;
 118         struct msm_gpu *gpu = priv->gpu;
 119
 120         if (gpu) {
 121                 seq_printf(m, "Active Objects (%s):\n", gpu->name);
 122                 msm_gem_describe_objects(&gpu->active_list, m);
 123         }
 124
 125         seq_printf(m, "Inactive Objects:\n");
 126         msm_gem_describe_objects(&priv->inactive_list, m);
 127
 128         return 0;
 129 }
 130
 131 static int msm_mm_show(struct drm_device *dev, struct seq_file *m)
 132 {
 133         struct drm_printer p = drm_seq_file_printer(m);
 134
 135         drm_mm_print(&dev->vma_offset_manager->vm_addr_space_mm, &p);
 136
 137         return 0;
 138 }
 139
 140 static int msm_fb_show(struct drm_device *dev, struct seq_file *m)
 141 {
 142         struct msm_drm_private *priv = dev->dev_private;
 143         struct drm_framebuffer *fb, *fbdev_fb = NULL;
 144
 145         if (priv->fbdev) {
 146                 seq_printf(m, "fbcon ");
 147                 fbdev_fb = priv->fbdev->fb;
 148                 msm_framebuffer_describe(fbdev_fb, m);
 149         }
 150
 151         mutex_lock(&dev->mode_config.fb_lock);
 152         list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
 153                 if (fb == fbdev_fb)
 154                         continue;
 155
 156                 seq_printf(m, "user ");
 157                 msm_framebuffer_describe(fb, m);
 158         }
 159         mutex_unlock(&dev->mode_config.fb_lock);
 160
 161         return 0;
 162 }
 163
 164 static int show_locked(struct seq_file *m, void *arg)
 165 {
 166         struct drm_info_node *node = (struct drm_info_node *) m->private;
 167         struct drm_device *dev = node->minor->dev;
 168         int (*show)(struct drm_device *dev, struct seq_file *m) =
 169                         node->info_ent->data;
 170         int ret;
 171
 172         ret = mutex_lock_interruptible(&dev->struct_mutex);
 173         if (ret)
 174                 return ret;
 175
 176         ret = show(dev, m);
 177
 178         mutex_unlock(&dev->struct_mutex);
 179
 180         return ret;
 181 }
 182
 183 static struct drm_info_list msm_debugfs_list[] = {
 184                 {"gem", show_locked, 0, msm_gem_show},
 185                 { "mm", show_locked, 0, msm_mm_show },
 186                 { "fb", show_locked, 0, msm_fb_show },
 187 };
 188
 189 static int late_init_minor(struct drm_minor *minor)
 190 {
 191         int ret;
 192
 193         if (!minor)
 194                 return 0;
 195
 196         ret = msm_rd_debugfs_init(minor);
 197         if (ret) {
 198                 DRM_DEV_ERROR(minor->dev->dev, "could not install rd debugfs\n");
 199                 return ret;
 200         }
 201
 202         ret = msm_perf_debugfs_init(minor);
 203         if (ret) {
 204                 DRM_DEV_ERROR(minor->dev->dev, "could not install perf debugfs\n");
 205                 return ret;
 206         }
 207
 208         return 0;
 209 }
 210
 211 int msm_debugfs_late_init(struct drm_device *dev)
 212 {
 213         int ret;
 214         ret = late_init_minor(dev->primary);
 215         if (ret)
 216                 return ret;
 217         ret = late_init_minor(dev->render);
 218         return ret;
 219 }
 220
 221 int msm_debugfs_init(struct drm_minor *minor)
 222 {
 223         struct drm_device *dev = minor->dev;
 224         struct msm_drm_private *priv = dev->dev_private;
 225         int ret;
 226
 227         ret = drm_debugfs_create_files(msm_debugfs_list,
 228                         ARRAY_SIZE(msm_debugfs_list),
 229                         minor->debugfs_root, minor);
 230
 231         if (ret) {
 232                 DRM_DEV_ERROR(dev->dev, "could not install msm_debugfs_list\n");
 233                 return ret;
 234         }
 235
 236         debugfs_create_file("gpu", S_IRUSR, minor->debugfs_root,
 237                 dev, &msm_gpu_fops);
 238
 239         if (priv->kms && priv->kms->funcs->debugfs_init) {
 240                 ret = priv->kms->funcs->debugfs_init(priv->kms, minor);
 241                 if (ret)
 242                         return ret;
 243         }
 244
 245         return ret;
 246 }
 247 #endif
 248