drivers/gpu/drm/i915/i915_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 <linux/debugfs.h>
  31 #include <linux/slab.h>
  32 #include <linux/export.h>
  33 #include <drm/drmP.h>
  34 #include "intel_drv.h"
  35 #include "intel_ringbuffer.h"
  36 #include <drm/i915_drm.h>
  37 #include "i915_drv.h"
  38
  39 #define DRM_I915_RING_DEBUG 1
  40
  41
  42 #if defined(CONFIG_DEBUG_FS)
  43
  44 enum {
  45         ACTIVE_LIST,
  46         INACTIVE_LIST,
  47         PINNED_LIST,
  48 };
  49
  50 static const char *yesno(int v)
  51 {
  52         return v ? "yes" : "no";
  53 }
  54
  55 static int i915_capabilities(struct seq_file *m, void *data)
  56 {
  57         struct drm_info_node *node = (struct drm_info_node *) m->private;
  58         struct drm_device *dev = node->minor->dev;
  59         const struct intel_device_info *info = INTEL_INFO(dev);
  60
  61         seq_printf(m, "gen: %d\n", info->gen);
  62         seq_printf(m, "pch: %d\n", INTEL_PCH_TYPE(dev));
  63 #define DEV_INFO_FLAG(x) seq_printf(m, #x ": %s\n", yesno(info->x))
  64 #define DEV_INFO_SEP ;
  65         DEV_INFO_FLAGS;
  66 #undef DEV_INFO_FLAG
  67 #undef DEV_INFO_SEP
  68
  69         return 0;
  70 }
  71
  72 static const char *get_pin_flag(struct drm_i915_gem_object *obj)
  73 {
  74         if (obj->user_pin_count > 0)
  75                 return "P";
  76         else if (obj->pin_count > 0)
  77                 return "p";
  78         else
  79                 return " ";
  80 }
  81
  82 static const char *get_tiling_flag(struct drm_i915_gem_object *obj)
  83 {
  84         switch (obj->tiling_mode) {
  85         default:
  86         case I915_TILING_NONE: return " ";
  87         case I915_TILING_X: return "X";
  88         case I915_TILING_Y: return "Y";
  89         }
  90 }
  91
  92 static const char *cache_level_str(int type)
  93 {
  94         switch (type) {
  95         case I915_CACHE_NONE: return " uncached";
  96         case I915_CACHE_LLC: return " snooped (LLC)";
  97         case I915_CACHE_LLC_MLC: return " snooped (LLC+MLC)";
  98         default: return "";
  99         }
 100 }
 101
 102 static void
 103 describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
 104 {
 105         seq_printf(m, "%p: %s%s %8zdKiB %02x %02x %d %d %d%s%s%s",
 106                    &obj->base,
 107                    get_pin_flag(obj),
 108                    get_tiling_flag(obj),
 109                    obj->base.size / 1024,
 110                    obj->base.read_domains,
 111                    obj->base.write_domain,
 112                    obj->last_read_seqno,
 113                    obj->last_write_seqno,
 114                    obj->last_fenced_seqno,
 115                    cache_level_str(obj->cache_level),
 116                    obj->dirty ? " dirty" : "",
 117                    obj->madv == I915_MADV_DONTNEED ? " purgeable" : "");
 118         if (obj->base.name)
 119                 seq_printf(m, " (name: %d)", obj->base.name);
 120         if (obj->pin_count)
 121                 seq_printf(m, " (pinned x %d)", obj->pin_count);
 122         if (obj->fence_reg != I915_FENCE_REG_NONE)
 123                 seq_printf(m, " (fence: %d)", obj->fence_reg);
 124         if (obj->gtt_space != NULL)
 125                 seq_printf(m, " (gtt offset: %08x, size: %08x)",
 126                            obj->gtt_offset, (unsigned int)obj->gtt_space->size);
 127         if (obj->stolen)
 128                 seq_printf(m, " (stolen: %08lx)", obj->stolen->start);
 129         if (obj->pin_mappable || obj->fault_mappable) {
 130                 char s[3], *t = s;
 131                 if (obj->pin_mappable)
 132                         *t++ = 'p';
 133                 if (obj->fault_mappable)
 134                         *t++ = 'f';
 135                 *t = '\0';
 136                 seq_printf(m, " (%s mappable)", s);
 137         }
 138         if (obj->ring != NULL)
 139                 seq_printf(m, " (%s)", obj->ring->name);
 140 }
 141
 142 static int i915_gem_object_list_info(struct seq_file *m, void *data)
 143 {
 144         struct drm_info_node *node = (struct drm_info_node *) m->private;
 145         uintptr_t list = (uintptr_t) node->info_ent->data;
 146         struct list_head *head;
 147         struct drm_device *dev = node->minor->dev;
 148         drm_i915_private_t *dev_priv = dev->dev_private;
 149         struct drm_i915_gem_object *obj;
 150         size_t total_obj_size, total_gtt_size;
 151         int count, ret;
 152
 153         ret = mutex_lock_interruptible(&dev->struct_mutex);
 154         if (ret)
 155                 return ret;
 156
 157         switch (list) {
 158         case ACTIVE_LIST:
 159                 seq_printf(m, "Active:\n");
 160                 head = &dev_priv->mm.active_list;
 161                 break;
 162         case INACTIVE_LIST:
 163                 seq_printf(m, "Inactive:\n");
 164                 head = &dev_priv->mm.inactive_list;
 165                 break;
 166         default:
 167                 mutex_unlock(&dev->struct_mutex);
 168                 return -EINVAL;
 169         }
 170
 171         total_obj_size = total_gtt_size = count = 0;
 172         list_for_each_entry(obj, head, mm_list) {
 173                 seq_printf(m, "   ");
 174                 describe_obj(m, obj);
 175                 seq_printf(m, "\n");
 176                 total_obj_size += obj->base.size;
 177                 total_gtt_size += obj->gtt_space->size;
 178                 count++;
 179         }
 180         mutex_unlock(&dev->struct_mutex);
 181
 182         seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
 183                    count, total_obj_size, total_gtt_size);
 184         return 0;
 185 }
 186
 187 #define count_objects(list, member) do { \
 188         list_for_each_entry(obj, list, member) { \
 189                 size += obj->gtt_space->size; \
 190                 ++count; \
 191                 if (obj->map_and_fenceable) { \
 192                         mappable_size += obj->gtt_space->size; \
 193                         ++mappable_count; \
 194                 } \
 195         } \
 196 } while (0)
 197
 198 static int i915_gem_object_info(struct seq_file *m, void* data)
 199 {
 200         struct drm_info_node *node = (struct drm_info_node *) m->private;
 201         struct drm_device *dev = node->minor->dev;
 202         struct drm_i915_private *dev_priv = dev->dev_private;
 203         u32 count, mappable_count, purgeable_count;
 204         size_t size, mappable_size, purgeable_size;
 205         struct drm_i915_gem_object *obj;
 206         int ret;
 207
 208         ret = mutex_lock_interruptible(&dev->struct_mutex);
 209         if (ret)
 210                 return ret;
 211
 212         seq_printf(m, "%u objects, %zu bytes\n",
 213                    dev_priv->mm.object_count,
 214                    dev_priv->mm.object_memory);
 215
 216         size = count = mappable_size = mappable_count = 0;
 217         count_objects(&dev_priv->mm.bound_list, gtt_list);
 218         seq_printf(m, "%u [%u] objects, %zu [%zu] bytes in gtt\n",
 219                    count, mappable_count, size, mappable_size);
 220
 221         size = count = mappable_size = mappable_count = 0;
 222         count_objects(&dev_priv->mm.active_list, mm_list);
 223         seq_printf(m, "  %u [%u] active objects, %zu [%zu] bytes\n",
 224                    count, mappable_count, size, mappable_size);
 225
 226         size = count = mappable_size = mappable_count = 0;
 227         count_objects(&dev_priv->mm.inactive_list, mm_list);
 228         seq_printf(m, "  %u [%u] inactive objects, %zu [%zu] bytes\n",
 229                    count, mappable_count, size, mappable_size);
 230
 231         size = count = purgeable_size = purgeable_count = 0;
 232         list_for_each_entry(obj, &dev_priv->mm.unbound_list, gtt_list) {
 233                 size += obj->base.size, ++count;
 234                 if (obj->madv == I915_MADV_DONTNEED)
 235                         purgeable_size += obj->base.size, ++purgeable_count;
 236         }
 237         seq_printf(m, "%u unbound objects, %zu bytes\n", count, size);
 238
 239         size = count = mappable_size = mappable_count = 0;
 240         list_for_each_entry(obj, &dev_priv->mm.bound_list, gtt_list) {
 241                 if (obj->fault_mappable) {
 242                         size += obj->gtt_space->size;
 243                         ++count;
 244                 }
 245                 if (obj->pin_mappable) {
 246                         mappable_size += obj->gtt_space->size;
 247                         ++mappable_count;
 248                 }
 249                 if (obj->madv == I915_MADV_DONTNEED) {
 250                         purgeable_size += obj->base.size;
 251                         ++purgeable_count;
 252                 }
 253         }
 254         seq_printf(m, "%u purgeable objects, %zu bytes\n",
 255                    purgeable_count, purgeable_size);
 256         seq_printf(m, "%u pinned mappable objects, %zu bytes\n",
 257                    mappable_count, mappable_size);
 258         seq_printf(m, "%u fault mappable objects, %zu bytes\n",
 259                    count, size);
 260
 261         seq_printf(m, "%zu [%zu] gtt total\n",
 262                    dev_priv->mm.gtt_total, dev_priv->mm.mappable_gtt_total);
 263
 264         mutex_unlock(&dev->struct_mutex);
 265
 266         return 0;
 267 }
 268
 269 static int i915_gem_gtt_info(struct seq_file *m, void* data)
 270 {
 271         struct drm_info_node *node = (struct drm_info_node *) m->private;
 272         struct drm_device *dev = node->minor->dev;
 273         uintptr_t list = (uintptr_t) node->info_ent->data;
 274         struct drm_i915_private *dev_priv = dev->dev_private;
 275         struct drm_i915_gem_object *obj;
 276         size_t total_obj_size, total_gtt_size;
 277         int count, ret;
 278
 279         ret = mutex_lock_interruptible(&dev->struct_mutex);
 280         if (ret)
 281                 return ret;
 282
 283         total_obj_size = total_gtt_size = count = 0;
 284         list_for_each_entry(obj, &dev_priv->mm.bound_list, gtt_list) {
 285                 if (list == PINNED_LIST && obj->pin_count == 0)
 286                         continue;
 287
 288                 seq_printf(m, "   ");
 289                 describe_obj(m, obj);
 290                 seq_printf(m, "\n");
 291                 total_obj_size += obj->base.size;
 292                 total_gtt_size += obj->gtt_space->size;
 293                 count++;
 294         }
 295
 296         mutex_unlock(&dev->struct_mutex);
 297
 298         seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
 299                    count, total_obj_size, total_gtt_size);
 300
 301         return 0;
 302 }
 303
 304 static int i915_gem_pageflip_info(struct seq_file *m, void *data)
 305 {
 306         struct drm_info_node *node = (struct drm_info_node *) m->private;
 307         struct drm_device *dev = node->minor->dev;
 308         unsigned long flags;
 309         struct intel_crtc *crtc;
 310
 311         list_for_each_entry(crtc, &dev->mode_config.crtc_list, base.head) {
 312                 const char pipe = pipe_name(crtc->pipe);
 313                 const char plane = plane_name(crtc->plane);
 314                 struct intel_unpin_work *work;
 315
 316                 spin_lock_irqsave(&dev->event_lock, flags);
 317                 work = crtc->unpin_work;
 318                 if (work == NULL) {
 319                         seq_printf(m, "No flip due on pipe %c (plane %c)\n",
 320                                    pipe, plane);
 321                 } else {
 322                         if (atomic_read(&work->pending) < INTEL_FLIP_COMPLETE) {
 323                                 seq_printf(m, "Flip queued on pipe %c (plane %c)\n",
 324                                            pipe, plane);
 325                         } else {
 326                                 seq_printf(m, "Flip pending (waiting for vsync) on pipe %c (plane %c)\n",
 327                                            pipe, plane);
 328                         }
 329                         if (work->enable_stall_check)
 330                                 seq_printf(m, "Stall check enabled, ");
 331                         else
 332                                 seq_printf(m, "Stall check waiting for page flip ioctl, ");
 333                         seq_printf(m, "%d prepares\n", atomic_read(&work->pending));
 334
 335                         if (work->old_fb_obj) {
 336                                 struct drm_i915_gem_object *obj = work->old_fb_obj;
 337                                 if (obj)
 338                                         seq_printf(m, "Old framebuffer gtt_offset 0x%08x\n", obj->gtt_offset);
 339                         }
 340                         if (work->pending_flip_obj) {
 341                                 struct drm_i915_gem_object *obj = work->pending_flip_obj;
 342                                 if (obj)
 343                                         seq_printf(m, "New framebuffer gtt_offset 0x%08x\n", obj->gtt_offset);
 344                         }
 345                 }
 346                 spin_unlock_irqrestore(&dev->event_lock, flags);
 347         }
 348
 349         return 0;
 350 }
 351
 352 static int i915_gem_request_info(struct seq_file *m, void *data)
 353 {
 354         struct drm_info_node *node = (struct drm_info_node *) m->private;
 355         struct drm_device *dev = node->minor->dev;
 356         drm_i915_private_t *dev_priv = dev->dev_private;
 357         struct intel_ring_buffer *ring;
 358         struct drm_i915_gem_request *gem_request;
 359         int ret, count, i;
 360
 361         ret = mutex_lock_interruptible(&dev->struct_mutex);
 362         if (ret)
 363                 return ret;
 364
 365         count = 0;
 366         for_each_ring(ring, dev_priv, i) {
 367                 if (list_empty(&ring->request_list))
 368                         continue;
 369
 370                 seq_printf(m, "%s requests:\n", ring->name);
 371                 list_for_each_entry(gem_request,
 372                                     &ring->request_list,
 373                                     list) {
 374                         seq_printf(m, "    %d @ %d\n",
 375                                    gem_request->seqno,
 376                                    (int) (jiffies - gem_request->emitted_jiffies));
 377                 }
 378                 count++;
 379         }
 380         mutex_unlock(&dev->struct_mutex);
 381
 382         if (count == 0)
 383                 seq_printf(m, "No requests\n");
 384
 385         return 0;
 386 }
 387
 388 static void i915_ring_seqno_info(struct seq_file *m,
 389                                  struct intel_ring_buffer *ring)
 390 {
 391         if (ring->get_seqno) {
 392                 seq_printf(m, "Current sequence (%s): %u\n",
 393                            ring->name, ring->get_seqno(ring, false));
 394         }
 395 }
 396
 397 static int i915_gem_seqno_info(struct seq_file *m, void *data)
 398 {
 399         struct drm_info_node *node = (struct drm_info_node *) m->private;
 400         struct drm_device *dev = node->minor->dev;
 401         drm_i915_private_t *dev_priv = dev->dev_private;
 402         struct intel_ring_buffer *ring;
 403         int ret, i;
 404
 405         ret = mutex_lock_interruptible(&dev->struct_mutex);
 406         if (ret)
 407                 return ret;
 408
 409         for_each_ring(ring, dev_priv, i)
 410                 i915_ring_seqno_info(m, ring);
 411
 412         mutex_unlock(&dev->struct_mutex);
 413
 414         return 0;
 415 }
 416
 417
 418 static int i915_interrupt_info(struct seq_file *m, void *data)
 419 {
 420         struct drm_info_node *node = (struct drm_info_node *) m->private;
 421         struct drm_device *dev = node->minor->dev;
 422         drm_i915_private_t *dev_priv = dev->dev_private;
 423         struct intel_ring_buffer *ring;
 424         int ret, i, pipe;
 425
 426         ret = mutex_lock_interruptible(&dev->struct_mutex);
 427         if (ret)
 428                 return ret;
 429
 430         if (IS_VALLEYVIEW(dev)) {
 431                 seq_printf(m, "Display IER:\t%08x\n",
 432                            I915_READ(VLV_IER));
 433                 seq_printf(m, "Display IIR:\t%08x\n",
 434                            I915_READ(VLV_IIR));
 435                 seq_printf(m, "Display IIR_RW:\t%08x\n",
 436                            I915_READ(VLV_IIR_RW));
 437                 seq_printf(m, "Display IMR:\t%08x\n",
 438                            I915_READ(VLV_IMR));
 439                 for_each_pipe(pipe)
 440                         seq_printf(m, "Pipe %c stat:\t%08x\n",
 441                                    pipe_name(pipe),
 442                                    I915_READ(PIPESTAT(pipe)));
 443
 444                 seq_printf(m, "Master IER:\t%08x\n",
 445                            I915_READ(VLV_MASTER_IER));
 446
 447                 seq_printf(m, "Render IER:\t%08x\n",
 448                            I915_READ(GTIER));
 449                 seq_printf(m, "Render IIR:\t%08x\n",
 450                            I915_READ(GTIIR));
 451                 seq_printf(m, "Render IMR:\t%08x\n",
 452                            I915_READ(GTIMR));
 453
 454                 seq_printf(m, "PM IER:\t\t%08x\n",
 455                            I915_READ(GEN6_PMIER));
 456                 seq_printf(m, "PM IIR:\t\t%08x\n",
 457                            I915_READ(GEN6_PMIIR));
 458                 seq_printf(m, "PM IMR:\t\t%08x\n",
 459                            I915_READ(GEN6_PMIMR));
 460
 461                 seq_printf(m, "Port hotplug:\t%08x\n",
 462                            I915_READ(PORT_HOTPLUG_EN));
 463                 seq_printf(m, "DPFLIPSTAT:\t%08x\n",
 464                            I915_READ(VLV_DPFLIPSTAT));
 465                 seq_printf(m, "DPINVGTT:\t%08x\n",
 466                            I915_READ(DPINVGTT));
 467
 468         } else if (!HAS_PCH_SPLIT(dev)) {
 469                 seq_printf(m, "Interrupt enable:    %08x\n",
 470                            I915_READ(IER));
 471                 seq_printf(m, "Interrupt identity:  %08x\n",
 472                            I915_READ(IIR));
 473                 seq_printf(m, "Interrupt mask:      %08x\n",
 474                            I915_READ(IMR));
 475                 for_each_pipe(pipe)
 476                         seq_printf(m, "Pipe %c stat:         %08x\n",
 477                                    pipe_name(pipe),
 478                                    I915_READ(PIPESTAT(pipe)));
 479         } else {
 480                 seq_printf(m, "North Display Interrupt enable:          %08x\n",
 481                            I915_READ(DEIER));
 482                 seq_printf(m, "North Display Interrupt identity:        %08x\n",
 483                            I915_READ(DEIIR));
 484                 seq_printf(m, "North Display Interrupt mask:            %08x\n",
 485                            I915_READ(DEIMR));
 486                 seq_printf(m, "South Display Interrupt enable:          %08x\n",
 487                            I915_READ(SDEIER));
 488                 seq_printf(m, "South Display Interrupt identity:        %08x\n",
 489                            I915_READ(SDEIIR));
 490                 seq_printf(m, "South Display Interrupt mask:            %08x\n",
 491                            I915_READ(SDEIMR));
 492                 seq_printf(m, "Graphics Interrupt enable:               %08x\n",
 493                            I915_READ(GTIER));
 494                 seq_printf(m, "Graphics Interrupt identity:             %08x\n",
 495                            I915_READ(GTIIR));
 496                 seq_printf(m, "Graphics Interrupt mask:         %08x\n",
 497                            I915_READ(GTIMR));
 498         }
 499         seq_printf(m, "Interrupts received: %d\n",
 500                    atomic_read(&dev_priv->irq_received));
 501         for_each_ring(ring, dev_priv, i) {
 502                 if (IS_GEN6(dev) || IS_GEN7(dev)) {
 503                         seq_printf(m,
 504                                    "Graphics Interrupt mask (%s):       %08x\n",
 505                                    ring->name, I915_READ_IMR(ring));
 506                 }
 507                 i915_ring_seqno_info(m, ring);
 508         }
 509         mutex_unlock(&dev->struct_mutex);
 510
 511         return 0;
 512 }
 513
 514 static int i915_gem_fence_regs_info(struct seq_file *m, void *data)
 515 {
 516         struct drm_info_node *node = (struct drm_info_node *) m->private;
 517         struct drm_device *dev = node->minor->dev;
 518         drm_i915_private_t *dev_priv = dev->dev_private;
 519         int i, ret;
 520
 521         ret = mutex_lock_interruptible(&dev->struct_mutex);
 522         if (ret)
 523                 return ret;
 524
 525         seq_printf(m, "Reserved fences = %d\n", dev_priv->fence_reg_start);
 526         seq_printf(m, "Total fences = %d\n", dev_priv->num_fence_regs);
 527         for (i = 0; i < dev_priv->num_fence_regs; i++) {
 528                 struct drm_i915_gem_object *obj = dev_priv->fence_regs[i].obj;
 529
 530                 seq_printf(m, "Fence %d, pin count = %d, object = ",
 531                            i, dev_priv->fence_regs[i].pin_count);
 532                 if (obj == NULL)
 533                         seq_printf(m, "unused");
 534                 else
 535                         describe_obj(m, obj);
 536                 seq_printf(m, "\n");
 537         }
 538
 539         mutex_unlock(&dev->struct_mutex);
 540         return 0;
 541 }
 542
 543 static int i915_hws_info(struct seq_file *m, void *data)
 544 {
 545         struct drm_info_node *node = (struct drm_info_node *) m->private;
 546         struct drm_device *dev = node->minor->dev;
 547         drm_i915_private_t *dev_priv = dev->dev_private;
 548         struct intel_ring_buffer *ring;
 549         const u32 *hws;
 550         int i;
 551
 552         ring = &dev_priv->ring[(uintptr_t)node->info_ent->data];
 553         hws = ring->status_page.page_addr;
 554         if (hws == NULL)
 555                 return 0;
 556
 557         for (i = 0; i < 4096 / sizeof(u32) / 4; i += 4) {
 558                 seq_printf(m, "0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
 559                            i * 4,
 560                            hws[i], hws[i + 1], hws[i + 2], hws[i + 3]);
 561         }
 562         return 0;
 563 }
 564
 565 static const char *ring_str(int ring)
 566 {
 567         switch (ring) {
 568         case RCS: return "render";
 569         case VCS: return "bsd";
 570         case BCS: return "blt";
 571         default: return "";
 572         }
 573 }
 574
 575 static const char *pin_flag(int pinned)
 576 {
 577         if (pinned > 0)
 578                 return " P";
 579         else if (pinned < 0)
 580                 return " p";
 581         else
 582                 return "";
 583 }
 584
 585 static const char *tiling_flag(int tiling)
 586 {
 587         switch (tiling) {
 588         default:
 589         case I915_TILING_NONE: return "";
 590         case I915_TILING_X: return " X";
 591         case I915_TILING_Y: return " Y";
 592         }
 593 }
 594
 595 static const char *dirty_flag(int dirty)
 596 {
 597         return dirty ? " dirty" : "";
 598 }
 599
 600 static const char *purgeable_flag(int purgeable)
 601 {
 602         return purgeable ? " purgeable" : "";
 603 }
 604
 605 static void print_error_buffers(struct seq_file *m,
 606                                 const char *name,
 607                                 struct drm_i915_error_buffer *err,
 608                                 int count)
 609 {
 610         seq_printf(m, "%s [%d]:\n", name, count);
 611
 612         while (count--) {
 613                 seq_printf(m, "  %08x %8u %02x %02x %x %x%s%s%s%s%s%s%s",
 614                            err->gtt_offset,
 615                            err->size,
 616                            err->read_domains,
 617                            err->write_domain,
 618                            err->rseqno, err->wseqno,
 619                            pin_flag(err->pinned),
 620                            tiling_flag(err->tiling),
 621                            dirty_flag(err->dirty),
 622                            purgeable_flag(err->purgeable),
 623                            err->ring != -1 ? " " : "",
 624                            ring_str(err->ring),
 625                            cache_level_str(err->cache_level));
 626
 627                 if (err->name)
 628                         seq_printf(m, " (name: %d)", err->name);
 629                 if (err->fence_reg != I915_FENCE_REG_NONE)
 630                         seq_printf(m, " (fence: %d)", err->fence_reg);
 631
 632                 seq_printf(m, "\n");
 633                 err++;
 634         }
 635 }
 636
 637 static void i915_ring_error_state(struct seq_file *m,
 638                                   struct drm_device *dev,
 639                                   struct drm_i915_error_state *error,
 640                                   unsigned ring)
 641 {
 642         BUG_ON(ring >= I915_NUM_RINGS); /* shut up confused gcc */
 643         seq_printf(m, "%s command stream:\n", ring_str(ring));
 644         seq_printf(m, "  HEAD: 0x%08x\n", error->head[ring]);
 645         seq_printf(m, "  TAIL: 0x%08x\n", error->tail[ring]);
 646         seq_printf(m, "  ACTHD: 0x%08x\n", error->acthd[ring]);
 647         seq_printf(m, "  IPEIR: 0x%08x\n", error->ipeir[ring]);
 648         seq_printf(m, "  IPEHR: 0x%08x\n", error->ipehr[ring]);
 649         seq_printf(m, "  INSTDONE: 0x%08x\n", error->instdone[ring]);
 650         if (ring == RCS && INTEL_INFO(dev)->gen >= 4)
 651                 seq_printf(m, "  BBADDR: 0x%08llx\n", error->bbaddr);
 652
 653         if (INTEL_INFO(dev)->gen >= 4)
 654                 seq_printf(m, "  INSTPS: 0x%08x\n", error->instps[ring]);
 655         seq_printf(m, "  INSTPM: 0x%08x\n", error->instpm[ring]);
 656         seq_printf(m, "  FADDR: 0x%08x\n", error->faddr[ring]);
 657         if (INTEL_INFO(dev)->gen >= 6) {
 658                 seq_printf(m, "  RC PSMI: 0x%08x\n", error->rc_psmi[ring]);
 659                 seq_printf(m, "  FAULT_REG: 0x%08x\n", error->fault_reg[ring]);
 660                 seq_printf(m, "  SYNC_0: 0x%08x [last synced 0x%08x]\n",
 661                            error->semaphore_mboxes[ring][0],
 662                            error->semaphore_seqno[ring][0]);
 663                 seq_printf(m, "  SYNC_1: 0x%08x [last synced 0x%08x]\n",
 664                            error->semaphore_mboxes[ring][1],
 665                            error->semaphore_seqno[ring][1]);
 666         }
 667         seq_printf(m, "  seqno: 0x%08x\n", error->seqno[ring]);
 668         seq_printf(m, "  waiting: %s\n", yesno(error->waiting[ring]));
 669         seq_printf(m, "  ring->head: 0x%08x\n", error->cpu_ring_head[ring]);
 670         seq_printf(m, "  ring->tail: 0x%08x\n", error->cpu_ring_tail[ring]);
 671 }
 672
 673 struct i915_error_state_file_priv {
 674         struct drm_device *dev;
 675         struct drm_i915_error_state *error;
 676 };
 677
 678 static int i915_error_state(struct seq_file *m, void *unused)
 679 {
 680         struct i915_error_state_file_priv *error_priv = m->private;
 681         struct drm_device *dev = error_priv->dev;
 682         drm_i915_private_t *dev_priv = dev->dev_private;
 683         struct drm_i915_error_state *error = error_priv->error;
 684         struct intel_ring_buffer *ring;
 685         int i, j, page, offset, elt;
 686
 687         if (!error) {
 688                 seq_printf(m, "no error state collected\n");
 689                 return 0;
 690         }
 691
 692         seq_printf(m, "Time: %ld s %ld us\n", error->time.tv_sec,
 693                    error->time.tv_usec);
 694         seq_printf(m, "PCI ID: 0x%04x\n", dev->pci_device);
 695         seq_printf(m, "EIR: 0x%08x\n", error->eir);
 696         seq_printf(m, "IER: 0x%08x\n", error->ier);
 697         seq_printf(m, "PGTBL_ER: 0x%08x\n", error->pgtbl_er);
 698         seq_printf(m, "CCID: 0x%08x\n", error->ccid);
 699
 700         for (i = 0; i < dev_priv->num_fence_regs; i++)
 701                 seq_printf(m, "  fence[%d] = %08llx\n", i, error->fence[i]);
 702
 703         for (i = 0; i < ARRAY_SIZE(error->extra_instdone); i++)
 704                 seq_printf(m, "  INSTDONE_%d: 0x%08x\n", i, error->extra_instdone[i]);
 705
 706         if (INTEL_INFO(dev)->gen >= 6) {
 707                 seq_printf(m, "ERROR: 0x%08x\n", error->error);
 708                 seq_printf(m, "DONE_REG: 0x%08x\n", error->done_reg);
 709         }
 710
 711         if (INTEL_INFO(dev)->gen == 7)
 712                 seq_printf(m, "ERR_INT: 0x%08x\n", error->err_int);
 713
 714         for_each_ring(ring, dev_priv, i)
 715                 i915_ring_error_state(m, dev, error, i);
 716
 717         if (error->active_bo)
 718                 print_error_buffers(m, "Active",
 719                                     error->active_bo,
 720                                     error->active_bo_count);
 721
 722         if (error->pinned_bo)
 723                 print_error_buffers(m, "Pinned",
 724                                     error->pinned_bo,
 725                                     error->pinned_bo_count);
 726
 727         for (i = 0; i < ARRAY_SIZE(error->ring); i++) {
 728                 struct drm_i915_error_object *obj;
 729
 730                 if ((obj = error->ring[i].batchbuffer)) {
 731                         seq_printf(m, "%s --- gtt_offset = 0x%08x\n",
 732                                    dev_priv->ring[i].name,
 733                                    obj->gtt_offset);
 734                         offset = 0;
 735                         for (page = 0; page < obj->page_count; page++) {
 736                                 for (elt = 0; elt < PAGE_SIZE/4; elt++) {
 737                                         seq_printf(m, "%08x :  %08x\n", offset, obj->pages[page][elt]);
 738                                         offset += 4;
 739                                 }
 740                         }
 741                 }
 742
 743                 if (error->ring[i].num_requests) {
 744                         seq_printf(m, "%s --- %d requests\n",
 745                                    dev_priv->ring[i].name,
 746                                    error->ring[i].num_requests);
 747                         for (j = 0; j < error->ring[i].num_requests; j++) {
 748                                 seq_printf(m, "  seqno 0x%08x, emitted %ld, tail 0x%08x\n",
 749                                            error->ring[i].requests[j].seqno,
 750                                            error->ring[i].requests[j].jiffies,
 751                                            error->ring[i].requests[j].tail);
 752                         }
 753                 }
 754
 755                 if ((obj = error->ring[i].ringbuffer)) {
 756                         seq_printf(m, "%s --- ringbuffer = 0x%08x\n",
 757                                    dev_priv->ring[i].name,
 758                                    obj->gtt_offset);
 759                         offset = 0;
 760                         for (page = 0; page < obj->page_count; page++) {
 761                                 for (elt = 0; elt < PAGE_SIZE/4; elt++) {
 762                                         seq_printf(m, "%08x :  %08x\n",
 763                                                    offset,
 764                                                    obj->pages[page][elt]);
 765                                         offset += 4;
 766                                 }
 767                         }
 768                 }
 769         }
 770
 771         if (error->overlay)
 772                 intel_overlay_print_error_state(m, error->overlay);
 773
 774         if (error->display)
 775                 intel_display_print_error_state(m, dev, error->display);
 776
 777         return 0;
 778 }
 779
 780 static ssize_t
 781 i915_error_state_write(struct file *filp,
 782                        const char __user *ubuf,
 783                        size_t cnt,
 784                        loff_t *ppos)
 785 {
 786         struct seq_file *m = filp->private_data;
 787         struct i915_error_state_file_priv *error_priv = m->private;
 788         struct drm_device *dev = error_priv->dev;
 789         int ret;
 790
 791         DRM_DEBUG_DRIVER("Resetting error state\n");
 792
 793         ret = mutex_lock_interruptible(&dev->struct_mutex);
 794         if (ret)
 795                 return ret;
 796
 797         i915_destroy_error_state(dev);
 798         mutex_unlock(&dev->struct_mutex);
 799
 800         return cnt;
 801 }
 802
 803 static int i915_error_state_open(struct inode *inode, struct file *file)
 804 {
 805         struct drm_device *dev = inode->i_private;
 806         drm_i915_private_t *dev_priv = dev->dev_private;
 807         struct i915_error_state_file_priv *error_priv;
 808         unsigned long flags;
 809
 810         error_priv = kzalloc(sizeof(*error_priv), GFP_KERNEL);
 811         if (!error_priv)
 812                 return -ENOMEM;
 813
 814         error_priv->dev = dev;
 815
 816         spin_lock_irqsave(&dev_priv->error_lock, flags);
 817         error_priv->error = dev_priv->first_error;
 818         if (error_priv->error)
 819                 kref_get(&error_priv->error->ref);
 820         spin_unlock_irqrestore(&dev_priv->error_lock, flags);
 821
 822         return single_open(file, i915_error_state, error_priv);
 823 }
 824
 825 static int i915_error_state_release(struct inode *inode, struct file *file)
 826 {
 827         struct seq_file *m = file->private_data;
 828         struct i915_error_state_file_priv *error_priv = m->private;
 829
 830         if (error_priv->error)
 831                 kref_put(&error_priv->error->ref, i915_error_state_free);
 832         kfree(error_priv);
 833
 834         return single_release(inode, file);
 835 }
 836
 837 static const struct file_operations i915_error_state_fops = {
 838         .owner = THIS_MODULE,
 839         .open = i915_error_state_open,
 840         .read = seq_read,
 841         .write = i915_error_state_write,
 842         .llseek = default_llseek,
 843         .release = i915_error_state_release,
 844 };
 845
 846 static ssize_t
 847 i915_next_seqno_read(struct file *filp,
 848                  char __user *ubuf,
 849                  size_t max,
 850                  loff_t *ppos)
 851 {
 852         struct drm_device *dev = filp->private_data;
 853         drm_i915_private_t *dev_priv = dev->dev_private;
 854         char buf[80];
 855         int len;
 856         int ret;
 857
 858         ret = mutex_lock_interruptible(&dev->struct_mutex);
 859         if (ret)
 860                 return ret;
 861
 862         len = snprintf(buf, sizeof(buf),
 863                        "next_seqno :  0x%x\n",
 864                        dev_priv->next_seqno);
 865
 866         mutex_unlock(&dev->struct_mutex);
 867
 868         if (len > sizeof(buf))
 869                 len = sizeof(buf);
 870
 871         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
 872 }
 873
 874 static ssize_t
 875 i915_next_seqno_write(struct file *filp,
 876                       const char __user *ubuf,
 877                       size_t cnt,
 878                       loff_t *ppos)
 879 {
 880         struct drm_device *dev = filp->private_data;
 881         char buf[20];
 882         u32 val = 1;
 883         int ret;
 884
 885         if (cnt > 0) {
 886                 if (cnt > sizeof(buf) - 1)
 887                         return -EINVAL;
 888
 889                 if (copy_from_user(buf, ubuf, cnt))
 890                         return -EFAULT;
 891                 buf[cnt] = 0;
 892
 893                 ret = kstrtouint(buf, 0, &val);
 894                 if (ret < 0)
 895                         return ret;
 896         }
 897
 898         ret = mutex_lock_interruptible(&dev->struct_mutex);
 899         if (ret)
 900                 return ret;
 901
 902         ret = i915_gem_set_seqno(dev, val);
 903
 904         mutex_unlock(&dev->struct_mutex);
 905
 906         return ret ?: cnt;
 907 }
 908
 909 static const struct file_operations i915_next_seqno_fops = {
 910         .owner = THIS_MODULE,
 911         .open = simple_open,
 912         .read = i915_next_seqno_read,
 913         .write = i915_next_seqno_write,
 914         .llseek = default_llseek,
 915 };
 916
 917 static int i915_rstdby_delays(struct seq_file *m, void *unused)
 918 {
 919         struct drm_info_node *node = (struct drm_info_node *) m->private;
 920         struct drm_device *dev = node->minor->dev;
 921         drm_i915_private_t *dev_priv = dev->dev_private;
 922         u16 crstanddelay;
 923         int ret;
 924
 925         ret = mutex_lock_interruptible(&dev->struct_mutex);
 926         if (ret)
 927                 return ret;
 928
 929         crstanddelay = I915_READ16(CRSTANDVID);
 930
 931         mutex_unlock(&dev->struct_mutex);
 932
 933         seq_printf(m, "w/ctx: %d, w/o ctx: %d\n", (crstanddelay >> 8) & 0x3f, (crstanddelay & 0x3f));
 934
 935         return 0;
 936 }
 937
 938 static int i915_cur_delayinfo(struct seq_file *m, void *unused)
 939 {
 940         struct drm_info_node *node = (struct drm_info_node *) m->private;
 941         struct drm_device *dev = node->minor->dev;
 942         drm_i915_private_t *dev_priv = dev->dev_private;
 943         int ret;
 944
 945         if (IS_GEN5(dev)) {
 946                 u16 rgvswctl = I915_READ16(MEMSWCTL);
 947                 u16 rgvstat = I915_READ16(MEMSTAT_ILK);
 948
 949                 seq_printf(m, "Requested P-state: %d\n", (rgvswctl >> 8) & 0xf);
 950                 seq_printf(m, "Requested VID: %d\n", rgvswctl & 0x3f);
 951                 seq_printf(m, "Current VID: %d\n", (rgvstat & MEMSTAT_VID_MASK) >>
 952                            MEMSTAT_VID_SHIFT);
 953                 seq_printf(m, "Current P-state: %d\n",
 954                            (rgvstat & MEMSTAT_PSTATE_MASK) >> MEMSTAT_PSTATE_SHIFT);
 955         } else if (IS_GEN6(dev) || IS_GEN7(dev)) {
 956                 u32 gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
 957                 u32 rp_state_limits = I915_READ(GEN6_RP_STATE_LIMITS);
 958                 u32 rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
 959                 u32 rpstat;
 960                 u32 rpupei, rpcurup, rpprevup;
 961                 u32 rpdownei, rpcurdown, rpprevdown;
 962                 int max_freq;
 963
 964                 /* RPSTAT1 is in the GT power well */
 965                 ret = mutex_lock_interruptible(&dev->struct_mutex);
 966                 if (ret)
 967                         return ret;
 968
 969                 gen6_gt_force_wake_get(dev_priv);
 970
 971                 rpstat = I915_READ(GEN6_RPSTAT1);
 972                 rpupei = I915_READ(GEN6_RP_CUR_UP_EI);
 973                 rpcurup = I915_READ(GEN6_RP_CUR_UP);
 974                 rpprevup = I915_READ(GEN6_RP_PREV_UP);
 975                 rpdownei = I915_READ(GEN6_RP_CUR_DOWN_EI);
 976                 rpcurdown = I915_READ(GEN6_RP_CUR_DOWN);
 977                 rpprevdown = I915_READ(GEN6_RP_PREV_DOWN);
 978
 979                 gen6_gt_force_wake_put(dev_priv);
 980                 mutex_unlock(&dev->struct_mutex);
 981
 982                 seq_printf(m, "GT_PERF_STATUS: 0x%08x\n", gt_perf_status);
 983                 seq_printf(m, "RPSTAT1: 0x%08x\n", rpstat);
 984                 seq_printf(m, "Render p-state ratio: %d\n",
 985                            (gt_perf_status & 0xff00) >> 8);
 986                 seq_printf(m, "Render p-state VID: %d\n",
 987                            gt_perf_status & 0xff);
 988                 seq_printf(m, "Render p-state limit: %d\n",
 989                            rp_state_limits & 0xff);
 990                 seq_printf(m, "CAGF: %dMHz\n", ((rpstat & GEN6_CAGF_MASK) >>
 991                                                 GEN6_CAGF_SHIFT) * GT_FREQUENCY_MULTIPLIER);
 992                 seq_printf(m, "RP CUR UP EI: %dus\n", rpupei &
 993                            GEN6_CURICONT_MASK);
 994                 seq_printf(m, "RP CUR UP: %dus\n", rpcurup &
 995                            GEN6_CURBSYTAVG_MASK);
 996                 seq_printf(m, "RP PREV UP: %dus\n", rpprevup &
 997                            GEN6_CURBSYTAVG_MASK);
 998                 seq_printf(m, "RP CUR DOWN EI: %dus\n", rpdownei &
 999                            GEN6_CURIAVG_MASK);
1000                 seq_printf(m, "RP CUR DOWN: %dus\n", rpcurdown &
1001                            GEN6_CURBSYTAVG_MASK);
1002                 seq_printf(m, "RP PREV DOWN: %dus\n", rpprevdown &
1003                            GEN6_CURBSYTAVG_MASK);
1004
1005                 max_freq = (rp_state_cap & 0xff0000) >> 16;
1006                 seq_printf(m, "Lowest (RPN) frequency: %dMHz\n",
1007                            max_freq * GT_FREQUENCY_MULTIPLIER);
1008
1009                 max_freq = (rp_state_cap & 0xff00) >> 8;
1010                 seq_printf(m, "Nominal (RP1) frequency: %dMHz\n",
1011                            max_freq * GT_FREQUENCY_MULTIPLIER);
1012
1013                 max_freq = rp_state_cap & 0xff;
1014                 seq_printf(m, "Max non-overclocked (RP0) frequency: %dMHz\n",
1015                            max_freq * GT_FREQUENCY_MULTIPLIER);
1016         } else {
1017                 seq_printf(m, "no P-state info available\n");
1018         }
1019
1020         return 0;
1021 }
1022
1023 static int i915_delayfreq_table(struct seq_file *m, void *unused)
1024 {
1025         struct drm_info_node *node = (struct drm_info_node *) m->private;
1026         struct drm_device *dev = node->minor->dev;
1027         drm_i915_private_t *dev_priv = dev->dev_private;
1028         u32 delayfreq;
1029         int ret, i;
1030
1031         ret = mutex_lock_interruptible(&dev->struct_mutex);
1032         if (ret)
1033                 return ret;
1034
1035         for (i = 0; i < 16; i++) {
1036                 delayfreq = I915_READ(PXVFREQ_BASE + i * 4);
1037                 seq_printf(m, "P%02dVIDFREQ: 0x%08x (VID: %d)\n", i, delayfreq,
1038                            (delayfreq & PXVFREQ_PX_MASK) >> PXVFREQ_PX_SHIFT);
1039         }
1040
1041         mutex_unlock(&dev->struct_mutex);
1042
1043         return 0;
1044 }
1045
1046 static inline int MAP_TO_MV(int map)
1047 {
1048         return 1250 - (map * 25);
1049 }
1050
1051 static int i915_inttoext_table(struct seq_file *m, void *unused)
1052 {
1053         struct drm_info_node *node = (struct drm_info_node *) m->private;
1054         struct drm_device *dev = node->minor->dev;
1055         drm_i915_private_t *dev_priv = dev->dev_private;
1056         u32 inttoext;
1057         int ret, i;
1058
1059         ret = mutex_lock_interruptible(&dev->struct_mutex);
1060         if (ret)
1061                 return ret;
1062
1063         for (i = 1; i <= 32; i++) {
1064                 inttoext = I915_READ(INTTOEXT_BASE_ILK + i * 4);
1065                 seq_printf(m, "INTTOEXT%02d: 0x%08x\n", i, inttoext);
1066         }
1067
1068         mutex_unlock(&dev->struct_mutex);
1069
1070         return 0;
1071 }
1072
1073 static int ironlake_drpc_info(struct seq_file *m)
1074 {
1075         struct drm_info_node *node = (struct drm_info_node *) m->private;
1076         struct drm_device *dev = node->minor->dev;
1077         drm_i915_private_t *dev_priv = dev->dev_private;
1078         u32 rgvmodectl, rstdbyctl;
1079         u16 crstandvid;
1080         int ret;
1081
1082         ret = mutex_lock_interruptible(&dev->struct_mutex);
1083         if (ret)
1084                 return ret;
1085
1086         rgvmodectl = I915_READ(MEMMODECTL);
1087         rstdbyctl = I915_READ(RSTDBYCTL);
1088         crstandvid = I915_READ16(CRSTANDVID);
1089
1090         mutex_unlock(&dev->struct_mutex);
1091
1092         seq_printf(m, "HD boost: %s\n", (rgvmodectl & MEMMODE_BOOST_EN) ?
1093                    "yes" : "no");
1094         seq_printf(m, "Boost freq: %d\n",
1095                    (rgvmodectl & MEMMODE_BOOST_FREQ_MASK) >>
1096                    MEMMODE_BOOST_FREQ_SHIFT);
1097         seq_printf(m, "HW control enabled: %s\n",
1098                    rgvmodectl & MEMMODE_HWIDLE_EN ? "yes" : "no");
1099         seq_printf(m, "SW control enabled: %s\n",
1100                    rgvmodectl & MEMMODE_SWMODE_EN ? "yes" : "no");
1101         seq_printf(m, "Gated voltage change: %s\n",
1102                    rgvmodectl & MEMMODE_RCLK_GATE ? "yes" : "no");
1103         seq_printf(m, "Starting frequency: P%d\n",
1104                    (rgvmodectl & MEMMODE_FSTART_MASK) >> MEMMODE_FSTART_SHIFT);
1105         seq_printf(m, "Max P-state: P%d\n",
1106                    (rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT);
1107         seq_printf(m, "Min P-state: P%d\n", (rgvmodectl & MEMMODE_FMIN_MASK));
1108         seq_printf(m, "RS1 VID: %d\n", (crstandvid & 0x3f));
1109         seq_printf(m, "RS2 VID: %d\n", ((crstandvid >> 8) & 0x3f));
1110         seq_printf(m, "Render standby enabled: %s\n",
1111                    (rstdbyctl & RCX_SW_EXIT) ? "no" : "yes");
1112         seq_printf(m, "Current RS state: ");
1113         switch (rstdbyctl & RSX_STATUS_MASK) {
1114         case RSX_STATUS_ON:
1115                 seq_printf(m, "on\n");
1116                 break;
1117         case RSX_STATUS_RC1:
1118                 seq_printf(m, "RC1\n");
1119                 break;
1120         case RSX_STATUS_RC1E:
1121                 seq_printf(m, "RC1E\n");
1122                 break;
1123         case RSX_STATUS_RS1:
1124                 seq_printf(m, "RS1\n");
1125                 break;
1126         case RSX_STATUS_RS2:
1127                 seq_printf(m, "RS2 (RC6)\n");
1128                 break;
1129         case RSX_STATUS_RS3:
1130                 seq_printf(m, "RC3 (RC6+)\n");
1131                 break;
1132         default:
1133                 seq_printf(m, "unknown\n");
1134                 break;
1135         }
1136
1137         return 0;
1138 }
1139
1140 static int gen6_drpc_info(struct seq_file *m)
1141 {
1142
1143         struct drm_info_node *node = (struct drm_info_node *) m->private;
1144         struct drm_device *dev = node->minor->dev;
1145         struct drm_i915_private *dev_priv = dev->dev_private;
1146         u32 rpmodectl1, gt_core_status, rcctl1, rc6vids = 0;
1147         unsigned forcewake_count;
1148         int count=0, ret;
1149
1150
1151         ret = mutex_lock_interruptible(&dev->struct_mutex);
1152         if (ret)
1153                 return ret;
1154
1155         spin_lock_irq(&dev_priv->gt_lock);
1156         forcewake_count = dev_priv->forcewake_count;
1157         spin_unlock_irq(&dev_priv->gt_lock);
1158
1159         if (forcewake_count) {
1160                 seq_printf(m, "RC information inaccurate because somebody "
1161                               "holds a forcewake reference \n");
1162         } else {
1163                 /* NB: we cannot use forcewake, else we read the wrong values */
1164                 while (count++ < 50 && (I915_READ_NOTRACE(FORCEWAKE_ACK) & 1))
1165                         udelay(10);
1166                 seq_printf(m, "RC information accurate: %s\n", yesno(count < 51));
1167         }
1168
1169         gt_core_status = readl(dev_priv->regs + GEN6_GT_CORE_STATUS);
1170         trace_i915_reg_rw(false, GEN6_GT_CORE_STATUS, gt_core_status, 4);
1171
1172         rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
1173         rcctl1 = I915_READ(GEN6_RC_CONTROL);
1174         mutex_unlock(&dev->struct_mutex);
1175         mutex_lock(&dev_priv->rps.hw_lock);
1176         sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS, &rc6vids);
1177         mutex_unlock(&dev_priv->rps.hw_lock);
1178
1179         seq_printf(m, "Video Turbo Mode: %s\n",
1180                    yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
1181         seq_printf(m, "HW control enabled: %s\n",
1182                    yesno(rpmodectl1 & GEN6_RP_ENABLE));
1183         seq_printf(m, "SW control enabled: %s\n",
1184                    yesno((rpmodectl1 & GEN6_RP_MEDIA_MODE_MASK) ==
1185                           GEN6_RP_MEDIA_SW_MODE));
1186         seq_printf(m, "RC1e Enabled: %s\n",
1187                    yesno(rcctl1 & GEN6_RC_CTL_RC1e_ENABLE));
1188         seq_printf(m, "RC6 Enabled: %s\n",
1189                    yesno(rcctl1 & GEN6_RC_CTL_RC6_ENABLE));
1190         seq_printf(m, "Deep RC6 Enabled: %s\n",
1191                    yesno(rcctl1 & GEN6_RC_CTL_RC6p_ENABLE));
1192         seq_printf(m, "Deepest RC6 Enabled: %s\n",
1193                    yesno(rcctl1 & GEN6_RC_CTL_RC6pp_ENABLE));
1194         seq_printf(m, "Current RC state: ");
1195         switch (gt_core_status & GEN6_RCn_MASK) {
1196         case GEN6_RC0:
1197                 if (gt_core_status & GEN6_CORE_CPD_STATE_MASK)
1198                         seq_printf(m, "Core Power Down\n");
1199                 else
1200                         seq_printf(m, "on\n");
1201                 break;
1202         case GEN6_RC3:
1203                 seq_printf(m, "RC3\n");
1204                 break;
1205         case GEN6_RC6:
1206                 seq_printf(m, "RC6\n");
1207                 break;
1208         case GEN6_RC7:
1209                 seq_printf(m, "RC7\n");
1210                 break;
1211         default:
1212                 seq_printf(m, "Unknown\n");
1213                 break;
1214         }
1215
1216         seq_printf(m, "Core Power Down: %s\n",
1217                    yesno(gt_core_status & GEN6_CORE_CPD_STATE_MASK));
1218
1219         /* Not exactly sure what this is */
1220         seq_printf(m, "RC6 \"Locked to RPn\" residency since boot: %u\n",
1221                    I915_READ(GEN6_GT_GFX_RC6_LOCKED));
1222         seq_printf(m, "RC6 residency since boot: %u\n",
1223                    I915_READ(GEN6_GT_GFX_RC6));
1224         seq_printf(m, "RC6+ residency since boot: %u\n",
1225                    I915_READ(GEN6_GT_GFX_RC6p));
1226         seq_printf(m, "RC6++ residency since boot: %u\n",
1227                    I915_READ(GEN6_GT_GFX_RC6pp));
1228
1229         seq_printf(m, "RC6   voltage: %dmV\n",
1230                    GEN6_DECODE_RC6_VID(((rc6vids >> 0) & 0xff)));
1231         seq_printf(m, "RC6+  voltage: %dmV\n",
1232                    GEN6_DECODE_RC6_VID(((rc6vids >> 8) & 0xff)));
1233         seq_printf(m, "RC6++ voltage: %dmV\n",
1234                    GEN6_DECODE_RC6_VID(((rc6vids >> 16) & 0xff)));
1235         return 0;
1236 }
1237
1238 static int i915_drpc_info(struct seq_file *m, void *unused)
1239 {
1240         struct drm_info_node *node = (struct drm_info_node *) m->private;
1241         struct drm_device *dev = node->minor->dev;
1242
1243         if (IS_GEN6(dev) || IS_GEN7(dev))
1244                 return gen6_drpc_info(m);
1245         else
1246                 return ironlake_drpc_info(m);
1247 }
1248
1249 static int i915_fbc_status(struct seq_file *m, void *unused)
1250 {
1251         struct drm_info_node *node = (struct drm_info_node *) m->private;
1252         struct drm_device *dev = node->minor->dev;
1253         drm_i915_private_t *dev_priv = dev->dev_private;
1254
1255         if (!I915_HAS_FBC(dev)) {
1256                 seq_printf(m, "FBC unsupported on this chipset\n");
1257                 return 0;
1258         }
1259
1260         if (intel_fbc_enabled(dev)) {
1261                 seq_printf(m, "FBC enabled\n");
1262         } else {
1263                 seq_printf(m, "FBC disabled: ");
1264                 switch (dev_priv->no_fbc_reason) {
1265                 case FBC_NO_OUTPUT:
1266                         seq_printf(m, "no outputs");
1267                         break;
1268                 case FBC_STOLEN_TOO_SMALL:
1269                         seq_printf(m, "not enough stolen memory");
1270                         break;
1271                 case FBC_UNSUPPORTED_MODE:
1272                         seq_printf(m, "mode not supported");
1273                         break;
1274                 case FBC_MODE_TOO_LARGE:
1275                         seq_printf(m, "mode too large");
1276                         break;
1277                 case FBC_BAD_PLANE:
1278                         seq_printf(m, "FBC unsupported on plane");
1279                         break;
1280                 case FBC_NOT_TILED:
1281                         seq_printf(m, "scanout buffer not tiled");
1282                         break;
1283                 case FBC_MULTIPLE_PIPES:
1284                         seq_printf(m, "multiple pipes are enabled");
1285                         break;
1286                 case FBC_MODULE_PARAM:
1287                         seq_printf(m, "disabled per module param (default off)");
1288                         break;
1289                 default:
1290                         seq_printf(m, "unknown reason");
1291                 }
1292                 seq_printf(m, "\n");
1293         }
1294         return 0;
1295 }
1296
1297 static int i915_sr_status(struct seq_file *m, void *unused)
1298 {
1299         struct drm_info_node *node = (struct drm_info_node *) m->private;
1300         struct drm_device *dev = node->minor->dev;
1301         drm_i915_private_t *dev_priv = dev->dev_private;
1302         bool sr_enabled = false;
1303
1304         if (HAS_PCH_SPLIT(dev))
1305                 sr_enabled = I915_READ(WM1_LP_ILK) & WM1_LP_SR_EN;
1306         else if (IS_CRESTLINE(dev) || IS_I945G(dev) || IS_I945GM(dev))
1307                 sr_enabled = I915_READ(FW_BLC_SELF) & FW_BLC_SELF_EN;
1308         else if (IS_I915GM(dev))
1309                 sr_enabled = I915_READ(INSTPM) & INSTPM_SELF_EN;
1310         else if (IS_PINEVIEW(dev))
1311                 sr_enabled = I915_READ(DSPFW3) & PINEVIEW_SELF_REFRESH_EN;
1312
1313         seq_printf(m, "self-refresh: %s\n",
1314                    sr_enabled ? "enabled" : "disabled");
1315
1316         return 0;
1317 }
1318
1319 static int i915_emon_status(struct seq_file *m, void *unused)
1320 {
1321         struct drm_info_node *node = (struct drm_info_node *) m->private;
1322         struct drm_device *dev = node->minor->dev;
1323         drm_i915_private_t *dev_priv = dev->dev_private;
1324         unsigned long temp, chipset, gfx;
1325         int ret;
1326
1327         if (!IS_GEN5(dev))
1328                 return -ENODEV;
1329
1330         ret = mutex_lock_interruptible(&dev->struct_mutex);
1331         if (ret)
1332                 return ret;
1333
1334         temp = i915_mch_val(dev_priv);
1335         chipset = i915_chipset_val(dev_priv);
1336         gfx = i915_gfx_val(dev_priv);
1337         mutex_unlock(&dev->struct_mutex);
1338
1339         seq_printf(m, "GMCH temp: %ld\n", temp);
1340         seq_printf(m, "Chipset power: %ld\n", chipset);
1341         seq_printf(m, "GFX power: %ld\n", gfx);
1342         seq_printf(m, "Total power: %ld\n", chipset + gfx);
1343
1344         return 0;
1345 }
1346
1347 static int i915_ring_freq_table(struct seq_file *m, void *unused)
1348 {
1349         struct drm_info_node *node = (struct drm_info_node *) m->private;
1350         struct drm_device *dev = node->minor->dev;
1351         drm_i915_private_t *dev_priv = dev->dev_private;
1352         int ret;
1353         int gpu_freq, ia_freq;
1354
1355         if (!(IS_GEN6(dev) || IS_GEN7(dev))) {
1356                 seq_printf(m, "unsupported on this chipset\n");
1357                 return 0;
1358         }
1359
1360         ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
1361         if (ret)
1362                 return ret;
1363
1364         seq_printf(m, "GPU freq (MHz)\tEffective CPU freq (MHz)\n");
1365
1366         for (gpu_freq = dev_priv->rps.min_delay;
1367              gpu_freq <= dev_priv->rps.max_delay;
1368              gpu_freq++) {
1369                 ia_freq = gpu_freq;
1370                 sandybridge_pcode_read(dev_priv,
1371                                        GEN6_PCODE_READ_MIN_FREQ_TABLE,
1372                                        &ia_freq);
1373                 seq_printf(m, "%d\t\t%d\n", gpu_freq * GT_FREQUENCY_MULTIPLIER, ia_freq * 100);
1374         }
1375
1376         mutex_unlock(&dev_priv->rps.hw_lock);
1377
1378         return 0;
1379 }
1380
1381 static int i915_gfxec(struct seq_file *m, void *unused)
1382 {
1383         struct drm_info_node *node = (struct drm_info_node *) m->private;
1384         struct drm_device *dev = node->minor->dev;
1385         drm_i915_private_t *dev_priv = dev->dev_private;
1386         int ret;
1387
1388         ret = mutex_lock_interruptible(&dev->struct_mutex);
1389         if (ret)
1390                 return ret;
1391
1392         seq_printf(m, "GFXEC: %ld\n", (unsigned long)I915_READ(0x112f4));
1393
1394         mutex_unlock(&dev->struct_mutex);
1395
1396         return 0;
1397 }
1398
1399 static int i915_opregion(struct seq_file *m, void *unused)
1400 {
1401         struct drm_info_node *node = (struct drm_info_node *) m->private;
1402         struct drm_device *dev = node->minor->dev;
1403         drm_i915_private_t *dev_priv = dev->dev_private;
1404         struct intel_opregion *opregion = &dev_priv->opregion;
1405         void *data = kmalloc(OPREGION_SIZE, GFP_KERNEL);
1406         int ret;
1407
1408         if (data == NULL)
1409                 return -ENOMEM;
1410
1411         ret = mutex_lock_interruptible(&dev->struct_mutex);
1412         if (ret)
1413                 goto out;
1414
1415         if (opregion->header) {
1416                 memcpy_fromio(data, opregion->header, OPREGION_SIZE);
1417                 seq_write(m, data, OPREGION_SIZE);
1418         }
1419
1420         mutex_unlock(&dev->struct_mutex);
1421
1422 out:
1423         kfree(data);
1424         return 0;
1425 }
1426
1427 static int i915_gem_framebuffer_info(struct seq_file *m, void *data)
1428 {
1429         struct drm_info_node *node = (struct drm_info_node *) m->private;
1430         struct drm_device *dev = node->minor->dev;
1431         drm_i915_private_t *dev_priv = dev->dev_private;
1432         struct intel_fbdev *ifbdev;
1433         struct intel_framebuffer *fb;
1434         int ret;
1435
1436         ret = mutex_lock_interruptible(&dev->mode_config.mutex);
1437         if (ret)
1438                 return ret;
1439
1440         ifbdev = dev_priv->fbdev;
1441         fb = to_intel_framebuffer(ifbdev->helper.fb);
1442
1443         seq_printf(m, "fbcon size: %d x %d, depth %d, %d bpp, obj ",
1444                    fb->base.width,
1445                    fb->base.height,
1446                    fb->base.depth,
1447                    fb->base.bits_per_pixel);
1448         describe_obj(m, fb->obj);
1449         seq_printf(m, "\n");
1450
1451         list_for_each_entry(fb, &dev->mode_config.fb_list, base.head) {
1452                 if (&fb->base == ifbdev->helper.fb)
1453                         continue;
1454
1455                 seq_printf(m, "user size: %d x %d, depth %d, %d bpp, obj ",
1456                            fb->base.width,
1457                            fb->base.height,
1458                            fb->base.depth,
1459                            fb->base.bits_per_pixel);
1460                 describe_obj(m, fb->obj);
1461                 seq_printf(m, "\n");
1462         }
1463
1464         mutex_unlock(&dev->mode_config.mutex);
1465
1466         return 0;
1467 }
1468
1469 static int i915_context_status(struct seq_file *m, void *unused)
1470 {
1471         struct drm_info_node *node = (struct drm_info_node *) m->private;
1472         struct drm_device *dev = node->minor->dev;
1473         drm_i915_private_t *dev_priv = dev->dev_private;
1474         int ret;
1475
1476         ret = mutex_lock_interruptible(&dev->mode_config.mutex);
1477         if (ret)
1478                 return ret;
1479
1480         if (dev_priv->ips.pwrctx) {
1481                 seq_printf(m, "power context ");
1482                 describe_obj(m, dev_priv->ips.pwrctx);
1483                 seq_printf(m, "\n");
1484         }
1485
1486         if (dev_priv->ips.renderctx) {
1487                 seq_printf(m, "render context ");
1488                 describe_obj(m, dev_priv->ips.renderctx);
1489                 seq_printf(m, "\n");
1490         }
1491
1492         mutex_unlock(&dev->mode_config.mutex);
1493
1494         return 0;
1495 }
1496
1497 static int i915_gen6_forcewake_count_info(struct seq_file *m, void *data)
1498 {
1499         struct drm_info_node *node = (struct drm_info_node *) m->private;
1500         struct drm_device *dev = node->minor->dev;
1501         struct drm_i915_private *dev_priv = dev->dev_private;
1502         unsigned forcewake_count;
1503
1504         spin_lock_irq(&dev_priv->gt_lock);
1505         forcewake_count = dev_priv->forcewake_count;
1506         spin_unlock_irq(&dev_priv->gt_lock);
1507
1508         seq_printf(m, "forcewake count = %u\n", forcewake_count);
1509
1510         return 0;
1511 }
1512
1513 static const char *swizzle_string(unsigned swizzle)
1514 {
1515         switch(swizzle) {
1516         case I915_BIT_6_SWIZZLE_NONE:
1517                 return "none";
1518         case I915_BIT_6_SWIZZLE_9:
1519                 return "bit9";
1520         case I915_BIT_6_SWIZZLE_9_10:
1521                 return "bit9/bit10";
1522         case I915_BIT_6_SWIZZLE_9_11:
1523                 return "bit9/bit11";
1524         case I915_BIT_6_SWIZZLE_9_10_11:
1525                 return "bit9/bit10/bit11";
1526         case I915_BIT_6_SWIZZLE_9_17:
1527                 return "bit9/bit17";
1528         case I915_BIT_6_SWIZZLE_9_10_17:
1529                 return "bit9/bit10/bit17";
1530         case I915_BIT_6_SWIZZLE_UNKNOWN:
1531                 return "unkown";
1532         }
1533
1534         return "bug";
1535 }
1536
1537 static int i915_swizzle_info(struct seq_file *m, void *data)
1538 {
1539         struct drm_info_node *node = (struct drm_info_node *) m->private;
1540         struct drm_device *dev = node->minor->dev;
1541         struct drm_i915_private *dev_priv = dev->dev_private;
1542         int ret;
1543
1544         ret = mutex_lock_interruptible(&dev->struct_mutex);
1545         if (ret)
1546                 return ret;
1547
1548         seq_printf(m, "bit6 swizzle for X-tiling = %s\n",
1549                    swizzle_string(dev_priv->mm.bit_6_swizzle_x));
1550         seq_printf(m, "bit6 swizzle for Y-tiling = %s\n",
1551                    swizzle_string(dev_priv->mm.bit_6_swizzle_y));
1552
1553         if (IS_GEN3(dev) || IS_GEN4(dev)) {
1554                 seq_printf(m, "DDC = 0x%08x\n",
1555                            I915_READ(DCC));
1556                 seq_printf(m, "C0DRB3 = 0x%04x\n",
1557                            I915_READ16(C0DRB3));
1558                 seq_printf(m, "C1DRB3 = 0x%04x\n",
1559                            I915_READ16(C1DRB3));
1560         } else if (IS_GEN6(dev) || IS_GEN7(dev)) {
1561                 seq_printf(m, "MAD_DIMM_C0 = 0x%08x\n",
1562                            I915_READ(MAD_DIMM_C0));
1563                 seq_printf(m, "MAD_DIMM_C1 = 0x%08x\n",
1564                            I915_READ(MAD_DIMM_C1));
1565                 seq_printf(m, "MAD_DIMM_C2 = 0x%08x\n",
1566                            I915_READ(MAD_DIMM_C2));
1567                 seq_printf(m, "TILECTL = 0x%08x\n",
1568                            I915_READ(TILECTL));
1569                 seq_printf(m, "ARB_MODE = 0x%08x\n",
1570                            I915_READ(ARB_MODE));
1571                 seq_printf(m, "DISP_ARB_CTL = 0x%08x\n",
1572                            I915_READ(DISP_ARB_CTL));
1573         }
1574         mutex_unlock(&dev->struct_mutex);
1575
1576         return 0;
1577 }
1578
1579 static int i915_ppgtt_info(struct seq_file *m, void *data)
1580 {
1581         struct drm_info_node *node = (struct drm_info_node *) m->private;
1582         struct drm_device *dev = node->minor->dev;
1583         struct drm_i915_private *dev_priv = dev->dev_private;
1584         struct intel_ring_buffer *ring;
1585         int i, ret;
1586
1587
1588         ret = mutex_lock_interruptible(&dev->struct_mutex);
1589         if (ret)
1590                 return ret;
1591         if (INTEL_INFO(dev)->gen == 6)
1592                 seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(GFX_MODE));
1593
1594         for_each_ring(ring, dev_priv, i) {
1595                 seq_printf(m, "%s\n", ring->name);
1596                 if (INTEL_INFO(dev)->gen == 7)
1597                         seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(RING_MODE_GEN7(ring)));
1598                 seq_printf(m, "PP_DIR_BASE: 0x%08x\n", I915_READ(RING_PP_DIR_BASE(ring)));
1599                 seq_printf(m, "PP_DIR_BASE_READ: 0x%08x\n", I915_READ(RING_PP_DIR_BASE_READ(ring)));
1600                 seq_printf(m, "PP_DIR_DCLV: 0x%08x\n", I915_READ(RING_PP_DIR_DCLV(ring)));
1601         }
1602         if (dev_priv->mm.aliasing_ppgtt) {
1603                 struct i915_hw_ppgtt *ppgtt = dev_priv->mm.aliasing_ppgtt;
1604
1605                 seq_printf(m, "aliasing PPGTT:\n");
1606                 seq_printf(m, "pd gtt offset: 0x%08x\n", ppgtt->pd_offset);
1607         }
1608         seq_printf(m, "ECOCHK: 0x%08x\n", I915_READ(GAM_ECOCHK));
1609         mutex_unlock(&dev->struct_mutex);
1610
1611         return 0;
1612 }
1613
1614 static int i915_dpio_info(struct seq_file *m, void *data)
1615 {
1616         struct drm_info_node *node = (struct drm_info_node *) m->private;
1617         struct drm_device *dev = node->minor->dev;
1618         struct drm_i915_private *dev_priv = dev->dev_private;
1619         int ret;
1620
1621
1622         if (!IS_VALLEYVIEW(dev)) {
1623                 seq_printf(m, "unsupported\n");
1624                 return 0;
1625         }
1626
1627         ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
1628         if (ret)
1629                 return ret;
1630
1631         seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
1632
1633         seq_printf(m, "DPIO_DIV_A: 0x%08x\n",
1634                    intel_dpio_read(dev_priv, _DPIO_DIV_A));
1635         seq_printf(m, "DPIO_DIV_B: 0x%08x\n",
1636                    intel_dpio_read(dev_priv, _DPIO_DIV_B));
1637
1638         seq_printf(m, "DPIO_REFSFR_A: 0x%08x\n",
1639                    intel_dpio_read(dev_priv, _DPIO_REFSFR_A));
1640         seq_printf(m, "DPIO_REFSFR_B: 0x%08x\n",
1641                    intel_dpio_read(dev_priv, _DPIO_REFSFR_B));
1642
1643         seq_printf(m, "DPIO_CORE_CLK_A: 0x%08x\n",
1644                    intel_dpio_read(dev_priv, _DPIO_CORE_CLK_A));
1645         seq_printf(m, "DPIO_CORE_CLK_B: 0x%08x\n",
1646                    intel_dpio_read(dev_priv, _DPIO_CORE_CLK_B));
1647
1648         seq_printf(m, "DPIO_LFP_COEFF_A: 0x%08x\n",
1649                    intel_dpio_read(dev_priv, _DPIO_LFP_COEFF_A));
1650         seq_printf(m, "DPIO_LFP_COEFF_B: 0x%08x\n",
1651                    intel_dpio_read(dev_priv, _DPIO_LFP_COEFF_B));
1652
1653         seq_printf(m, "DPIO_FASTCLK_DISABLE: 0x%08x\n",
1654                    intel_dpio_read(dev_priv, DPIO_FASTCLK_DISABLE));
1655
1656         mutex_unlock(&dev_priv->dpio_lock);
1657
1658         return 0;
1659 }
1660
1661 static ssize_t
1662 i915_wedged_read(struct file *filp,
1663                  char __user *ubuf,
1664                  size_t max,
1665                  loff_t *ppos)
1666 {
1667         struct drm_device *dev = filp->private_data;
1668         drm_i915_private_t *dev_priv = dev->dev_private;
1669         char buf[80];
1670         int len;
1671
1672         len = snprintf(buf, sizeof(buf),
1673                        "wedged :  %d\n",
1674                        atomic_read(&dev_priv->mm.wedged));
1675
1676         if (len > sizeof(buf))
1677                 len = sizeof(buf);
1678
1679         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
1680 }
1681
1682 static ssize_t
1683 i915_wedged_write(struct file *filp,
1684                   const char __user *ubuf,
1685                   size_t cnt,
1686                   loff_t *ppos)
1687 {
1688         struct drm_device *dev = filp->private_data;
1689         char buf[20];
1690         int val = 1;
1691
1692         if (cnt > 0) {
1693                 if (cnt > sizeof(buf) - 1)
1694                         return -EINVAL;
1695
1696                 if (copy_from_user(buf, ubuf, cnt))
1697                         return -EFAULT;
1698                 buf[cnt] = 0;
1699
1700                 val = simple_strtoul(buf, NULL, 0);
1701         }
1702
1703         DRM_INFO("Manually setting wedged to %d\n", val);
1704         i915_handle_error(dev, val);
1705
1706         return cnt;
1707 }
1708
1709 static const struct file_operations i915_wedged_fops = {
1710         .owner = THIS_MODULE,
1711         .open = simple_open,
1712         .read = i915_wedged_read,
1713         .write = i915_wedged_write,
1714         .llseek = default_llseek,
1715 };
1716
1717 static ssize_t
1718 i915_ring_stop_read(struct file *filp,
1719                     char __user *ubuf,
1720                     size_t max,
1721                     loff_t *ppos)
1722 {
1723         struct drm_device *dev = filp->private_data;
1724         drm_i915_private_t *dev_priv = dev->dev_private;
1725         char buf[20];
1726         int len;
1727
1728         len = snprintf(buf, sizeof(buf),
1729                        "0x%08x\n", dev_priv->stop_rings);
1730
1731         if (len > sizeof(buf))
1732                 len = sizeof(buf);
1733
1734         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
1735 }
1736
1737 static ssize_t
1738 i915_ring_stop_write(struct file *filp,
1739                      const char __user *ubuf,
1740                      size_t cnt,
1741                      loff_t *ppos)
1742 {
1743         struct drm_device *dev = filp->private_data;
1744         struct drm_i915_private *dev_priv = dev->dev_private;
1745         char buf[20];
1746         int val = 0, ret;
1747
1748         if (cnt > 0) {
1749                 if (cnt > sizeof(buf) - 1)
1750                         return -EINVAL;
1751
1752                 if (copy_from_user(buf, ubuf, cnt))
1753                         return -EFAULT;
1754                 buf[cnt] = 0;
1755
1756                 val = simple_strtoul(buf, NULL, 0);
1757         }
1758
1759         DRM_DEBUG_DRIVER("Stopping rings 0x%08x\n", val);
1760
1761         ret = mutex_lock_interruptible(&dev->struct_mutex);
1762         if (ret)
1763                 return ret;
1764
1765         dev_priv->stop_rings = val;
1766         mutex_unlock(&dev->struct_mutex);
1767
1768         return cnt;
1769 }
1770
1771 static const struct file_operations i915_ring_stop_fops = {
1772         .owner = THIS_MODULE,
1773         .open = simple_open,
1774         .read = i915_ring_stop_read,
1775         .write = i915_ring_stop_write,
1776         .llseek = default_llseek,
1777 };
1778
1779 static ssize_t
1780 i915_max_freq_read(struct file *filp,
1781                    char __user *ubuf,
1782                    size_t max,
1783                    loff_t *ppos)
1784 {
1785         struct drm_device *dev = filp->private_data;
1786         drm_i915_private_t *dev_priv = dev->dev_private;
1787         char buf[80];
1788         int len, ret;
1789
1790         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1791                 return -ENODEV;
1792
1793         ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
1794         if (ret)
1795                 return ret;
1796
1797         len = snprintf(buf, sizeof(buf),
1798                        "max freq: %d\n", dev_priv->rps.max_delay * GT_FREQUENCY_MULTIPLIER);
1799         mutex_unlock(&dev_priv->rps.hw_lock);
1800
1801         if (len > sizeof(buf))
1802                 len = sizeof(buf);
1803
1804         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
1805 }
1806
1807 static ssize_t
1808 i915_max_freq_write(struct file *filp,
1809                   const char __user *ubuf,
1810                   size_t cnt,
1811                   loff_t *ppos)
1812 {
1813         struct drm_device *dev = filp->private_data;
1814         struct drm_i915_private *dev_priv = dev->dev_private;
1815         char buf[20];
1816         int val = 1, ret;
1817
1818         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1819                 return -ENODEV;
1820
1821         if (cnt > 0) {
1822                 if (cnt > sizeof(buf) - 1)
1823                         return -EINVAL;
1824
1825                 if (copy_from_user(buf, ubuf, cnt))
1826                         return -EFAULT;
1827                 buf[cnt] = 0;
1828
1829                 val = simple_strtoul(buf, NULL, 0);
1830         }
1831
1832         DRM_DEBUG_DRIVER("Manually setting max freq to %d\n", val);
1833
1834         ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
1835         if (ret)
1836                 return ret;
1837
1838         /*
1839          * Turbo will still be enabled, but won't go above the set value.
1840          */
1841         dev_priv->rps.max_delay = val / GT_FREQUENCY_MULTIPLIER;
1842
1843         gen6_set_rps(dev, val / GT_FREQUENCY_MULTIPLIER);
1844         mutex_unlock(&dev_priv->rps.hw_lock);
1845
1846         return cnt;
1847 }
1848
1849 static const struct file_operations i915_max_freq_fops = {
1850         .owner = THIS_MODULE,
1851         .open = simple_open,
1852         .read = i915_max_freq_read,
1853         .write = i915_max_freq_write,
1854         .llseek = default_llseek,
1855 };
1856
1857 static ssize_t
1858 i915_min_freq_read(struct file *filp, char __user *ubuf, size_t max,
1859                    loff_t *ppos)
1860 {
1861         struct drm_device *dev = filp->private_data;
1862         drm_i915_private_t *dev_priv = dev->dev_private;
1863         char buf[80];
1864         int len, ret;
1865
1866         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1867                 return -ENODEV;
1868
1869         ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
1870         if (ret)
1871                 return ret;
1872
1873         len = snprintf(buf, sizeof(buf),
1874                        "min freq: %d\n", dev_priv->rps.min_delay * GT_FREQUENCY_MULTIPLIER);
1875         mutex_unlock(&dev_priv->rps.hw_lock);
1876
1877         if (len > sizeof(buf))
1878                 len = sizeof(buf);
1879
1880         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
1881 }
1882
1883 static ssize_t
1884 i915_min_freq_write(struct file *filp, const char __user *ubuf, size_t cnt,
1885                     loff_t *ppos)
1886 {
1887         struct drm_device *dev = filp->private_data;
1888         struct drm_i915_private *dev_priv = dev->dev_private;
1889         char buf[20];
1890         int val = 1, ret;
1891
1892         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1893                 return -ENODEV;
1894
1895         if (cnt > 0) {
1896                 if (cnt > sizeof(buf) - 1)
1897                         return -EINVAL;
1898
1899                 if (copy_from_user(buf, ubuf, cnt))
1900                         return -EFAULT;
1901                 buf[cnt] = 0;
1902
1903                 val = simple_strtoul(buf, NULL, 0);
1904         }
1905
1906         DRM_DEBUG_DRIVER("Manually setting min freq to %d\n", val);
1907
1908         ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
1909         if (ret)
1910                 return ret;
1911
1912         /*
1913          * Turbo will still be enabled, but won't go below the set value.
1914          */
1915         dev_priv->rps.min_delay = val / GT_FREQUENCY_MULTIPLIER;
1916
1917         gen6_set_rps(dev, val / GT_FREQUENCY_MULTIPLIER);
1918         mutex_unlock(&dev_priv->rps.hw_lock);
1919
1920         return cnt;
1921 }
1922
1923 static const struct file_operations i915_min_freq_fops = {
1924         .owner = THIS_MODULE,
1925         .open = simple_open,
1926         .read = i915_min_freq_read,
1927         .write = i915_min_freq_write,
1928         .llseek = default_llseek,
1929 };
1930
1931 static ssize_t
1932 i915_cache_sharing_read(struct file *filp,
1933                    char __user *ubuf,
1934                    size_t max,
1935                    loff_t *ppos)
1936 {
1937         struct drm_device *dev = filp->private_data;
1938         drm_i915_private_t *dev_priv = dev->dev_private;
1939         char buf[80];
1940         u32 snpcr;
1941         int len, ret;
1942
1943         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1944                 return -ENODEV;
1945
1946         ret = mutex_lock_interruptible(&dev->struct_mutex);
1947         if (ret)
1948                 return ret;
1949
1950         snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
1951         mutex_unlock(&dev_priv->dev->struct_mutex);
1952
1953         len = snprintf(buf, sizeof(buf),
1954                        "%d\n", (snpcr & GEN6_MBC_SNPCR_MASK) >>
1955                        GEN6_MBC_SNPCR_SHIFT);
1956
1957         if (len > sizeof(buf))
1958                 len = sizeof(buf);
1959
1960         return simple_read_from_buffer(ubuf, max, ppos, buf, len);
1961 }
1962
1963 static ssize_t
1964 i915_cache_sharing_write(struct file *filp,
1965                   const char __user *ubuf,
1966                   size_t cnt,
1967                   loff_t *ppos)
1968 {
1969         struct drm_device *dev = filp->private_data;
1970         struct drm_i915_private *dev_priv = dev->dev_private;
1971         char buf[20];
1972         u32 snpcr;
1973         int val = 1;
1974
1975         if (!(IS_GEN6(dev) || IS_GEN7(dev)))
1976                 return -ENODEV;
1977
1978         if (cnt > 0) {
1979                 if (cnt > sizeof(buf) - 1)
1980                         return -EINVAL;
1981
1982                 if (copy_from_user(buf, ubuf, cnt))
1983                         return -EFAULT;
1984                 buf[cnt] = 0;
1985
1986                 val = simple_strtoul(buf, NULL, 0);
1987         }
1988
1989         if (val < 0 || val > 3)
1990                 return -EINVAL;
1991
1992         DRM_DEBUG_DRIVER("Manually setting uncore sharing to %d\n", val);
1993
1994         /* Update the cache sharing policy here as well */
1995         snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
1996         snpcr &= ~GEN6_MBC_SNPCR_MASK;
1997         snpcr |= (val << GEN6_MBC_SNPCR_SHIFT);
1998         I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
1999
2000         return cnt;
2001 }
2002
2003 static const struct file_operations i915_cache_sharing_fops = {
2004         .owner = THIS_MODULE,
2005         .open = simple_open,
2006         .read = i915_cache_sharing_read,
2007         .write = i915_cache_sharing_write,
2008         .llseek = default_llseek,
2009 };
2010
2011 /* As the drm_debugfs_init() routines are called before dev->dev_private is
2012  * allocated we need to hook into the minor for release. */
2013 static int
2014 drm_add_fake_info_node(struct drm_minor *minor,
2015                        struct dentry *ent,
2016                        const void *key)
2017 {
2018         struct drm_info_node *node;
2019
2020         node = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
2021         if (node == NULL) {
2022                 debugfs_remove(ent);
2023                 return -ENOMEM;
2024         }
2025
2026         node->minor = minor;
2027         node->dent = ent;
2028         node->info_ent = (void *) key;
2029
2030         mutex_lock(&minor->debugfs_lock);
2031         list_add(&node->list, &minor->debugfs_list);
2032         mutex_unlock(&minor->debugfs_lock);
2033
2034         return 0;
2035 }
2036
2037 static int i915_forcewake_open(struct inode *inode, struct file *file)
2038 {
2039         struct drm_device *dev = inode->i_private;
2040         struct drm_i915_private *dev_priv = dev->dev_private;
2041
2042         if (INTEL_INFO(dev)->gen < 6)
2043                 return 0;
2044
2045         gen6_gt_force_wake_get(dev_priv);
2046
2047         return 0;
2048 }
2049
2050 static int i915_forcewake_release(struct inode *inode, struct file *file)
2051 {
2052         struct drm_device *dev = inode->i_private;
2053         struct drm_i915_private *dev_priv = dev->dev_private;
2054
2055         if (INTEL_INFO(dev)->gen < 6)
2056                 return 0;
2057
2058         gen6_gt_force_wake_put(dev_priv);
2059
2060         return 0;
2061 }
2062
2063 static const struct file_operations i915_forcewake_fops = {
2064         .owner = THIS_MODULE,
2065         .open = i915_forcewake_open,
2066         .release = i915_forcewake_release,
2067 };
2068
2069 static int i915_forcewake_create(struct dentry *root, struct drm_minor *minor)
2070 {
2071         struct drm_device *dev = minor->dev;
2072         struct dentry *ent;
2073
2074         ent = debugfs_create_file("i915_forcewake_user",
2075                                   S_IRUSR,
2076                                   root, dev,
2077                                   &i915_forcewake_fops);
2078         if (IS_ERR(ent))
2079                 return PTR_ERR(ent);
2080
2081         return drm_add_fake_info_node(minor, ent, &i915_forcewake_fops);
2082 }
2083
2084 static int i915_debugfs_create(struct dentry *root,
2085                                struct drm_minor *minor,
2086                                const char *name,
2087                                const struct file_operations *fops)
2088 {
2089         struct drm_device *dev = minor->dev;
2090         struct dentry *ent;
2091
2092         ent = debugfs_create_file(name,
2093                                   S_IRUGO | S_IWUSR,
2094                                   root, dev,
2095                                   fops);
2096         if (IS_ERR(ent))
2097                 return PTR_ERR(ent);
2098
2099         return drm_add_fake_info_node(minor, ent, fops);
2100 }
2101
2102 static struct drm_info_list i915_debugfs_list[] = {
2103         {"i915_capabilities", i915_capabilities, 0},
2104         {"i915_gem_objects", i915_gem_object_info, 0},
2105         {"i915_gem_gtt", i915_gem_gtt_info, 0},
2106         {"i915_gem_pinned", i915_gem_gtt_info, 0, (void *) PINNED_LIST},
2107         {"i915_gem_active", i915_gem_object_list_info, 0, (void *) ACTIVE_LIST},
2108         {"i915_gem_inactive", i915_gem_object_list_info, 0, (void *) INACTIVE_LIST},
2109         {"i915_gem_pageflip", i915_gem_pageflip_info, 0},
2110         {"i915_gem_request", i915_gem_request_info, 0},
2111         {"i915_gem_seqno", i915_gem_seqno_info, 0},
2112         {"i915_gem_fence_regs", i915_gem_fence_regs_info, 0},
2113         {"i915_gem_interrupt", i915_interrupt_info, 0},
2114         {"i915_gem_hws", i915_hws_info, 0, (void *)RCS},
2115         {"i915_gem_hws_blt", i915_hws_info, 0, (void *)BCS},
2116         {"i915_gem_hws_bsd", i915_hws_info, 0, (void *)VCS},
2117         {"i915_rstdby_delays", i915_rstdby_delays, 0},
2118         {"i915_cur_delayinfo", i915_cur_delayinfo, 0},
2119         {"i915_delayfreq_table", i915_delayfreq_table, 0},
2120         {"i915_inttoext_table", i915_inttoext_table, 0},
2121         {"i915_drpc_info", i915_drpc_info, 0},
2122         {"i915_emon_status", i915_emon_status, 0},
2123         {"i915_ring_freq_table", i915_ring_freq_table, 0},
2124         {"i915_gfxec", i915_gfxec, 0},
2125         {"i915_fbc_status", i915_fbc_status, 0},
2126         {"i915_sr_status", i915_sr_status, 0},
2127         {"i915_opregion", i915_opregion, 0},
2128         {"i915_gem_framebuffer", i915_gem_framebuffer_info, 0},
2129         {"i915_context_status", i915_context_status, 0},
2130         {"i915_gen6_forcewake_count", i915_gen6_forcewake_count_info, 0},
2131         {"i915_swizzle_info", i915_swizzle_info, 0},
2132         {"i915_ppgtt_info", i915_ppgtt_info, 0},
2133         {"i915_dpio", i915_dpio_info, 0},
2134 };
2135 #define I915_DEBUGFS_ENTRIES ARRAY_SIZE(i915_debugfs_list)
2136
2137 int i915_debugfs_init(struct drm_minor *minor)
2138 {
2139         int ret;
2140
2141         ret = i915_debugfs_create(minor->debugfs_root, minor,
2142                                   "i915_wedged",
2143                                   &i915_wedged_fops);
2144         if (ret)
2145                 return ret;
2146
2147         ret = i915_forcewake_create(minor->debugfs_root, minor);
2148         if (ret)
2149                 return ret;
2150
2151         ret = i915_debugfs_create(minor->debugfs_root, minor,
2152                                   "i915_max_freq",
2153                                   &i915_max_freq_fops);
2154         if (ret)
2155                 return ret;
2156
2157         ret = i915_debugfs_create(minor->debugfs_root, minor,
2158                                   "i915_min_freq",
2159                                   &i915_min_freq_fops);
2160         if (ret)
2161                 return ret;
2162
2163         ret = i915_debugfs_create(minor->debugfs_root, minor,
2164                                   "i915_cache_sharing",
2165                                   &i915_cache_sharing_fops);
2166         if (ret)
2167                 return ret;
2168
2169         ret = i915_debugfs_create(minor->debugfs_root, minor,
2170                                   "i915_ring_stop",
2171                                   &i915_ring_stop_fops);
2172         if (ret)
2173                 return ret;
2174
2175         ret = i915_debugfs_create(minor->debugfs_root, minor,
2176                                   "i915_error_state",
2177                                   &i915_error_state_fops);
2178         if (ret)
2179                 return ret;
2180
2181         ret = i915_debugfs_create(minor->debugfs_root, minor,
2182                                  "i915_next_seqno",
2183                                  &i915_next_seqno_fops);
2184         if (ret)
2185                 return ret;
2186
2187         return drm_debugfs_create_files(i915_debugfs_list,
2188                                         I915_DEBUGFS_ENTRIES,
2189                                         minor->debugfs_root, minor);
2190 }
2191
2192 void i915_debugfs_cleanup(struct drm_minor *minor)
2193 {
2194         drm_debugfs_remove_files(i915_debugfs_list,
2195                                  I915_DEBUGFS_ENTRIES, minor);
2196         drm_debugfs_remove_files((struct drm_info_list *) &i915_forcewake_fops,
2197                                  1, minor);
2198         drm_debugfs_remove_files((struct drm_info_list *) &i915_wedged_fops,
2199                                  1, minor);
2200         drm_debugfs_remove_files((struct drm_info_list *) &i915_max_freq_fops,
2201                                  1, minor);
2202         drm_debugfs_remove_files((struct drm_info_list *) &i915_min_freq_fops,
2203                                  1, minor);
2204         drm_debugfs_remove_files((struct drm_info_list *) &i915_cache_sharing_fops,
2205                                  1, minor);
2206         drm_debugfs_remove_files((struct drm_info_list *) &i915_ring_stop_fops,
2207                                  1, minor);
2208         drm_debugfs_remove_files((struct drm_info_list *) &i915_error_state_fops,
2209                                  1, minor);
2210         drm_debugfs_remove_files((struct drm_info_list *) &i915_next_seqno_fops,
2211                                  1, minor);
2212 }
2213
2214 #endif /* CONFIG_DEBUG_FS */