drivers/gpu/drm/i915/i915_gem_debugfs.c

   1 /*
   2  * Copyright © 2008 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *    Keith Packard <keithp@keithp.com>
  26  *
  27  */
  28
  29 #include <linux/seq_file.h>
  30 #include "drmP.h"
  31 #include "drm.h"
  32 #include "i915_drm.h"
  33 #include "i915_drv.h"
  34
  35 #define DRM_I915_RING_DEBUG 1
  36
  37
  38 #if defined(CONFIG_DEBUG_FS)
  39
  40 static int i915_gem_active_info(struct seq_file *m, void *data)
  41 {
  42         struct drm_info_node *node = (struct drm_info_node *) m->private;
  43         struct drm_device *dev = node->minor->dev;
  44         drm_i915_private_t *dev_priv = dev->dev_private;
  45         struct drm_i915_gem_object *obj_priv;
  46
  47         seq_printf(m, "Active:\n");
  48         list_for_each_entry(obj_priv, &dev_priv->mm.active_list,
  49                         list)
  50         {
  51                 struct drm_gem_object *obj = obj_priv->obj;
  52                 if (obj->name) {
  53                         seq_printf(m, "    %p(%d): %08x %08x %d\n",
  54                                         obj, obj->name,
  55                                         obj->read_domains, obj->write_domain,
  56                                         obj_priv->last_rendering_seqno);
  57                 } else {
  58                         seq_printf(m, "       %p: %08x %08x %d\n",
  59                                         obj,
  60                                         obj->read_domains, obj->write_domain,
  61                                         obj_priv->last_rendering_seqno);
  62                 }
  63         }
  64         return 0;
  65 }
  66
  67 static int i915_gem_flushing_info(struct seq_file *m, void *data)
  68 {
  69         struct drm_info_node *node = (struct drm_info_node *) m->private;
  70         struct drm_device *dev = node->minor->dev;
  71         drm_i915_private_t *dev_priv = dev->dev_private;
  72         struct drm_i915_gem_object *obj_priv;
  73
  74         seq_printf(m, "Flushing:\n");
  75         list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list,
  76                         list)
  77         {
  78                 struct drm_gem_object *obj = obj_priv->obj;
  79                 if (obj->name) {
  80                         seq_printf(m, "    %p(%d): %08x %08x %d\n",
  81                                         obj, obj->name,
  82                                         obj->read_domains, obj->write_domain,
  83                                         obj_priv->last_rendering_seqno);
  84                 } else {
  85                         seq_printf(m, "       %p: %08x %08x %d\n", obj,
  86                                         obj->read_domains, obj->write_domain,
  87                                         obj_priv->last_rendering_seqno);
  88                 }
  89         }
  90         return 0;
  91 }
  92
  93 static int i915_gem_inactive_info(struct seq_file *m, void *data)
  94 {
  95         struct drm_info_node *node = (struct drm_info_node *) m->private;
  96         struct drm_device *dev = node->minor->dev;
  97         drm_i915_private_t *dev_priv = dev->dev_private;
  98         struct drm_i915_gem_object *obj_priv;
  99
 100         seq_printf(m, "Inactive:\n");
 101         list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list,
 102                         list)
 103         {
 104                 struct drm_gem_object *obj = obj_priv->obj;
 105                 if (obj->name) {
 106                         seq_printf(m, "    %p(%d): %08x %08x %d\n",
 107                                         obj, obj->name,
 108                                         obj->read_domains, obj->write_domain,
 109                                         obj_priv->last_rendering_seqno);
 110                 } else {
 111                         seq_printf(m, "       %p: %08x %08x %d\n", obj,
 112                                         obj->read_domains, obj->write_domain,
 113                                         obj_priv->last_rendering_seqno);
 114                 }
 115         }
 116         return 0;
 117 }
 118
 119 static int i915_gem_request_info(struct seq_file *m, void *data)
 120 {
 121         struct drm_info_node *node = (struct drm_info_node *) m->private;
 122         struct drm_device *dev = node->minor->dev;
 123         drm_i915_private_t *dev_priv = dev->dev_private;
 124         struct drm_i915_gem_request *gem_request;
 125
 126         seq_printf(m, "Request:\n");
 127         list_for_each_entry(gem_request, &dev_priv->mm.request_list, list) {
 128                 seq_printf(m, "    %d @ %d\n",
 129                            gem_request->seqno,
 130                            (int) (jiffies - gem_request->emitted_jiffies));
 131         }
 132         return 0;
 133 }
 134
 135 static int i915_gem_seqno_info(struct seq_file *m, void *data)
 136 {
 137         struct drm_info_node *node = (struct drm_info_node *) m->private;
 138         struct drm_device *dev = node->minor->dev;
 139         drm_i915_private_t *dev_priv = dev->dev_private;
 140
 141         if (dev_priv->hw_status_page != NULL) {
 142                 seq_printf(m, "Current sequence: %d\n",
 143                            i915_get_gem_seqno(dev));
 144         } else {
 145                 seq_printf(m, "Current sequence: hws uninitialized\n");
 146         }
 147         seq_printf(m, "Waiter sequence:  %d\n",
 148                         dev_priv->mm.waiting_gem_seqno);
 149         seq_printf(m, "IRQ sequence:     %d\n", dev_priv->mm.irq_gem_seqno);
 150         return 0;
 151 }
 152
 153
 154 static int i915_interrupt_info(struct seq_file *m, void *data)
 155 {
 156         struct drm_info_node *node = (struct drm_info_node *) m->private;
 157         struct drm_device *dev = node->minor->dev;
 158         drm_i915_private_t *dev_priv = dev->dev_private;
 159
 160         seq_printf(m, "Interrupt enable:    %08x\n",
 161                    I915_READ(IER));
 162         seq_printf(m, "Interrupt identity:  %08x\n",
 163                    I915_READ(IIR));
 164         seq_printf(m, "Interrupt mask:      %08x\n",
 165                    I915_READ(IMR));
 166         seq_printf(m, "Pipe A stat:         %08x\n",
 167                    I915_READ(PIPEASTAT));
 168         seq_printf(m, "Pipe B stat:         %08x\n",
 169                    I915_READ(PIPEBSTAT));
 170         seq_printf(m, "Interrupts received: %d\n",
 171                    atomic_read(&dev_priv->irq_received));
 172         if (dev_priv->hw_status_page != NULL) {
 173                 seq_printf(m, "Current sequence:    %d\n",
 174                            i915_get_gem_seqno(dev));
 175         } else {
 176                 seq_printf(m, "Current sequence:    hws uninitialized\n");
 177         }
 178         seq_printf(m, "Waiter sequence:     %d\n",
 179                    dev_priv->mm.waiting_gem_seqno);
 180         seq_printf(m, "IRQ sequence:        %d\n",
 181                    dev_priv->mm.irq_gem_seqno);
 182         return 0;
 183 }
 184
 185 static int i915_hws_info(struct seq_file *m, void *data)
 186 {
 187         struct drm_info_node *node = (struct drm_info_node *) m->private;
 188         struct drm_device *dev = node->minor->dev;
 189         drm_i915_private_t *dev_priv = dev->dev_private;
 190         int i;
 191         volatile u32 *hws;
 192
 193         hws = (volatile u32 *)dev_priv->hw_status_page;
 194         if (hws == NULL)
 195                 return 0;
 196
 197         for (i = 0; i < 4096 / sizeof(u32) / 4; i += 4) {
 198                 seq_printf(m, "0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
 199                            i * 4,
 200                            hws[i], hws[i + 1], hws[i + 2], hws[i + 3]);
 201         }
 202         return 0;
 203 }
 204
 205 static struct drm_info_list i915_gem_debugfs_list[] = {
 206         {"i915_gem_active", i915_gem_active_info, 0},
 207         {"i915_gem_flushing", i915_gem_flushing_info, 0},
 208         {"i915_gem_inactive", i915_gem_inactive_info, 0},
 209         {"i915_gem_request", i915_gem_request_info, 0},
 210         {"i915_gem_seqno", i915_gem_seqno_info, 0},
 211         {"i915_gem_interrupt", i915_interrupt_info, 0},
 212         {"i915_gem_hws", i915_hws_info, 0},
 213 };
 214 #define I915_GEM_DEBUGFS_ENTRIES ARRAY_SIZE(i915_gem_debugfs_list)
 215
 216 int i915_gem_debugfs_init(struct drm_minor *minor)
 217 {
 218         return drm_debugfs_create_files(i915_gem_debugfs_list,
 219                                         I915_GEM_DEBUGFS_ENTRIES,
 220                                         minor->debugfs_root, minor);
 221 }
 222
 223 void i915_gem_debugfs_cleanup(struct drm_minor *minor)
 224 {
 225         drm_debugfs_remove_files(i915_gem_debugfs_list,
 226                                  I915_GEM_DEBUGFS_ENTRIES, minor);
 227 }
 228
 229 #endif /* CONFIG_DEBUG_FS */
 230