drivers/gpu/drm/msm/msm_debugfs.c

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