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/sort.h>
  30 #include <linux/sched/mm.h>
  31 #include <drm/drm_debugfs.h>
  32 #include <drm/drm_fourcc.h>
  33 #include "intel_drv.h"
  34 #include "intel_guc_submission.h"
  35
  36 #include "i915_reset.h"
  37
  38 static inline struct drm_i915_private *node_to_i915(struct drm_info_node *node)
  39 {
  40         return to_i915(node->minor->dev);
  41 }
  42
  43 static int i915_capabilities(struct seq_file *m, void *data)
  44 {
  45         struct drm_i915_private *dev_priv = node_to_i915(m->private);
  46         const struct intel_device_info *info = INTEL_INFO(dev_priv);
  47         struct drm_printer p = drm_seq_file_printer(m);
  48
  49         seq_printf(m, "gen: %d\n", INTEL_GEN(dev_priv));
  50         seq_printf(m, "platform: %s\n", intel_platform_name(info->platform));
  51         seq_printf(m, "pch: %d\n", INTEL_PCH_TYPE(dev_priv));
  52
  53         intel_device_info_dump_flags(info, &p);
  54         intel_device_info_dump_runtime(RUNTIME_INFO(dev_priv), &p);
  55         intel_driver_caps_print(&dev_priv->caps, &p);
  56
  57         kernel_param_lock(THIS_MODULE);
  58         i915_params_dump(&i915_modparams, &p);
  59         kernel_param_unlock(THIS_MODULE);
  60
  61         return 0;
  62 }
  63
  64 static char get_active_flag(struct drm_i915_gem_object *obj)
  65 {
  66         return i915_gem_object_is_active(obj) ? '*' : ' ';
  67 }
  68
  69 static char get_pin_flag(struct drm_i915_gem_object *obj)
  70 {
  71         return obj->pin_global ? 'p' : ' ';
  72 }
  73
  74 static char get_tiling_flag(struct drm_i915_gem_object *obj)
  75 {
  76         switch (i915_gem_object_get_tiling(obj)) {
  77         default:
  78         case I915_TILING_NONE: return ' ';
  79         case I915_TILING_X: return 'X';
  80         case I915_TILING_Y: return 'Y';
  81         }
  82 }
  83
  84 static char get_global_flag(struct drm_i915_gem_object *obj)
  85 {
  86         return obj->userfault_count ? 'g' : ' ';
  87 }
  88
  89 static char get_pin_mapped_flag(struct drm_i915_gem_object *obj)
  90 {
  91         return obj->mm.mapping ? 'M' : ' ';
  92 }
  93
  94 static u64 i915_gem_obj_total_ggtt_size(struct drm_i915_gem_object *obj)
  95 {
  96         u64 size = 0;
  97         struct i915_vma *vma;
  98
  99         for_each_ggtt_vma(vma, obj) {
 100                 if (drm_mm_node_allocated(&vma->node))
 101                         size += vma->node.size;
 102         }
 103
 104         return size;
 105 }
 106
 107 static const char *
 108 stringify_page_sizes(unsigned int page_sizes, char *buf, size_t len)
 109 {
 110         size_t x = 0;
 111
 112         switch (page_sizes) {
 113         case 0:
 114                 return "";
 115         case I915_GTT_PAGE_SIZE_4K:
 116                 return "4K";
 117         case I915_GTT_PAGE_SIZE_64K:
 118                 return "64K";
 119         case I915_GTT_PAGE_SIZE_2M:
 120                 return "2M";
 121         default:
 122                 if (!buf)
 123                         return "M";
 124
 125                 if (page_sizes & I915_GTT_PAGE_SIZE_2M)
 126                         x += snprintf(buf + x, len - x, "2M, ");
 127                 if (page_sizes & I915_GTT_PAGE_SIZE_64K)
 128                         x += snprintf(buf + x, len - x, "64K, ");
 129                 if (page_sizes & I915_GTT_PAGE_SIZE_4K)
 130                         x += snprintf(buf + x, len - x, "4K, ");
 131                 buf[x-2] = '\0';
 132
 133                 return buf;
 134         }
 135 }
 136
 137 static void
 138 describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
 139 {
 140         struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
 141         struct intel_engine_cs *engine;
 142         struct i915_vma *vma;
 143         unsigned int frontbuffer_bits;
 144         int pin_count = 0;
 145
 146         lockdep_assert_held(&obj->base.dev->struct_mutex);
 147
 148         seq_printf(m, "%pK: %c%c%c%c%c %8zdKiB %02x %02x %s%s%s",
 149                    &obj->base,
 150                    get_active_flag(obj),
 151                    get_pin_flag(obj),
 152                    get_tiling_flag(obj),
 153                    get_global_flag(obj),
 154                    get_pin_mapped_flag(obj),
 155                    obj->base.size / 1024,
 156                    obj->read_domains,
 157                    obj->write_domain,
 158                    i915_cache_level_str(dev_priv, obj->cache_level),
 159                    obj->mm.dirty ? " dirty" : "",
 160                    obj->mm.madv == I915_MADV_DONTNEED ? " purgeable" : "");
 161         if (obj->base.name)
 162                 seq_printf(m, " (name: %d)", obj->base.name);
 163         list_for_each_entry(vma, &obj->vma.list, obj_link) {
 164                 if (i915_vma_is_pinned(vma))
 165                         pin_count++;
 166         }
 167         seq_printf(m, " (pinned x %d)", pin_count);
 168         if (obj->pin_global)
 169                 seq_printf(m, " (global)");
 170         list_for_each_entry(vma, &obj->vma.list, obj_link) {
 171                 if (!drm_mm_node_allocated(&vma->node))
 172                         continue;
 173
 174                 seq_printf(m, " (%sgtt offset: %08llx, size: %08llx, pages: %s",
 175                            i915_vma_is_ggtt(vma) ? "g" : "pp",
 176                            vma->node.start, vma->node.size,
 177                            stringify_page_sizes(vma->page_sizes.gtt, NULL, 0));
 178                 if (i915_vma_is_ggtt(vma)) {
 179                         switch (vma->ggtt_view.type) {
 180                         case I915_GGTT_VIEW_NORMAL:
 181                                 seq_puts(m, ", normal");
 182                                 break;
 183
 184                         case I915_GGTT_VIEW_PARTIAL:
 185                                 seq_printf(m, ", partial [%08llx+%x]",
 186                                            vma->ggtt_view.partial.offset << PAGE_SHIFT,
 187                                            vma->ggtt_view.partial.size << PAGE_SHIFT);
 188                                 break;
 189
 190                         case I915_GGTT_VIEW_ROTATED:
 191                                 seq_printf(m, ", rotated [(%ux%u, stride=%u, offset=%u), (%ux%u, stride=%u, offset=%u)]",
 192                                            vma->ggtt_view.rotated.plane[0].width,
 193                                            vma->ggtt_view.rotated.plane[0].height,
 194                                            vma->ggtt_view.rotated.plane[0].stride,
 195                                            vma->ggtt_view.rotated.plane[0].offset,
 196                                            vma->ggtt_view.rotated.plane[1].width,
 197                                            vma->ggtt_view.rotated.plane[1].height,
 198                                            vma->ggtt_view.rotated.plane[1].stride,
 199                                            vma->ggtt_view.rotated.plane[1].offset);
 200                                 break;
 201
 202                         default:
 203                                 MISSING_CASE(vma->ggtt_view.type);
 204                                 break;
 205                         }
 206                 }
 207                 if (vma->fence)
 208                         seq_printf(m, " , fence: %d%s",
 209                                    vma->fence->id,
 210                                    i915_active_request_isset(&vma->last_fence) ? "*" : "");
 211                 seq_puts(m, ")");
 212         }
 213         if (obj->stolen)
 214                 seq_printf(m, " (stolen: %08llx)", obj->stolen->start);
 215
 216         engine = i915_gem_object_last_write_engine(obj);
 217         if (engine)
 218                 seq_printf(m, " (%s)", engine->name);
 219
 220         frontbuffer_bits = atomic_read(&obj->frontbuffer_bits);
 221         if (frontbuffer_bits)
 222                 seq_printf(m, " (frontbuffer: 0x%03x)", frontbuffer_bits);
 223 }
 224
 225 static int obj_rank_by_stolen(const void *A, const void *B)
 226 {
 227         const struct drm_i915_gem_object *a =
 228                 *(const struct drm_i915_gem_object **)A;
 229         const struct drm_i915_gem_object *b =
 230                 *(const struct drm_i915_gem_object **)B;
 231
 232         if (a->stolen->start < b->stolen->start)
 233                 return -1;
 234         if (a->stolen->start > b->stolen->start)
 235                 return 1;
 236         return 0;
 237 }
 238
 239 static int i915_gem_stolen_list_info(struct seq_file *m, void *data)
 240 {
 241         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 242         struct drm_device *dev = &dev_priv->drm;
 243         struct drm_i915_gem_object **objects;
 244         struct drm_i915_gem_object *obj;
 245         u64 total_obj_size, total_gtt_size;
 246         unsigned long total, count, n;
 247         int ret;
 248
 249         total = READ_ONCE(dev_priv->mm.object_count);
 250         objects = kvmalloc_array(total, sizeof(*objects), GFP_KERNEL);
 251         if (!objects)
 252                 return -ENOMEM;
 253
 254         ret = mutex_lock_interruptible(&dev->struct_mutex);
 255         if (ret)
 256                 goto out;
 257
 258         total_obj_size = total_gtt_size = count = 0;
 259
 260         spin_lock(&dev_priv->mm.obj_lock);
 261         list_for_each_entry(obj, &dev_priv->mm.bound_list, mm.link) {
 262                 if (count == total)
 263                         break;
 264
 265                 if (obj->stolen == NULL)
 266                         continue;
 267
 268                 objects[count++] = obj;
 269                 total_obj_size += obj->base.size;
 270                 total_gtt_size += i915_gem_obj_total_ggtt_size(obj);
 271
 272         }
 273         list_for_each_entry(obj, &dev_priv->mm.unbound_list, mm.link) {
 274                 if (count == total)
 275                         break;
 276
 277                 if (obj->stolen == NULL)
 278                         continue;
 279
 280                 objects[count++] = obj;
 281                 total_obj_size += obj->base.size;
 282         }
 283         spin_unlock(&dev_priv->mm.obj_lock);
 284
 285         sort(objects, count, sizeof(*objects), obj_rank_by_stolen, NULL);
 286
 287         seq_puts(m, "Stolen:\n");
 288         for (n = 0; n < count; n++) {
 289                 seq_puts(m, "   ");
 290                 describe_obj(m, objects[n]);
 291                 seq_putc(m, '\n');
 292         }
 293         seq_printf(m, "Total %lu objects, %llu bytes, %llu GTT size\n",
 294                    count, total_obj_size, total_gtt_size);
 295
 296         mutex_unlock(&dev->struct_mutex);
 297 out:
 298         kvfree(objects);
 299         return ret;
 300 }
 301
 302 struct file_stats {
 303         struct i915_address_space *vm;
 304         unsigned long count;
 305         u64 total, unbound;
 306         u64 global, shared;
 307         u64 active, inactive;
 308         u64 closed;
 309 };
 310
 311 static int per_file_stats(int id, void *ptr, void *data)
 312 {
 313         struct drm_i915_gem_object *obj = ptr;
 314         struct file_stats *stats = data;
 315         struct i915_vma *vma;
 316
 317         lockdep_assert_held(&obj->base.dev->struct_mutex);
 318
 319         stats->count++;
 320         stats->total += obj->base.size;
 321         if (!obj->bind_count)
 322                 stats->unbound += obj->base.size;
 323         if (obj->base.name || obj->base.dma_buf)
 324                 stats->shared += obj->base.size;
 325
 326         list_for_each_entry(vma, &obj->vma.list, obj_link) {
 327                 if (!drm_mm_node_allocated(&vma->node))
 328                         continue;
 329
 330                 if (i915_vma_is_ggtt(vma)) {
 331                         stats->global += vma->node.size;
 332                 } else {
 333                         if (vma->vm != stats->vm)
 334                                 continue;
 335                 }
 336
 337                 if (i915_vma_is_active(vma))
 338                         stats->active += vma->node.size;
 339                 else
 340                         stats->inactive += vma->node.size;
 341
 342                 if (i915_vma_is_closed(vma))
 343                         stats->closed += vma->node.size;
 344         }
 345
 346         return 0;
 347 }
 348
 349 #define print_file_stats(m, name, stats) do { \
 350         if (stats.count) \
 351                 seq_printf(m, "%s: %lu objects, %llu bytes (%llu active, %llu inactive, %llu global, %llu shared, %llu unbound, %llu closed)\n", \
 352                            name, \
 353                            stats.count, \
 354                            stats.total, \
 355                            stats.active, \
 356                            stats.inactive, \
 357                            stats.global, \
 358                            stats.shared, \
 359                            stats.unbound, \
 360                            stats.closed); \
 361 } while (0)
 362
 363 static void print_batch_pool_stats(struct seq_file *m,
 364                                    struct drm_i915_private *dev_priv)
 365 {
 366         struct drm_i915_gem_object *obj;
 367         struct intel_engine_cs *engine;
 368         struct file_stats stats = {};
 369         enum intel_engine_id id;
 370         int j;
 371
 372         for_each_engine(engine, dev_priv, id) {
 373                 for (j = 0; j < ARRAY_SIZE(engine->batch_pool.cache_list); j++) {
 374                         list_for_each_entry(obj,
 375                                             &engine->batch_pool.cache_list[j],
 376                                             batch_pool_link)
 377                                 per_file_stats(0, obj, &stats);
 378                 }
 379         }
 380
 381         print_file_stats(m, "[k]batch pool", stats);
 382 }
 383
 384 static void print_context_stats(struct seq_file *m,
 385                                 struct drm_i915_private *i915)
 386 {
 387         struct file_stats kstats = {};
 388         struct i915_gem_context *ctx;
 389
 390         list_for_each_entry(ctx, &i915->contexts.list, link) {
 391                 struct intel_engine_cs *engine;
 392                 enum intel_engine_id id;
 393
 394                 for_each_engine(engine, i915, id) {
 395                         struct intel_context *ce = to_intel_context(ctx, engine);
 396
 397                         if (ce->state)
 398                                 per_file_stats(0, ce->state->obj, &kstats);
 399                         if (ce->ring)
 400                                 per_file_stats(0, ce->ring->vma->obj, &kstats);
 401                 }
 402
 403                 if (!IS_ERR_OR_NULL(ctx->file_priv)) {
 404                         struct file_stats stats = { .vm = &ctx->ppgtt->vm, };
 405                         struct drm_file *file = ctx->file_priv->file;
 406                         struct task_struct *task;
 407                         char name[80];
 408
 409                         spin_lock(&file->table_lock);
 410                         idr_for_each(&file->object_idr, per_file_stats, &stats);
 411                         spin_unlock(&file->table_lock);
 412
 413                         rcu_read_lock();
 414                         task = pid_task(ctx->pid ?: file->pid, PIDTYPE_PID);
 415                         snprintf(name, sizeof(name), "%s/%d",
 416                                  task ? task->comm : "<unknown>",
 417                                  ctx->user_handle);
 418                         rcu_read_unlock();
 419
 420                         print_file_stats(m, name, stats);
 421                 }
 422         }
 423
 424         print_file_stats(m, "[k]contexts", kstats);
 425 }
 426
 427 static int i915_gem_object_info(struct seq_file *m, void *data)
 428 {
 429         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 430         struct drm_device *dev = &dev_priv->drm;
 431         struct i915_ggtt *ggtt = &dev_priv->ggtt;
 432         u32 count, mapped_count, purgeable_count, dpy_count, huge_count;
 433         u64 size, mapped_size, purgeable_size, dpy_size, huge_size;
 434         struct drm_i915_gem_object *obj;
 435         unsigned int page_sizes = 0;
 436         char buf[80];
 437         int ret;
 438
 439         seq_printf(m, "%u objects, %llu bytes\n",
 440                    dev_priv->mm.object_count,
 441                    dev_priv->mm.object_memory);
 442
 443         size = count = 0;
 444         mapped_size = mapped_count = 0;
 445         purgeable_size = purgeable_count = 0;
 446         huge_size = huge_count = 0;
 447
 448         spin_lock(&dev_priv->mm.obj_lock);
 449         list_for_each_entry(obj, &dev_priv->mm.unbound_list, mm.link) {
 450                 size += obj->base.size;
 451                 ++count;
 452
 453                 if (obj->mm.madv == I915_MADV_DONTNEED) {
 454                         purgeable_size += obj->base.size;
 455                         ++purgeable_count;
 456                 }
 457
 458                 if (obj->mm.mapping) {
 459                         mapped_count++;
 460                         mapped_size += obj->base.size;
 461                 }
 462
 463                 if (obj->mm.page_sizes.sg > I915_GTT_PAGE_SIZE) {
 464                         huge_count++;
 465                         huge_size += obj->base.size;
 466                         page_sizes |= obj->mm.page_sizes.sg;
 467                 }
 468         }
 469         seq_printf(m, "%u unbound objects, %llu bytes\n", count, size);
 470
 471         size = count = dpy_size = dpy_count = 0;
 472         list_for_each_entry(obj, &dev_priv->mm.bound_list, mm.link) {
 473                 size += obj->base.size;
 474                 ++count;
 475
 476                 if (obj->pin_global) {
 477                         dpy_size += obj->base.size;
 478                         ++dpy_count;
 479                 }
 480
 481                 if (obj->mm.madv == I915_MADV_DONTNEED) {
 482                         purgeable_size += obj->base.size;
 483                         ++purgeable_count;
 484                 }
 485
 486                 if (obj->mm.mapping) {
 487                         mapped_count++;
 488                         mapped_size += obj->base.size;
 489                 }
 490
 491                 if (obj->mm.page_sizes.sg > I915_GTT_PAGE_SIZE) {
 492                         huge_count++;
 493                         huge_size += obj->base.size;
 494                         page_sizes |= obj->mm.page_sizes.sg;
 495                 }
 496         }
 497         spin_unlock(&dev_priv->mm.obj_lock);
 498
 499         seq_printf(m, "%u bound objects, %llu bytes\n",
 500                    count, size);
 501         seq_printf(m, "%u purgeable objects, %llu bytes\n",
 502                    purgeable_count, purgeable_size);
 503         seq_printf(m, "%u mapped objects, %llu bytes\n",
 504                    mapped_count, mapped_size);
 505         seq_printf(m, "%u huge-paged objects (%s) %llu bytes\n",
 506                    huge_count,
 507                    stringify_page_sizes(page_sizes, buf, sizeof(buf)),
 508                    huge_size);
 509         seq_printf(m, "%u display objects (globally pinned), %llu bytes\n",
 510                    dpy_count, dpy_size);
 511
 512         seq_printf(m, "%llu [%pa] gtt total\n",
 513                    ggtt->vm.total, &ggtt->mappable_end);
 514         seq_printf(m, "Supported page sizes: %s\n",
 515                    stringify_page_sizes(INTEL_INFO(dev_priv)->page_sizes,
 516                                         buf, sizeof(buf)));
 517
 518         seq_putc(m, '\n');
 519
 520         ret = mutex_lock_interruptible(&dev->struct_mutex);
 521         if (ret)
 522                 return ret;
 523
 524         print_batch_pool_stats(m, dev_priv);
 525         print_context_stats(m, dev_priv);
 526         mutex_unlock(&dev->struct_mutex);
 527
 528         return 0;
 529 }
 530
 531 static int i915_gem_gtt_info(struct seq_file *m, void *data)
 532 {
 533         struct drm_info_node *node = m->private;
 534         struct drm_i915_private *dev_priv = node_to_i915(node);
 535         struct drm_device *dev = &dev_priv->drm;
 536         struct drm_i915_gem_object **objects;
 537         struct drm_i915_gem_object *obj;
 538         u64 total_obj_size, total_gtt_size;
 539         unsigned long nobject, n;
 540         int count, ret;
 541
 542         nobject = READ_ONCE(dev_priv->mm.object_count);
 543         objects = kvmalloc_array(nobject, sizeof(*objects), GFP_KERNEL);
 544         if (!objects)
 545                 return -ENOMEM;
 546
 547         ret = mutex_lock_interruptible(&dev->struct_mutex);
 548         if (ret)
 549                 return ret;
 550
 551         count = 0;
 552         spin_lock(&dev_priv->mm.obj_lock);
 553         list_for_each_entry(obj, &dev_priv->mm.bound_list, mm.link) {
 554                 objects[count++] = obj;
 555                 if (count == nobject)
 556                         break;
 557         }
 558         spin_unlock(&dev_priv->mm.obj_lock);
 559
 560         total_obj_size = total_gtt_size = 0;
 561         for (n = 0;  n < count; n++) {
 562                 obj = objects[n];
 563
 564                 seq_puts(m, "   ");
 565                 describe_obj(m, obj);
 566                 seq_putc(m, '\n');
 567                 total_obj_size += obj->base.size;
 568                 total_gtt_size += i915_gem_obj_total_ggtt_size(obj);
 569         }
 570
 571         mutex_unlock(&dev->struct_mutex);
 572
 573         seq_printf(m, "Total %d objects, %llu bytes, %llu GTT size\n",
 574                    count, total_obj_size, total_gtt_size);
 575         kvfree(objects);
 576
 577         return 0;
 578 }
 579
 580 static int i915_gem_batch_pool_info(struct seq_file *m, void *data)
 581 {
 582         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 583         struct drm_device *dev = &dev_priv->drm;
 584         struct drm_i915_gem_object *obj;
 585         struct intel_engine_cs *engine;
 586         enum intel_engine_id id;
 587         int total = 0;
 588         int ret, j;
 589
 590         ret = mutex_lock_interruptible(&dev->struct_mutex);
 591         if (ret)
 592                 return ret;
 593
 594         for_each_engine(engine, dev_priv, id) {
 595                 for (j = 0; j < ARRAY_SIZE(engine->batch_pool.cache_list); j++) {
 596                         int count;
 597
 598                         count = 0;
 599                         list_for_each_entry(obj,
 600                                             &engine->batch_pool.cache_list[j],
 601                                             batch_pool_link)
 602                                 count++;
 603                         seq_printf(m, "%s cache[%d]: %d objects\n",
 604                                    engine->name, j, count);
 605
 606                         list_for_each_entry(obj,
 607                                             &engine->batch_pool.cache_list[j],
 608                                             batch_pool_link) {
 609                                 seq_puts(m, "   ");
 610                                 describe_obj(m, obj);
 611                                 seq_putc(m, '\n');
 612                         }
 613
 614                         total += count;
 615                 }
 616         }
 617
 618         seq_printf(m, "total: %d\n", total);
 619
 620         mutex_unlock(&dev->struct_mutex);
 621
 622         return 0;
 623 }
 624
 625 static void gen8_display_interrupt_info(struct seq_file *m)
 626 {
 627         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 628         int pipe;
 629
 630         for_each_pipe(dev_priv, pipe) {
 631                 enum intel_display_power_domain power_domain;
 632                 intel_wakeref_t wakeref;
 633
 634                 power_domain = POWER_DOMAIN_PIPE(pipe);
 635                 wakeref = intel_display_power_get_if_enabled(dev_priv,
 636                                                              power_domain);
 637                 if (!wakeref) {
 638                         seq_printf(m, "Pipe %c power disabled\n",
 639                                    pipe_name(pipe));
 640                         continue;
 641                 }
 642                 seq_printf(m, "Pipe %c IMR:\t%08x\n",
 643                            pipe_name(pipe),
 644                            I915_READ(GEN8_DE_PIPE_IMR(pipe)));
 645                 seq_printf(m, "Pipe %c IIR:\t%08x\n",
 646                            pipe_name(pipe),
 647                            I915_READ(GEN8_DE_PIPE_IIR(pipe)));
 648                 seq_printf(m, "Pipe %c IER:\t%08x\n",
 649                            pipe_name(pipe),
 650                            I915_READ(GEN8_DE_PIPE_IER(pipe)));
 651
 652                 intel_display_power_put(dev_priv, power_domain, wakeref);
 653         }
 654
 655         seq_printf(m, "Display Engine port interrupt mask:\t%08x\n",
 656                    I915_READ(GEN8_DE_PORT_IMR));
 657         seq_printf(m, "Display Engine port interrupt identity:\t%08x\n",
 658                    I915_READ(GEN8_DE_PORT_IIR));
 659         seq_printf(m, "Display Engine port interrupt enable:\t%08x\n",
 660                    I915_READ(GEN8_DE_PORT_IER));
 661
 662         seq_printf(m, "Display Engine misc interrupt mask:\t%08x\n",
 663                    I915_READ(GEN8_DE_MISC_IMR));
 664         seq_printf(m, "Display Engine misc interrupt identity:\t%08x\n",
 665                    I915_READ(GEN8_DE_MISC_IIR));
 666         seq_printf(m, "Display Engine misc interrupt enable:\t%08x\n",
 667                    I915_READ(GEN8_DE_MISC_IER));
 668
 669         seq_printf(m, "PCU interrupt mask:\t%08x\n",
 670                    I915_READ(GEN8_PCU_IMR));
 671         seq_printf(m, "PCU interrupt identity:\t%08x\n",
 672                    I915_READ(GEN8_PCU_IIR));
 673         seq_printf(m, "PCU interrupt enable:\t%08x\n",
 674                    I915_READ(GEN8_PCU_IER));
 675 }
 676
 677 static int i915_interrupt_info(struct seq_file *m, void *data)
 678 {
 679         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 680         struct intel_engine_cs *engine;
 681         enum intel_engine_id id;
 682         intel_wakeref_t wakeref;
 683         int i, pipe;
 684
 685         wakeref = intel_runtime_pm_get(dev_priv);
 686
 687         if (IS_CHERRYVIEW(dev_priv)) {
 688                 intel_wakeref_t pref;
 689
 690                 seq_printf(m, "Master Interrupt Control:\t%08x\n",
 691                            I915_READ(GEN8_MASTER_IRQ));
 692
 693                 seq_printf(m, "Display IER:\t%08x\n",
 694                            I915_READ(VLV_IER));
 695                 seq_printf(m, "Display IIR:\t%08x\n",
 696                            I915_READ(VLV_IIR));
 697                 seq_printf(m, "Display IIR_RW:\t%08x\n",
 698                            I915_READ(VLV_IIR_RW));
 699                 seq_printf(m, "Display IMR:\t%08x\n",
 700                            I915_READ(VLV_IMR));
 701                 for_each_pipe(dev_priv, pipe) {
 702                         enum intel_display_power_domain power_domain;
 703
 704                         power_domain = POWER_DOMAIN_PIPE(pipe);
 705                         pref = intel_display_power_get_if_enabled(dev_priv,
 706                                                                   power_domain);
 707                         if (!pref) {
 708                                 seq_printf(m, "Pipe %c power disabled\n",
 709                                            pipe_name(pipe));
 710                                 continue;
 711                         }
 712
 713                         seq_printf(m, "Pipe %c stat:\t%08x\n",
 714                                    pipe_name(pipe),
 715                                    I915_READ(PIPESTAT(pipe)));
 716
 717                         intel_display_power_put(dev_priv, power_domain, pref);
 718                 }
 719
 720                 pref = intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 721                 seq_printf(m, "Port hotplug:\t%08x\n",
 722                            I915_READ(PORT_HOTPLUG_EN));
 723                 seq_printf(m, "DPFLIPSTAT:\t%08x\n",
 724                            I915_READ(VLV_DPFLIPSTAT));
 725                 seq_printf(m, "DPINVGTT:\t%08x\n",
 726                            I915_READ(DPINVGTT));
 727                 intel_display_power_put(dev_priv, POWER_DOMAIN_INIT, pref);
 728
 729                 for (i = 0; i < 4; i++) {
 730                         seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
 731                                    i, I915_READ(GEN8_GT_IMR(i)));
 732                         seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
 733                                    i, I915_READ(GEN8_GT_IIR(i)));
 734                         seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
 735                                    i, I915_READ(GEN8_GT_IER(i)));
 736                 }
 737
 738                 seq_printf(m, "PCU interrupt mask:\t%08x\n",
 739                            I915_READ(GEN8_PCU_IMR));
 740                 seq_printf(m, "PCU interrupt identity:\t%08x\n",
 741                            I915_READ(GEN8_PCU_IIR));
 742                 seq_printf(m, "PCU interrupt enable:\t%08x\n",
 743                            I915_READ(GEN8_PCU_IER));
 744         } else if (INTEL_GEN(dev_priv) >= 11) {
 745                 seq_printf(m, "Master Interrupt Control:  %08x\n",
 746                            I915_READ(GEN11_GFX_MSTR_IRQ));
 747
 748                 seq_printf(m, "Render/Copy Intr Enable:   %08x\n",
 749                            I915_READ(GEN11_RENDER_COPY_INTR_ENABLE));
 750                 seq_printf(m, "VCS/VECS Intr Enable:      %08x\n",
 751                            I915_READ(GEN11_VCS_VECS_INTR_ENABLE));
 752                 seq_printf(m, "GUC/SG Intr Enable:\t   %08x\n",
 753                            I915_READ(GEN11_GUC_SG_INTR_ENABLE));
 754                 seq_printf(m, "GPM/WGBOXPERF Intr Enable: %08x\n",
 755                            I915_READ(GEN11_GPM_WGBOXPERF_INTR_ENABLE));
 756                 seq_printf(m, "Crypto Intr Enable:\t   %08x\n",
 757                            I915_READ(GEN11_CRYPTO_RSVD_INTR_ENABLE));
 758                 seq_printf(m, "GUnit/CSME Intr Enable:\t   %08x\n",
 759                            I915_READ(GEN11_GUNIT_CSME_INTR_ENABLE));
 760
 761                 seq_printf(m, "Display Interrupt Control:\t%08x\n",
 762                            I915_READ(GEN11_DISPLAY_INT_CTL));
 763
 764                 gen8_display_interrupt_info(m);
 765         } else if (INTEL_GEN(dev_priv) >= 8) {
 766                 seq_printf(m, "Master Interrupt Control:\t%08x\n",
 767                            I915_READ(GEN8_MASTER_IRQ));
 768
 769                 for (i = 0; i < 4; i++) {
 770                         seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
 771                                    i, I915_READ(GEN8_GT_IMR(i)));
 772                         seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
 773                                    i, I915_READ(GEN8_GT_IIR(i)));
 774                         seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
 775                                    i, I915_READ(GEN8_GT_IER(i)));
 776                 }
 777
 778                 gen8_display_interrupt_info(m);
 779         } else if (IS_VALLEYVIEW(dev_priv)) {
 780                 seq_printf(m, "Display IER:\t%08x\n",
 781                            I915_READ(VLV_IER));
 782                 seq_printf(m, "Display IIR:\t%08x\n",
 783                            I915_READ(VLV_IIR));
 784                 seq_printf(m, "Display IIR_RW:\t%08x\n",
 785                            I915_READ(VLV_IIR_RW));
 786                 seq_printf(m, "Display IMR:\t%08x\n",
 787                            I915_READ(VLV_IMR));
 788                 for_each_pipe(dev_priv, pipe) {
 789                         enum intel_display_power_domain power_domain;
 790                         intel_wakeref_t pref;
 791
 792                         power_domain = POWER_DOMAIN_PIPE(pipe);
 793                         pref = intel_display_power_get_if_enabled(dev_priv,
 794                                                                   power_domain);
 795                         if (!pref) {
 796                                 seq_printf(m, "Pipe %c power disabled\n",
 797                                            pipe_name(pipe));
 798                                 continue;
 799                         }
 800
 801                         seq_printf(m, "Pipe %c stat:\t%08x\n",
 802                                    pipe_name(pipe),
 803                                    I915_READ(PIPESTAT(pipe)));
 804                         intel_display_power_put(dev_priv, power_domain, pref);
 805                 }
 806
 807                 seq_printf(m, "Master IER:\t%08x\n",
 808                            I915_READ(VLV_MASTER_IER));
 809
 810                 seq_printf(m, "Render IER:\t%08x\n",
 811                            I915_READ(GTIER));
 812                 seq_printf(m, "Render IIR:\t%08x\n",
 813                            I915_READ(GTIIR));
 814                 seq_printf(m, "Render IMR:\t%08x\n",
 815                            I915_READ(GTIMR));
 816
 817                 seq_printf(m, "PM IER:\t\t%08x\n",
 818                            I915_READ(GEN6_PMIER));
 819                 seq_printf(m, "PM IIR:\t\t%08x\n",
 820                            I915_READ(GEN6_PMIIR));
 821                 seq_printf(m, "PM IMR:\t\t%08x\n",
 822                            I915_READ(GEN6_PMIMR));
 823
 824                 seq_printf(m, "Port hotplug:\t%08x\n",
 825                            I915_READ(PORT_HOTPLUG_EN));
 826                 seq_printf(m, "DPFLIPSTAT:\t%08x\n",
 827                            I915_READ(VLV_DPFLIPSTAT));
 828                 seq_printf(m, "DPINVGTT:\t%08x\n",
 829                            I915_READ(DPINVGTT));
 830
 831         } else if (!HAS_PCH_SPLIT(dev_priv)) {
 832                 seq_printf(m, "Interrupt enable:    %08x\n",
 833                            I915_READ(IER));
 834                 seq_printf(m, "Interrupt identity:  %08x\n",
 835                            I915_READ(IIR));
 836                 seq_printf(m, "Interrupt mask:      %08x\n",
 837                            I915_READ(IMR));
 838                 for_each_pipe(dev_priv, pipe)
 839                         seq_printf(m, "Pipe %c stat:         %08x\n",
 840                                    pipe_name(pipe),
 841                                    I915_READ(PIPESTAT(pipe)));
 842         } else {
 843                 seq_printf(m, "North Display Interrupt enable:          %08x\n",
 844                            I915_READ(DEIER));
 845                 seq_printf(m, "North Display Interrupt identity:        %08x\n",
 846                            I915_READ(DEIIR));
 847                 seq_printf(m, "North Display Interrupt mask:            %08x\n",
 848                            I915_READ(DEIMR));
 849                 seq_printf(m, "South Display Interrupt enable:          %08x\n",
 850                            I915_READ(SDEIER));
 851                 seq_printf(m, "South Display Interrupt identity:        %08x\n",
 852                            I915_READ(SDEIIR));
 853                 seq_printf(m, "South Display Interrupt mask:            %08x\n",
 854                            I915_READ(SDEIMR));
 855                 seq_printf(m, "Graphics Interrupt enable:               %08x\n",
 856                            I915_READ(GTIER));
 857                 seq_printf(m, "Graphics Interrupt identity:             %08x\n",
 858                            I915_READ(GTIIR));
 859                 seq_printf(m, "Graphics Interrupt mask:         %08x\n",
 860                            I915_READ(GTIMR));
 861         }
 862
 863         if (INTEL_GEN(dev_priv) >= 11) {
 864                 seq_printf(m, "RCS Intr Mask:\t %08x\n",
 865                            I915_READ(GEN11_RCS0_RSVD_INTR_MASK));
 866                 seq_printf(m, "BCS Intr Mask:\t %08x\n",
 867                            I915_READ(GEN11_BCS_RSVD_INTR_MASK));
 868                 seq_printf(m, "VCS0/VCS1 Intr Mask:\t %08x\n",
 869                            I915_READ(GEN11_VCS0_VCS1_INTR_MASK));
 870                 seq_printf(m, "VCS2/VCS3 Intr Mask:\t %08x\n",
 871                            I915_READ(GEN11_VCS2_VCS3_INTR_MASK));
 872                 seq_printf(m, "VECS0/VECS1 Intr Mask:\t %08x\n",
 873                            I915_READ(GEN11_VECS0_VECS1_INTR_MASK));
 874                 seq_printf(m, "GUC/SG Intr Mask:\t %08x\n",
 875                            I915_READ(GEN11_GUC_SG_INTR_MASK));
 876                 seq_printf(m, "GPM/WGBOXPERF Intr Mask: %08x\n",
 877                            I915_READ(GEN11_GPM_WGBOXPERF_INTR_MASK));
 878                 seq_printf(m, "Crypto Intr Mask:\t %08x\n",
 879                            I915_READ(GEN11_CRYPTO_RSVD_INTR_MASK));
 880                 seq_printf(m, "Gunit/CSME Intr Mask:\t %08x\n",
 881                            I915_READ(GEN11_GUNIT_CSME_INTR_MASK));
 882
 883         } else if (INTEL_GEN(dev_priv) >= 6) {
 884                 for_each_engine(engine, dev_priv, id) {
 885                         seq_printf(m,
 886                                    "Graphics Interrupt mask (%s):       %08x\n",
 887                                    engine->name, I915_READ_IMR(engine));
 888                 }
 889         }
 890
 891         intel_runtime_pm_put(dev_priv, wakeref);
 892
 893         return 0;
 894 }
 895
 896 static int i915_gem_fence_regs_info(struct seq_file *m, void *data)
 897 {
 898         struct drm_i915_private *dev_priv = node_to_i915(m->private);
 899         struct drm_device *dev = &dev_priv->drm;
 900         int i, ret;
 901
 902         ret = mutex_lock_interruptible(&dev->struct_mutex);
 903         if (ret)
 904                 return ret;
 905
 906         seq_printf(m, "Total fences = %d\n", dev_priv->num_fence_regs);
 907         for (i = 0; i < dev_priv->num_fence_regs; i++) {
 908                 struct i915_vma *vma = dev_priv->fence_regs[i].vma;
 909
 910                 seq_printf(m, "Fence %d, pin count = %d, object = ",
 911                            i, dev_priv->fence_regs[i].pin_count);
 912                 if (!vma)
 913                         seq_puts(m, "unused");
 914                 else
 915                         describe_obj(m, vma->obj);
 916                 seq_putc(m, '\n');
 917         }
 918
 919         mutex_unlock(&dev->struct_mutex);
 920         return 0;
 921 }
 922
 923 #if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR)
 924 static ssize_t gpu_state_read(struct file *file, char __user *ubuf,
 925                               size_t count, loff_t *pos)
 926 {
 927         struct i915_gpu_state *error;
 928         ssize_t ret;
 929         void *buf;
 930
 931         error = file->private_data;
 932         if (!error)
 933                 return 0;
 934
 935         /* Bounce buffer required because of kernfs __user API convenience. */
 936         buf = kmalloc(count, GFP_KERNEL);
 937         if (!buf)
 938                 return -ENOMEM;
 939
 940         ret = i915_gpu_state_copy_to_buffer(error, buf, *pos, count);
 941         if (ret <= 0)
 942                 goto out;
 943
 944         if (!copy_to_user(ubuf, buf, ret))
 945                 *pos += ret;
 946         else
 947                 ret = -EFAULT;
 948
 949 out:
 950         kfree(buf);
 951         return ret;
 952 }
 953
 954 static int gpu_state_release(struct inode *inode, struct file *file)
 955 {
 956         i915_gpu_state_put(file->private_data);
 957         return 0;
 958 }
 959
 960 static int i915_gpu_info_open(struct inode *inode, struct file *file)
 961 {
 962         struct drm_i915_private *i915 = inode->i_private;
 963         struct i915_gpu_state *gpu;
 964         intel_wakeref_t wakeref;
 965
 966         gpu = NULL;
 967         with_intel_runtime_pm(i915, wakeref)
 968                 gpu = i915_capture_gpu_state(i915);
 969         if (IS_ERR(gpu))
 970                 return PTR_ERR(gpu);
 971
 972         file->private_data = gpu;
 973         return 0;
 974 }
 975
 976 static const struct file_operations i915_gpu_info_fops = {
 977         .owner = THIS_MODULE,
 978         .open = i915_gpu_info_open,
 979         .read = gpu_state_read,
 980         .llseek = default_llseek,
 981         .release = gpu_state_release,
 982 };
 983
 984 static ssize_t
 985 i915_error_state_write(struct file *filp,
 986                        const char __user *ubuf,
 987                        size_t cnt,
 988                        loff_t *ppos)
 989 {
 990         struct i915_gpu_state *error = filp->private_data;
 991
 992         if (!error)
 993                 return 0;
 994
 995         DRM_DEBUG_DRIVER("Resetting error state\n");
 996         i915_reset_error_state(error->i915);
 997
 998         return cnt;
 999 }
1000
1001 static int i915_error_state_open(struct inode *inode, struct file *file)
1002 {
1003         struct i915_gpu_state *error;
1004
1005         error = i915_first_error_state(inode->i_private);
1006         if (IS_ERR(error))
1007                 return PTR_ERR(error);
1008
1009         file->private_data  = error;
1010         return 0;
1011 }
1012
1013 static const struct file_operations i915_error_state_fops = {
1014         .owner = THIS_MODULE,
1015         .open = i915_error_state_open,
1016         .read = gpu_state_read,
1017         .write = i915_error_state_write,
1018         .llseek = default_llseek,
1019         .release = gpu_state_release,
1020 };
1021 #endif
1022
1023 static int i915_frequency_info(struct seq_file *m, void *unused)
1024 {
1025         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1026         struct intel_rps *rps = &dev_priv->gt_pm.rps;
1027         intel_wakeref_t wakeref;
1028         int ret = 0;
1029
1030         wakeref = intel_runtime_pm_get(dev_priv);
1031
1032         if (IS_GEN(dev_priv, 5)) {
1033                 u16 rgvswctl = I915_READ16(MEMSWCTL);
1034                 u16 rgvstat = I915_READ16(MEMSTAT_ILK);
1035
1036                 seq_printf(m, "Requested P-state: %d\n", (rgvswctl >> 8) & 0xf);
1037                 seq_printf(m, "Requested VID: %d\n", rgvswctl & 0x3f);
1038                 seq_printf(m, "Current VID: %d\n", (rgvstat & MEMSTAT_VID_MASK) >>
1039                            MEMSTAT_VID_SHIFT);
1040                 seq_printf(m, "Current P-state: %d\n",
1041                            (rgvstat & MEMSTAT_PSTATE_MASK) >> MEMSTAT_PSTATE_SHIFT);
1042         } else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1043                 u32 rpmodectl, freq_sts;
1044
1045                 mutex_lock(&dev_priv->pcu_lock);
1046
1047                 rpmodectl = I915_READ(GEN6_RP_CONTROL);
1048                 seq_printf(m, "Video Turbo Mode: %s\n",
1049                            yesno(rpmodectl & GEN6_RP_MEDIA_TURBO));
1050                 seq_printf(m, "HW control enabled: %s\n",
1051                            yesno(rpmodectl & GEN6_RP_ENABLE));
1052                 seq_printf(m, "SW control enabled: %s\n",
1053                            yesno((rpmodectl & GEN6_RP_MEDIA_MODE_MASK) ==
1054                                   GEN6_RP_MEDIA_SW_MODE));
1055
1056                 freq_sts = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS);
1057                 seq_printf(m, "PUNIT_REG_GPU_FREQ_STS: 0x%08x\n", freq_sts);
1058                 seq_printf(m, "DDR freq: %d MHz\n", dev_priv->mem_freq);
1059
1060                 seq_printf(m, "actual GPU freq: %d MHz\n",
1061                            intel_gpu_freq(dev_priv, (freq_sts >> 8) & 0xff));
1062
1063                 seq_printf(m, "current GPU freq: %d MHz\n",
1064                            intel_gpu_freq(dev_priv, rps->cur_freq));
1065
1066                 seq_printf(m, "max GPU freq: %d MHz\n",
1067                            intel_gpu_freq(dev_priv, rps->max_freq));
1068
1069                 seq_printf(m, "min GPU freq: %d MHz\n",
1070                            intel_gpu_freq(dev_priv, rps->min_freq));
1071
1072                 seq_printf(m, "idle GPU freq: %d MHz\n",
1073                            intel_gpu_freq(dev_priv, rps->idle_freq));
1074
1075                 seq_printf(m,
1076                            "efficient (RPe) frequency: %d MHz\n",
1077                            intel_gpu_freq(dev_priv, rps->efficient_freq));
1078                 mutex_unlock(&dev_priv->pcu_lock);
1079         } else if (INTEL_GEN(dev_priv) >= 6) {
1080                 u32 rp_state_limits;
1081                 u32 gt_perf_status;
1082                 u32 rp_state_cap;
1083                 u32 rpmodectl, rpinclimit, rpdeclimit;
1084                 u32 rpstat, cagf, reqf;
1085                 u32 rpupei, rpcurup, rpprevup;
1086                 u32 rpdownei, rpcurdown, rpprevdown;
1087                 u32 pm_ier, pm_imr, pm_isr, pm_iir, pm_mask;
1088                 int max_freq;
1089
1090                 rp_state_limits = I915_READ(GEN6_RP_STATE_LIMITS);
1091                 if (IS_GEN9_LP(dev_priv)) {
1092                         rp_state_cap = I915_READ(BXT_RP_STATE_CAP);
1093                         gt_perf_status = I915_READ(BXT_GT_PERF_STATUS);
1094                 } else {
1095                         rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
1096                         gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
1097                 }
1098
1099                 /* RPSTAT1 is in the GT power well */
1100                 intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
1101
1102                 reqf = I915_READ(GEN6_RPNSWREQ);
1103                 if (INTEL_GEN(dev_priv) >= 9)
1104                         reqf >>= 23;
1105                 else {
1106                         reqf &= ~GEN6_TURBO_DISABLE;
1107                         if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv))
1108                                 reqf >>= 24;
1109                         else
1110                                 reqf >>= 25;
1111                 }
1112                 reqf = intel_gpu_freq(dev_priv, reqf);
1113
1114                 rpmodectl = I915_READ(GEN6_RP_CONTROL);
1115                 rpinclimit = I915_READ(GEN6_RP_UP_THRESHOLD);
1116                 rpdeclimit = I915_READ(GEN6_RP_DOWN_THRESHOLD);
1117
1118                 rpstat = I915_READ(GEN6_RPSTAT1);
1119                 rpupei = I915_READ(GEN6_RP_CUR_UP_EI) & GEN6_CURICONT_MASK;
1120                 rpcurup = I915_READ(GEN6_RP_CUR_UP) & GEN6_CURBSYTAVG_MASK;
1121                 rpprevup = I915_READ(GEN6_RP_PREV_UP) & GEN6_CURBSYTAVG_MASK;
1122                 rpdownei = I915_READ(GEN6_RP_CUR_DOWN_EI) & GEN6_CURIAVG_MASK;
1123                 rpcurdown = I915_READ(GEN6_RP_CUR_DOWN) & GEN6_CURBSYTAVG_MASK;
1124                 rpprevdown = I915_READ(GEN6_RP_PREV_DOWN) & GEN6_CURBSYTAVG_MASK;
1125                 cagf = intel_gpu_freq(dev_priv,
1126                                       intel_get_cagf(dev_priv, rpstat));
1127
1128                 intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
1129
1130                 if (INTEL_GEN(dev_priv) >= 11) {
1131                         pm_ier = I915_READ(GEN11_GPM_WGBOXPERF_INTR_ENABLE);
1132                         pm_imr = I915_READ(GEN11_GPM_WGBOXPERF_INTR_MASK);
1133                         /*
1134                          * The equivalent to the PM ISR & IIR cannot be read
1135                          * without affecting the current state of the system
1136                          */
1137                         pm_isr = 0;
1138                         pm_iir = 0;
1139                 } else if (INTEL_GEN(dev_priv) >= 8) {
1140                         pm_ier = I915_READ(GEN8_GT_IER(2));
1141                         pm_imr = I915_READ(GEN8_GT_IMR(2));
1142                         pm_isr = I915_READ(GEN8_GT_ISR(2));
1143                         pm_iir = I915_READ(GEN8_GT_IIR(2));
1144                 } else {
1145                         pm_ier = I915_READ(GEN6_PMIER);
1146                         pm_imr = I915_READ(GEN6_PMIMR);
1147                         pm_isr = I915_READ(GEN6_PMISR);
1148                         pm_iir = I915_READ(GEN6_PMIIR);
1149                 }
1150                 pm_mask = I915_READ(GEN6_PMINTRMSK);
1151
1152                 seq_printf(m, "Video Turbo Mode: %s\n",
1153                            yesno(rpmodectl & GEN6_RP_MEDIA_TURBO));
1154                 seq_printf(m, "HW control enabled: %s\n",
1155                            yesno(rpmodectl & GEN6_RP_ENABLE));
1156                 seq_printf(m, "SW control enabled: %s\n",
1157                            yesno((rpmodectl & GEN6_RP_MEDIA_MODE_MASK) ==
1158                                   GEN6_RP_MEDIA_SW_MODE));
1159
1160                 seq_printf(m, "PM IER=0x%08x IMR=0x%08x, MASK=0x%08x\n",
1161                            pm_ier, pm_imr, pm_mask);
1162                 if (INTEL_GEN(dev_priv) <= 10)
1163                         seq_printf(m, "PM ISR=0x%08x IIR=0x%08x\n",
1164                                    pm_isr, pm_iir);
1165                 seq_printf(m, "pm_intrmsk_mbz: 0x%08x\n",
1166                            rps->pm_intrmsk_mbz);
1167                 seq_printf(m, "GT_PERF_STATUS: 0x%08x\n", gt_perf_status);
1168                 seq_printf(m, "Render p-state ratio: %d\n",
1169                            (gt_perf_status & (INTEL_GEN(dev_priv) >= 9 ? 0x1ff00 : 0xff00)) >> 8);
1170                 seq_printf(m, "Render p-state VID: %d\n",
1171                            gt_perf_status & 0xff);
1172                 seq_printf(m, "Render p-state limit: %d\n",
1173                            rp_state_limits & 0xff);
1174                 seq_printf(m, "RPSTAT1: 0x%08x\n", rpstat);
1175                 seq_printf(m, "RPMODECTL: 0x%08x\n", rpmodectl);
1176                 seq_printf(m, "RPINCLIMIT: 0x%08x\n", rpinclimit);
1177                 seq_printf(m, "RPDECLIMIT: 0x%08x\n", rpdeclimit);
1178                 seq_printf(m, "RPNSWREQ: %dMHz\n", reqf);
1179                 seq_printf(m, "CAGF: %dMHz\n", cagf);
1180                 seq_printf(m, "RP CUR UP EI: %d (%dus)\n",
1181                            rpupei, GT_PM_INTERVAL_TO_US(dev_priv, rpupei));
1182                 seq_printf(m, "RP CUR UP: %d (%dus)\n",
1183                            rpcurup, GT_PM_INTERVAL_TO_US(dev_priv, rpcurup));
1184                 seq_printf(m, "RP PREV UP: %d (%dus)\n",
1185                            rpprevup, GT_PM_INTERVAL_TO_US(dev_priv, rpprevup));
1186                 seq_printf(m, "Up threshold: %d%%\n",
1187                            rps->power.up_threshold);
1188
1189                 seq_printf(m, "RP CUR DOWN EI: %d (%dus)\n",
1190                            rpdownei, GT_PM_INTERVAL_TO_US(dev_priv, rpdownei));
1191                 seq_printf(m, "RP CUR DOWN: %d (%dus)\n",
1192                            rpcurdown, GT_PM_INTERVAL_TO_US(dev_priv, rpcurdown));
1193                 seq_printf(m, "RP PREV DOWN: %d (%dus)\n",
1194                            rpprevdown, GT_PM_INTERVAL_TO_US(dev_priv, rpprevdown));
1195                 seq_printf(m, "Down threshold: %d%%\n",
1196                            rps->power.down_threshold);
1197
1198                 max_freq = (IS_GEN9_LP(dev_priv) ? rp_state_cap >> 0 :
1199                             rp_state_cap >> 16) & 0xff;
1200                 max_freq *= (IS_GEN9_BC(dev_priv) ||
1201                              INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
1202                 seq_printf(m, "Lowest (RPN) frequency: %dMHz\n",
1203                            intel_gpu_freq(dev_priv, max_freq));
1204
1205                 max_freq = (rp_state_cap & 0xff00) >> 8;
1206                 max_freq *= (IS_GEN9_BC(dev_priv) ||
1207                              INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
1208                 seq_printf(m, "Nominal (RP1) frequency: %dMHz\n",
1209                            intel_gpu_freq(dev_priv, max_freq));
1210
1211                 max_freq = (IS_GEN9_LP(dev_priv) ? rp_state_cap >> 16 :
1212                             rp_state_cap >> 0) & 0xff;
1213                 max_freq *= (IS_GEN9_BC(dev_priv) ||
1214                              INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
1215                 seq_printf(m, "Max non-overclocked (RP0) frequency: %dMHz\n",
1216                            intel_gpu_freq(dev_priv, max_freq));
1217                 seq_printf(m, "Max overclocked frequency: %dMHz\n",
1218                            intel_gpu_freq(dev_priv, rps->max_freq));
1219
1220                 seq_printf(m, "Current freq: %d MHz\n",
1221                            intel_gpu_freq(dev_priv, rps->cur_freq));
1222                 seq_printf(m, "Actual freq: %d MHz\n", cagf);
1223                 seq_printf(m, "Idle freq: %d MHz\n",
1224                            intel_gpu_freq(dev_priv, rps->idle_freq));
1225                 seq_printf(m, "Min freq: %d MHz\n",
1226                            intel_gpu_freq(dev_priv, rps->min_freq));
1227                 seq_printf(m, "Boost freq: %d MHz\n",
1228                            intel_gpu_freq(dev_priv, rps->boost_freq));
1229                 seq_printf(m, "Max freq: %d MHz\n",
1230                            intel_gpu_freq(dev_priv, rps->max_freq));
1231                 seq_printf(m,
1232                            "efficient (RPe) frequency: %d MHz\n",
1233                            intel_gpu_freq(dev_priv, rps->efficient_freq));
1234         } else {
1235                 seq_puts(m, "no P-state info available\n");
1236         }
1237
1238         seq_printf(m, "Current CD clock frequency: %d kHz\n", dev_priv->cdclk.hw.cdclk);
1239         seq_printf(m, "Max CD clock frequency: %d kHz\n", dev_priv->max_cdclk_freq);
1240         seq_printf(m, "Max pixel clock frequency: %d kHz\n", dev_priv->max_dotclk_freq);
1241
1242         intel_runtime_pm_put(dev_priv, wakeref);
1243         return ret;
1244 }
1245
1246 static void i915_instdone_info(struct drm_i915_private *dev_priv,
1247                                struct seq_file *m,
1248                                struct intel_instdone *instdone)
1249 {
1250         int slice;
1251         int subslice;
1252
1253         seq_printf(m, "\t\tINSTDONE: 0x%08x\n",
1254                    instdone->instdone);
1255
1256         if (INTEL_GEN(dev_priv) <= 3)
1257                 return;
1258
1259         seq_printf(m, "\t\tSC_INSTDONE: 0x%08x\n",
1260                    instdone->slice_common);
1261
1262         if (INTEL_GEN(dev_priv) <= 6)
1263                 return;
1264
1265         for_each_instdone_slice_subslice(dev_priv, slice, subslice)
1266                 seq_printf(m, "\t\tSAMPLER_INSTDONE[%d][%d]: 0x%08x\n",
1267                            slice, subslice, instdone->sampler[slice][subslice]);
1268
1269         for_each_instdone_slice_subslice(dev_priv, slice, subslice)
1270                 seq_printf(m, "\t\tROW_INSTDONE[%d][%d]: 0x%08x\n",
1271                            slice, subslice, instdone->row[slice][subslice]);
1272 }
1273
1274 static int i915_hangcheck_info(struct seq_file *m, void *unused)
1275 {
1276         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1277         struct intel_engine_cs *engine;
1278         u64 acthd[I915_NUM_ENGINES];
1279         u32 seqno[I915_NUM_ENGINES];
1280         struct intel_instdone instdone;
1281         intel_wakeref_t wakeref;
1282         enum intel_engine_id id;
1283
1284         if (test_bit(I915_WEDGED, &dev_priv->gpu_error.flags))
1285                 seq_puts(m, "Wedged\n");
1286         if (test_bit(I915_RESET_BACKOFF, &dev_priv->gpu_error.flags))
1287                 seq_puts(m, "Reset in progress: struct_mutex backoff\n");
1288         if (waitqueue_active(&dev_priv->gpu_error.wait_queue))
1289                 seq_puts(m, "Waiter holding struct mutex\n");
1290         if (waitqueue_active(&dev_priv->gpu_error.reset_queue))
1291                 seq_puts(m, "struct_mutex blocked for reset\n");
1292
1293         if (!i915_modparams.enable_hangcheck) {
1294                 seq_puts(m, "Hangcheck disabled\n");
1295                 return 0;
1296         }
1297
1298         with_intel_runtime_pm(dev_priv, wakeref) {
1299                 for_each_engine(engine, dev_priv, id) {
1300                         acthd[id] = intel_engine_get_active_head(engine);
1301                         seqno[id] = intel_engine_get_seqno(engine);
1302                 }
1303
1304                 intel_engine_get_instdone(dev_priv->engine[RCS], &instdone);
1305         }
1306
1307         if (timer_pending(&dev_priv->gpu_error.hangcheck_work.timer))
1308                 seq_printf(m, "Hangcheck active, timer fires in %dms\n",
1309                            jiffies_to_msecs(dev_priv->gpu_error.hangcheck_work.timer.expires -
1310                                             jiffies));
1311         else if (delayed_work_pending(&dev_priv->gpu_error.hangcheck_work))
1312                 seq_puts(m, "Hangcheck active, work pending\n");
1313         else
1314                 seq_puts(m, "Hangcheck inactive\n");
1315
1316         seq_printf(m, "GT active? %s\n", yesno(dev_priv->gt.awake));
1317
1318         for_each_engine(engine, dev_priv, id) {
1319                 seq_printf(m, "%s:\n", engine->name);
1320                 seq_printf(m, "\tseqno = %x [current %x, last %x], %dms ago\n",
1321                            engine->hangcheck.seqno, seqno[id],
1322                            intel_engine_last_submit(engine),
1323                            jiffies_to_msecs(jiffies -
1324                                             engine->hangcheck.action_timestamp));
1325
1326                 seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n",
1327                            (long long)engine->hangcheck.acthd,
1328                            (long long)acthd[id]);
1329
1330                 if (engine->id == RCS) {
1331                         seq_puts(m, "\tinstdone read =\n");
1332
1333                         i915_instdone_info(dev_priv, m, &instdone);
1334
1335                         seq_puts(m, "\tinstdone accu =\n");
1336
1337                         i915_instdone_info(dev_priv, m,
1338                                            &engine->hangcheck.instdone);
1339                 }
1340         }
1341
1342         return 0;
1343 }
1344
1345 static int i915_reset_info(struct seq_file *m, void *unused)
1346 {
1347         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1348         struct i915_gpu_error *error = &dev_priv->gpu_error;
1349         struct intel_engine_cs *engine;
1350         enum intel_engine_id id;
1351
1352         seq_printf(m, "full gpu reset = %u\n", i915_reset_count(error));
1353
1354         for_each_engine(engine, dev_priv, id) {
1355                 seq_printf(m, "%s = %u\n", engine->name,
1356                            i915_reset_engine_count(error, engine));
1357         }
1358
1359         return 0;
1360 }
1361
1362 static int ironlake_drpc_info(struct seq_file *m)
1363 {
1364         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1365         u32 rgvmodectl, rstdbyctl;
1366         u16 crstandvid;
1367
1368         rgvmodectl = I915_READ(MEMMODECTL);
1369         rstdbyctl = I915_READ(RSTDBYCTL);
1370         crstandvid = I915_READ16(CRSTANDVID);
1371
1372         seq_printf(m, "HD boost: %s\n", yesno(rgvmodectl & MEMMODE_BOOST_EN));
1373         seq_printf(m, "Boost freq: %d\n",
1374                    (rgvmodectl & MEMMODE_BOOST_FREQ_MASK) >>
1375                    MEMMODE_BOOST_FREQ_SHIFT);
1376         seq_printf(m, "HW control enabled: %s\n",
1377                    yesno(rgvmodectl & MEMMODE_HWIDLE_EN));
1378         seq_printf(m, "SW control enabled: %s\n",
1379                    yesno(rgvmodectl & MEMMODE_SWMODE_EN));
1380         seq_printf(m, "Gated voltage change: %s\n",
1381                    yesno(rgvmodectl & MEMMODE_RCLK_GATE));
1382         seq_printf(m, "Starting frequency: P%d\n",
1383                    (rgvmodectl & MEMMODE_FSTART_MASK) >> MEMMODE_FSTART_SHIFT);
1384         seq_printf(m, "Max P-state: P%d\n",
1385                    (rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT);
1386         seq_printf(m, "Min P-state: P%d\n", (rgvmodectl & MEMMODE_FMIN_MASK));
1387         seq_printf(m, "RS1 VID: %d\n", (crstandvid & 0x3f));
1388         seq_printf(m, "RS2 VID: %d\n", ((crstandvid >> 8) & 0x3f));
1389         seq_printf(m, "Render standby enabled: %s\n",
1390                    yesno(!(rstdbyctl & RCX_SW_EXIT)));
1391         seq_puts(m, "Current RS state: ");
1392         switch (rstdbyctl & RSX_STATUS_MASK) {
1393         case RSX_STATUS_ON:
1394                 seq_puts(m, "on\n");
1395                 break;
1396         case RSX_STATUS_RC1:
1397                 seq_puts(m, "RC1\n");
1398                 break;
1399         case RSX_STATUS_RC1E:
1400                 seq_puts(m, "RC1E\n");
1401                 break;
1402         case RSX_STATUS_RS1:
1403                 seq_puts(m, "RS1\n");
1404                 break;
1405         case RSX_STATUS_RS2:
1406                 seq_puts(m, "RS2 (RC6)\n");
1407                 break;
1408         case RSX_STATUS_RS3:
1409                 seq_puts(m, "RC3 (RC6+)\n");
1410                 break;
1411         default:
1412                 seq_puts(m, "unknown\n");
1413                 break;
1414         }
1415
1416         return 0;
1417 }
1418
1419 static int i915_forcewake_domains(struct seq_file *m, void *data)
1420 {
1421         struct drm_i915_private *i915 = node_to_i915(m->private);
1422         struct intel_uncore_forcewake_domain *fw_domain;
1423         unsigned int tmp;
1424
1425         seq_printf(m, "user.bypass_count = %u\n",
1426                    i915->uncore.user_forcewake.count);
1427
1428         for_each_fw_domain(fw_domain, i915, tmp)
1429                 seq_printf(m, "%s.wake_count = %u\n",
1430                            intel_uncore_forcewake_domain_to_str(fw_domain->id),
1431                            READ_ONCE(fw_domain->wake_count));
1432
1433         return 0;
1434 }
1435
1436 static void print_rc6_res(struct seq_file *m,
1437                           const char *title,
1438                           const i915_reg_t reg)
1439 {
1440         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1441
1442         seq_printf(m, "%s %u (%llu us)\n",
1443                    title, I915_READ(reg),
1444                    intel_rc6_residency_us(dev_priv, reg));
1445 }
1446
1447 static int vlv_drpc_info(struct seq_file *m)
1448 {
1449         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1450         u32 rcctl1, pw_status;
1451
1452         pw_status = I915_READ(VLV_GTLC_PW_STATUS);
1453         rcctl1 = I915_READ(GEN6_RC_CONTROL);
1454
1455         seq_printf(m, "RC6 Enabled: %s\n",
1456                    yesno(rcctl1 & (GEN7_RC_CTL_TO_MODE |
1457                                         GEN6_RC_CTL_EI_MODE(1))));
1458         seq_printf(m, "Render Power Well: %s\n",
1459                    (pw_status & VLV_GTLC_PW_RENDER_STATUS_MASK) ? "Up" : "Down");
1460         seq_printf(m, "Media Power Well: %s\n",
1461                    (pw_status & VLV_GTLC_PW_MEDIA_STATUS_MASK) ? "Up" : "Down");
1462
1463         print_rc6_res(m, "Render RC6 residency since boot:", VLV_GT_RENDER_RC6);
1464         print_rc6_res(m, "Media RC6 residency since boot:", VLV_GT_MEDIA_RC6);
1465
1466         return i915_forcewake_domains(m, NULL);
1467 }
1468
1469 static int gen6_drpc_info(struct seq_file *m)
1470 {
1471         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1472         u32 gt_core_status, rcctl1, rc6vids = 0;
1473         u32 gen9_powergate_enable = 0, gen9_powergate_status = 0;
1474
1475         gt_core_status = I915_READ_FW(GEN6_GT_CORE_STATUS);
1476         trace_i915_reg_rw(false, GEN6_GT_CORE_STATUS, gt_core_status, 4, true);
1477
1478         rcctl1 = I915_READ(GEN6_RC_CONTROL);
1479         if (INTEL_GEN(dev_priv) >= 9) {
1480                 gen9_powergate_enable = I915_READ(GEN9_PG_ENABLE);
1481                 gen9_powergate_status = I915_READ(GEN9_PWRGT_DOMAIN_STATUS);
1482         }
1483
1484         if (INTEL_GEN(dev_priv) <= 7) {
1485                 mutex_lock(&dev_priv->pcu_lock);
1486                 sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS,
1487                                        &rc6vids);
1488                 mutex_unlock(&dev_priv->pcu_lock);
1489         }
1490
1491         seq_printf(m, "RC1e Enabled: %s\n",
1492                    yesno(rcctl1 & GEN6_RC_CTL_RC1e_ENABLE));
1493         seq_printf(m, "RC6 Enabled: %s\n",
1494                    yesno(rcctl1 & GEN6_RC_CTL_RC6_ENABLE));
1495         if (INTEL_GEN(dev_priv) >= 9) {
1496                 seq_printf(m, "Render Well Gating Enabled: %s\n",
1497                         yesno(gen9_powergate_enable & GEN9_RENDER_PG_ENABLE));
1498                 seq_printf(m, "Media Well Gating Enabled: %s\n",
1499                         yesno(gen9_powergate_enable & GEN9_MEDIA_PG_ENABLE));
1500         }
1501         seq_printf(m, "Deep RC6 Enabled: %s\n",
1502                    yesno(rcctl1 & GEN6_RC_CTL_RC6p_ENABLE));
1503         seq_printf(m, "Deepest RC6 Enabled: %s\n",
1504                    yesno(rcctl1 & GEN6_RC_CTL_RC6pp_ENABLE));
1505         seq_puts(m, "Current RC state: ");
1506         switch (gt_core_status & GEN6_RCn_MASK) {
1507         case GEN6_RC0:
1508                 if (gt_core_status & GEN6_CORE_CPD_STATE_MASK)
1509                         seq_puts(m, "Core Power Down\n");
1510                 else
1511                         seq_puts(m, "on\n");
1512                 break;
1513         case GEN6_RC3:
1514                 seq_puts(m, "RC3\n");
1515                 break;
1516         case GEN6_RC6:
1517                 seq_puts(m, "RC6\n");
1518                 break;
1519         case GEN6_RC7:
1520                 seq_puts(m, "RC7\n");
1521                 break;
1522         default:
1523                 seq_puts(m, "Unknown\n");
1524                 break;
1525         }
1526
1527         seq_printf(m, "Core Power Down: %s\n",
1528                    yesno(gt_core_status & GEN6_CORE_CPD_STATE_MASK));
1529         if (INTEL_GEN(dev_priv) >= 9) {
1530                 seq_printf(m, "Render Power Well: %s\n",
1531                         (gen9_powergate_status &
1532                          GEN9_PWRGT_RENDER_STATUS_MASK) ? "Up" : "Down");
1533                 seq_printf(m, "Media Power Well: %s\n",
1534                         (gen9_powergate_status &
1535                          GEN9_PWRGT_MEDIA_STATUS_MASK) ? "Up" : "Down");
1536         }
1537
1538         /* Not exactly sure what this is */
1539         print_rc6_res(m, "RC6 \"Locked to RPn\" residency since boot:",
1540                       GEN6_GT_GFX_RC6_LOCKED);
1541         print_rc6_res(m, "RC6 residency since boot:", GEN6_GT_GFX_RC6);
1542         print_rc6_res(m, "RC6+ residency since boot:", GEN6_GT_GFX_RC6p);
1543         print_rc6_res(m, "RC6++ residency since boot:", GEN6_GT_GFX_RC6pp);
1544
1545         if (INTEL_GEN(dev_priv) <= 7) {
1546                 seq_printf(m, "RC6   voltage: %dmV\n",
1547                            GEN6_DECODE_RC6_VID(((rc6vids >> 0) & 0xff)));
1548                 seq_printf(m, "RC6+  voltage: %dmV\n",
1549                            GEN6_DECODE_RC6_VID(((rc6vids >> 8) & 0xff)));
1550                 seq_printf(m, "RC6++ voltage: %dmV\n",
1551                            GEN6_DECODE_RC6_VID(((rc6vids >> 16) & 0xff)));
1552         }
1553
1554         return i915_forcewake_domains(m, NULL);
1555 }
1556
1557 static int i915_drpc_info(struct seq_file *m, void *unused)
1558 {
1559         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1560         intel_wakeref_t wakeref;
1561         int err = -ENODEV;
1562
1563         with_intel_runtime_pm(dev_priv, wakeref) {
1564                 if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
1565                         err = vlv_drpc_info(m);
1566                 else if (INTEL_GEN(dev_priv) >= 6)
1567                         err = gen6_drpc_info(m);
1568                 else
1569                         err = ironlake_drpc_info(m);
1570         }
1571
1572         return err;
1573 }
1574
1575 static int i915_frontbuffer_tracking(struct seq_file *m, void *unused)
1576 {
1577         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1578
1579         seq_printf(m, "FB tracking busy bits: 0x%08x\n",
1580                    dev_priv->fb_tracking.busy_bits);
1581
1582         seq_printf(m, "FB tracking flip bits: 0x%08x\n",
1583                    dev_priv->fb_tracking.flip_bits);
1584
1585         return 0;
1586 }
1587
1588 static int i915_fbc_status(struct seq_file *m, void *unused)
1589 {
1590         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1591         struct intel_fbc *fbc = &dev_priv->fbc;
1592         intel_wakeref_t wakeref;
1593
1594         if (!HAS_FBC(dev_priv))
1595                 return -ENODEV;
1596
1597         wakeref = intel_runtime_pm_get(dev_priv);
1598         mutex_lock(&fbc->lock);
1599
1600         if (intel_fbc_is_active(dev_priv))
1601                 seq_puts(m, "FBC enabled\n");
1602         else
1603                 seq_printf(m, "FBC disabled: %s\n", fbc->no_fbc_reason);
1604
1605         if (intel_fbc_is_active(dev_priv)) {
1606                 u32 mask;
1607
1608                 if (INTEL_GEN(dev_priv) >= 8)
1609                         mask = I915_READ(IVB_FBC_STATUS2) & BDW_FBC_COMP_SEG_MASK;
1610                 else if (INTEL_GEN(dev_priv) >= 7)
1611                         mask = I915_READ(IVB_FBC_STATUS2) & IVB_FBC_COMP_SEG_MASK;
1612                 else if (INTEL_GEN(dev_priv) >= 5)
1613                         mask = I915_READ(ILK_DPFC_STATUS) & ILK_DPFC_COMP_SEG_MASK;
1614                 else if (IS_G4X(dev_priv))
1615                         mask = I915_READ(DPFC_STATUS) & DPFC_COMP_SEG_MASK;
1616                 else
1617                         mask = I915_READ(FBC_STATUS) & (FBC_STAT_COMPRESSING |
1618                                                         FBC_STAT_COMPRESSED);
1619
1620                 seq_printf(m, "Compressing: %s\n", yesno(mask));
1621         }
1622
1623         mutex_unlock(&fbc->lock);
1624         intel_runtime_pm_put(dev_priv, wakeref);
1625
1626         return 0;
1627 }
1628
1629 static int i915_fbc_false_color_get(void *data, u64 *val)
1630 {
1631         struct drm_i915_private *dev_priv = data;
1632
1633         if (INTEL_GEN(dev_priv) < 7 || !HAS_FBC(dev_priv))
1634                 return -ENODEV;
1635
1636         *val = dev_priv->fbc.false_color;
1637
1638         return 0;
1639 }
1640
1641 static int i915_fbc_false_color_set(void *data, u64 val)
1642 {
1643         struct drm_i915_private *dev_priv = data;
1644         u32 reg;
1645
1646         if (INTEL_GEN(dev_priv) < 7 || !HAS_FBC(dev_priv))
1647                 return -ENODEV;
1648
1649         mutex_lock(&dev_priv->fbc.lock);
1650
1651         reg = I915_READ(ILK_DPFC_CONTROL);
1652         dev_priv->fbc.false_color = val;
1653
1654         I915_WRITE(ILK_DPFC_CONTROL, val ?
1655                    (reg | FBC_CTL_FALSE_COLOR) :
1656                    (reg & ~FBC_CTL_FALSE_COLOR));
1657
1658         mutex_unlock(&dev_priv->fbc.lock);
1659         return 0;
1660 }
1661
1662 DEFINE_SIMPLE_ATTRIBUTE(i915_fbc_false_color_fops,
1663                         i915_fbc_false_color_get, i915_fbc_false_color_set,
1664                         "%llu\n");
1665
1666 static int i915_ips_status(struct seq_file *m, void *unused)
1667 {
1668         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1669         intel_wakeref_t wakeref;
1670
1671         if (!HAS_IPS(dev_priv))
1672                 return -ENODEV;
1673
1674         wakeref = intel_runtime_pm_get(dev_priv);
1675
1676         seq_printf(m, "Enabled by kernel parameter: %s\n",
1677                    yesno(i915_modparams.enable_ips));
1678
1679         if (INTEL_GEN(dev_priv) >= 8) {
1680                 seq_puts(m, "Currently: unknown\n");
1681         } else {
1682                 if (I915_READ(IPS_CTL) & IPS_ENABLE)
1683                         seq_puts(m, "Currently: enabled\n");
1684                 else
1685                         seq_puts(m, "Currently: disabled\n");
1686         }
1687
1688         intel_runtime_pm_put(dev_priv, wakeref);
1689
1690         return 0;
1691 }
1692
1693 static int i915_sr_status(struct seq_file *m, void *unused)
1694 {
1695         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1696         intel_wakeref_t wakeref;
1697         bool sr_enabled = false;
1698
1699         wakeref = intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
1700
1701         if (INTEL_GEN(dev_priv) >= 9)
1702                 /* no global SR status; inspect per-plane WM */;
1703         else if (HAS_PCH_SPLIT(dev_priv))
1704                 sr_enabled = I915_READ(WM1_LP_ILK) & WM1_LP_SR_EN;
1705         else if (IS_I965GM(dev_priv) || IS_G4X(dev_priv) ||
1706                  IS_I945G(dev_priv) || IS_I945GM(dev_priv))
1707                 sr_enabled = I915_READ(FW_BLC_SELF) & FW_BLC_SELF_EN;
1708         else if (IS_I915GM(dev_priv))
1709                 sr_enabled = I915_READ(INSTPM) & INSTPM_SELF_EN;
1710         else if (IS_PINEVIEW(dev_priv))
1711                 sr_enabled = I915_READ(DSPFW3) & PINEVIEW_SELF_REFRESH_EN;
1712         else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
1713                 sr_enabled = I915_READ(FW_BLC_SELF_VLV) & FW_CSPWRDWNEN;
1714
1715         intel_display_power_put(dev_priv, POWER_DOMAIN_INIT, wakeref);
1716
1717         seq_printf(m, "self-refresh: %s\n", enableddisabled(sr_enabled));
1718
1719         return 0;
1720 }
1721
1722 static int i915_emon_status(struct seq_file *m, void *unused)
1723 {
1724         struct drm_i915_private *i915 = node_to_i915(m->private);
1725         intel_wakeref_t wakeref;
1726
1727         if (!IS_GEN(i915, 5))
1728                 return -ENODEV;
1729
1730         with_intel_runtime_pm(i915, wakeref) {
1731                 unsigned long temp, chipset, gfx;
1732
1733                 temp = i915_mch_val(i915);
1734                 chipset = i915_chipset_val(i915);
1735                 gfx = i915_gfx_val(i915);
1736
1737                 seq_printf(m, "GMCH temp: %ld\n", temp);
1738                 seq_printf(m, "Chipset power: %ld\n", chipset);
1739                 seq_printf(m, "GFX power: %ld\n", gfx);
1740                 seq_printf(m, "Total power: %ld\n", chipset + gfx);
1741         }
1742
1743         return 0;
1744 }
1745
1746 static int i915_ring_freq_table(struct seq_file *m, void *unused)
1747 {
1748         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1749         struct intel_rps *rps = &dev_priv->gt_pm.rps;
1750         unsigned int max_gpu_freq, min_gpu_freq;
1751         intel_wakeref_t wakeref;
1752         int gpu_freq, ia_freq;
1753         int ret;
1754
1755         if (!HAS_LLC(dev_priv))
1756                 return -ENODEV;
1757
1758         wakeref = intel_runtime_pm_get(dev_priv);
1759
1760         ret = mutex_lock_interruptible(&dev_priv->pcu_lock);
1761         if (ret)
1762                 goto out;
1763
1764         min_gpu_freq = rps->min_freq;
1765         max_gpu_freq = rps->max_freq;
1766         if (IS_GEN9_BC(dev_priv) || INTEL_GEN(dev_priv) >= 10) {
1767                 /* Convert GT frequency to 50 HZ units */
1768                 min_gpu_freq /= GEN9_FREQ_SCALER;
1769                 max_gpu_freq /= GEN9_FREQ_SCALER;
1770         }
1771
1772         seq_puts(m, "GPU freq (MHz)\tEffective CPU freq (MHz)\tEffective Ring freq (MHz)\n");
1773
1774         for (gpu_freq = min_gpu_freq; gpu_freq <= max_gpu_freq; gpu_freq++) {
1775                 ia_freq = gpu_freq;
1776                 sandybridge_pcode_read(dev_priv,
1777                                        GEN6_PCODE_READ_MIN_FREQ_TABLE,
1778                                        &ia_freq);
1779                 seq_printf(m, "%d\t\t%d\t\t\t\t%d\n",
1780                            intel_gpu_freq(dev_priv, (gpu_freq *
1781                                                      (IS_GEN9_BC(dev_priv) ||
1782                                                       INTEL_GEN(dev_priv) >= 10 ?
1783                                                       GEN9_FREQ_SCALER : 1))),
1784                            ((ia_freq >> 0) & 0xff) * 100,
1785                            ((ia_freq >> 8) & 0xff) * 100);
1786         }
1787
1788         mutex_unlock(&dev_priv->pcu_lock);
1789
1790 out:
1791         intel_runtime_pm_put(dev_priv, wakeref);
1792         return ret;
1793 }
1794
1795 static int i915_opregion(struct seq_file *m, void *unused)
1796 {
1797         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1798         struct drm_device *dev = &dev_priv->drm;
1799         struct intel_opregion *opregion = &dev_priv->opregion;
1800         int ret;
1801
1802         ret = mutex_lock_interruptible(&dev->struct_mutex);
1803         if (ret)
1804                 goto out;
1805
1806         if (opregion->header)
1807                 seq_write(m, opregion->header, OPREGION_SIZE);
1808
1809         mutex_unlock(&dev->struct_mutex);
1810
1811 out:
1812         return 0;
1813 }
1814
1815 static int i915_vbt(struct seq_file *m, void *unused)
1816 {
1817         struct intel_opregion *opregion = &node_to_i915(m->private)->opregion;
1818
1819         if (opregion->vbt)
1820                 seq_write(m, opregion->vbt, opregion->vbt_size);
1821
1822         return 0;
1823 }
1824
1825 static int i915_gem_framebuffer_info(struct seq_file *m, void *data)
1826 {
1827         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1828         struct drm_device *dev = &dev_priv->drm;
1829         struct intel_framebuffer *fbdev_fb = NULL;
1830         struct drm_framebuffer *drm_fb;
1831         int ret;
1832
1833         ret = mutex_lock_interruptible(&dev->struct_mutex);
1834         if (ret)
1835                 return ret;
1836
1837 #ifdef CONFIG_DRM_FBDEV_EMULATION
1838         if (dev_priv->fbdev && dev_priv->fbdev->helper.fb) {
1839                 fbdev_fb = to_intel_framebuffer(dev_priv->fbdev->helper.fb);
1840
1841                 seq_printf(m, "fbcon size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
1842                            fbdev_fb->base.width,
1843                            fbdev_fb->base.height,
1844                            fbdev_fb->base.format->depth,
1845                            fbdev_fb->base.format->cpp[0] * 8,
1846                            fbdev_fb->base.modifier,
1847                            drm_framebuffer_read_refcount(&fbdev_fb->base));
1848                 describe_obj(m, intel_fb_obj(&fbdev_fb->base));
1849                 seq_putc(m, '\n');
1850         }
1851 #endif
1852
1853         mutex_lock(&dev->mode_config.fb_lock);
1854         drm_for_each_fb(drm_fb, dev) {
1855                 struct intel_framebuffer *fb = to_intel_framebuffer(drm_fb);
1856                 if (fb == fbdev_fb)
1857                         continue;
1858
1859                 seq_printf(m, "user size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
1860                            fb->base.width,
1861                            fb->base.height,
1862                            fb->base.format->depth,
1863                            fb->base.format->cpp[0] * 8,
1864                            fb->base.modifier,
1865                            drm_framebuffer_read_refcount(&fb->base));
1866                 describe_obj(m, intel_fb_obj(&fb->base));
1867                 seq_putc(m, '\n');
1868         }
1869         mutex_unlock(&dev->mode_config.fb_lock);
1870         mutex_unlock(&dev->struct_mutex);
1871
1872         return 0;
1873 }
1874
1875 static void describe_ctx_ring(struct seq_file *m, struct intel_ring *ring)
1876 {
1877         seq_printf(m, " (ringbuffer, space: %d, head: %u, tail: %u, emit: %u)",
1878                    ring->space, ring->head, ring->tail, ring->emit);
1879 }
1880
1881 static int i915_context_status(struct seq_file *m, void *unused)
1882 {
1883         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1884         struct drm_device *dev = &dev_priv->drm;
1885         struct intel_engine_cs *engine;
1886         struct i915_gem_context *ctx;
1887         enum intel_engine_id id;
1888         int ret;
1889
1890         ret = mutex_lock_interruptible(&dev->struct_mutex);
1891         if (ret)
1892                 return ret;
1893
1894         list_for_each_entry(ctx, &dev_priv->contexts.list, link) {
1895                 seq_puts(m, "HW context ");
1896                 if (!list_empty(&ctx->hw_id_link))
1897                         seq_printf(m, "%x [pin %u]", ctx->hw_id,
1898                                    atomic_read(&ctx->hw_id_pin_count));
1899                 if (ctx->pid) {
1900                         struct task_struct *task;
1901
1902                         task = get_pid_task(ctx->pid, PIDTYPE_PID);
1903                         if (task) {
1904                                 seq_printf(m, "(%s [%d]) ",
1905                                            task->comm, task->pid);
1906                                 put_task_struct(task);
1907                         }
1908                 } else if (IS_ERR(ctx->file_priv)) {
1909                         seq_puts(m, "(deleted) ");
1910                 } else {
1911                         seq_puts(m, "(kernel) ");
1912                 }
1913
1914                 seq_putc(m, ctx->remap_slice ? 'R' : 'r');
1915                 seq_putc(m, '\n');
1916
1917                 for_each_engine(engine, dev_priv, id) {
1918                         struct intel_context *ce =
1919                                 to_intel_context(ctx, engine);
1920
1921                         seq_printf(m, "%s: ", engine->name);
1922                         if (ce->state)
1923                                 describe_obj(m, ce->state->obj);
1924                         if (ce->ring)
1925                                 describe_ctx_ring(m, ce->ring);
1926                         seq_putc(m, '\n');
1927                 }
1928
1929                 seq_putc(m, '\n');
1930         }
1931
1932         mutex_unlock(&dev->struct_mutex);
1933
1934         return 0;
1935 }
1936
1937 static const char *swizzle_string(unsigned swizzle)
1938 {
1939         switch (swizzle) {
1940         case I915_BIT_6_SWIZZLE_NONE:
1941                 return "none";
1942         case I915_BIT_6_SWIZZLE_9:
1943                 return "bit9";
1944         case I915_BIT_6_SWIZZLE_9_10:
1945                 return "bit9/bit10";
1946         case I915_BIT_6_SWIZZLE_9_11:
1947                 return "bit9/bit11";
1948         case I915_BIT_6_SWIZZLE_9_10_11:
1949                 return "bit9/bit10/bit11";
1950         case I915_BIT_6_SWIZZLE_9_17:
1951                 return "bit9/bit17";
1952         case I915_BIT_6_SWIZZLE_9_10_17:
1953                 return "bit9/bit10/bit17";
1954         case I915_BIT_6_SWIZZLE_UNKNOWN:
1955                 return "unknown";
1956         }
1957
1958         return "bug";
1959 }
1960
1961 static int i915_swizzle_info(struct seq_file *m, void *data)
1962 {
1963         struct drm_i915_private *dev_priv = node_to_i915(m->private);
1964         intel_wakeref_t wakeref;
1965
1966         wakeref = intel_runtime_pm_get(dev_priv);
1967
1968         seq_printf(m, "bit6 swizzle for X-tiling = %s\n",
1969                    swizzle_string(dev_priv->mm.bit_6_swizzle_x));
1970         seq_printf(m, "bit6 swizzle for Y-tiling = %s\n",
1971                    swizzle_string(dev_priv->mm.bit_6_swizzle_y));
1972
1973         if (IS_GEN_RANGE(dev_priv, 3, 4)) {
1974                 seq_printf(m, "DDC = 0x%08x\n",
1975                            I915_READ(DCC));
1976                 seq_printf(m, "DDC2 = 0x%08x\n",
1977                            I915_READ(DCC2));
1978                 seq_printf(m, "C0DRB3 = 0x%04x\n",
1979                            I915_READ16(C0DRB3));
1980                 seq_printf(m, "C1DRB3 = 0x%04x\n",
1981                            I915_READ16(C1DRB3));
1982         } else if (INTEL_GEN(dev_priv) >= 6) {
1983                 seq_printf(m, "MAD_DIMM_C0 = 0x%08x\n",
1984                            I915_READ(MAD_DIMM_C0));
1985                 seq_printf(m, "MAD_DIMM_C1 = 0x%08x\n",
1986                            I915_READ(MAD_DIMM_C1));
1987                 seq_printf(m, "MAD_DIMM_C2 = 0x%08x\n",
1988                            I915_READ(MAD_DIMM_C2));
1989                 seq_printf(m, "TILECTL = 0x%08x\n",
1990                            I915_READ(TILECTL));
1991                 if (INTEL_GEN(dev_priv) >= 8)
1992                         seq_printf(m, "GAMTARBMODE = 0x%08x\n",
1993                                    I915_READ(GAMTARBMODE));
1994                 else
1995                         seq_printf(m, "ARB_MODE = 0x%08x\n",
1996                                    I915_READ(ARB_MODE));
1997                 seq_printf(m, "DISP_ARB_CTL = 0x%08x\n",
1998                            I915_READ(DISP_ARB_CTL));
1999         }
2000
2001         if (dev_priv->quirks & QUIRK_PIN_SWIZZLED_PAGES)
2002                 seq_puts(m, "L-shaped memory detected\n");
2003
2004         intel_runtime_pm_put(dev_priv, wakeref);
2005
2006         return 0;
2007 }
2008
2009 static const char *rps_power_to_str(unsigned int power)
2010 {
2011         static const char * const strings[] = {
2012                 [LOW_POWER] = "low power",
2013                 [BETWEEN] = "mixed",
2014                 [HIGH_POWER] = "high power",
2015         };
2016
2017         if (power >= ARRAY_SIZE(strings) || !strings[power])
2018                 return "unknown";
2019
2020         return strings[power];
2021 }
2022
2023 static int i915_rps_boost_info(struct seq_file *m, void *data)
2024 {
2025         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2026         struct drm_device *dev = &dev_priv->drm;
2027         struct intel_rps *rps = &dev_priv->gt_pm.rps;
2028         u32 act_freq = rps->cur_freq;
2029         intel_wakeref_t wakeref;
2030         struct drm_file *file;
2031
2032         with_intel_runtime_pm_if_in_use(dev_priv, wakeref) {
2033                 if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
2034                         mutex_lock(&dev_priv->pcu_lock);
2035                         act_freq = vlv_punit_read(dev_priv,
2036                                                   PUNIT_REG_GPU_FREQ_STS);
2037                         act_freq = (act_freq >> 8) & 0xff;
2038                         mutex_unlock(&dev_priv->pcu_lock);
2039                 } else {
2040                         act_freq = intel_get_cagf(dev_priv,
2041                                                   I915_READ(GEN6_RPSTAT1));
2042                 }
2043         }
2044
2045         seq_printf(m, "RPS enabled? %d\n", rps->enabled);
2046         seq_printf(m, "GPU busy? %s [%d requests]\n",
2047                    yesno(dev_priv->gt.awake), dev_priv->gt.active_requests);
2048         seq_printf(m, "Boosts outstanding? %d\n",
2049                    atomic_read(&rps->num_waiters));
2050         seq_printf(m, "Interactive? %d\n", READ_ONCE(rps->power.interactive));
2051         seq_printf(m, "Frequency requested %d, actual %d\n",
2052                    intel_gpu_freq(dev_priv, rps->cur_freq),
2053                    intel_gpu_freq(dev_priv, act_freq));
2054         seq_printf(m, "  min hard:%d, soft:%d; max soft:%d, hard:%d\n",
2055                    intel_gpu_freq(dev_priv, rps->min_freq),
2056                    intel_gpu_freq(dev_priv, rps->min_freq_softlimit),
2057                    intel_gpu_freq(dev_priv, rps->max_freq_softlimit),
2058                    intel_gpu_freq(dev_priv, rps->max_freq));
2059         seq_printf(m, "  idle:%d, efficient:%d, boost:%d\n",
2060                    intel_gpu_freq(dev_priv, rps->idle_freq),
2061                    intel_gpu_freq(dev_priv, rps->efficient_freq),
2062                    intel_gpu_freq(dev_priv, rps->boost_freq));
2063
2064         mutex_lock(&dev->filelist_mutex);
2065         list_for_each_entry_reverse(file, &dev->filelist, lhead) {
2066                 struct drm_i915_file_private *file_priv = file->driver_priv;
2067                 struct task_struct *task;
2068
2069                 rcu_read_lock();
2070                 task = pid_task(file->pid, PIDTYPE_PID);
2071                 seq_printf(m, "%s [%d]: %d boosts\n",
2072                            task ? task->comm : "<unknown>",
2073                            task ? task->pid : -1,
2074                            atomic_read(&file_priv->rps_client.boosts));
2075                 rcu_read_unlock();
2076         }
2077         seq_printf(m, "Kernel (anonymous) boosts: %d\n",
2078                    atomic_read(&rps->boosts));
2079         mutex_unlock(&dev->filelist_mutex);
2080
2081         if (INTEL_GEN(dev_priv) >= 6 &&
2082             rps->enabled &&
2083             dev_priv->gt.active_requests) {
2084                 u32 rpup, rpupei;
2085                 u32 rpdown, rpdownei;
2086
2087                 intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
2088                 rpup = I915_READ_FW(GEN6_RP_CUR_UP) & GEN6_RP_EI_MASK;
2089                 rpupei = I915_READ_FW(GEN6_RP_CUR_UP_EI) & GEN6_RP_EI_MASK;
2090                 rpdown = I915_READ_FW(GEN6_RP_CUR_DOWN) & GEN6_RP_EI_MASK;
2091                 rpdownei = I915_READ_FW(GEN6_RP_CUR_DOWN_EI) & GEN6_RP_EI_MASK;
2092                 intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
2093
2094                 seq_printf(m, "\nRPS Autotuning (current \"%s\" window):\n",
2095                            rps_power_to_str(rps->power.mode));
2096                 seq_printf(m, "  Avg. up: %d%% [above threshold? %d%%]\n",
2097                            rpup && rpupei ? 100 * rpup / rpupei : 0,
2098                            rps->power.up_threshold);
2099                 seq_printf(m, "  Avg. down: %d%% [below threshold? %d%%]\n",
2100                            rpdown && rpdownei ? 100 * rpdown / rpdownei : 0,
2101                            rps->power.down_threshold);
2102         } else {
2103                 seq_puts(m, "\nRPS Autotuning inactive\n");
2104         }
2105
2106         return 0;
2107 }
2108
2109 static int i915_llc(struct seq_file *m, void *data)
2110 {
2111         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2112         const bool edram = INTEL_GEN(dev_priv) > 8;
2113
2114         seq_printf(m, "LLC: %s\n", yesno(HAS_LLC(dev_priv)));
2115         seq_printf(m, "%s: %lluMB\n", edram ? "eDRAM" : "eLLC",
2116                    intel_uncore_edram_size(dev_priv)/1024/1024);
2117
2118         return 0;
2119 }
2120
2121 static int i915_huc_load_status_info(struct seq_file *m, void *data)
2122 {
2123         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2124         intel_wakeref_t wakeref;
2125         struct drm_printer p;
2126
2127         if (!HAS_HUC(dev_priv))
2128                 return -ENODEV;
2129
2130         p = drm_seq_file_printer(m);
2131         intel_uc_fw_dump(&dev_priv->huc.fw, &p);
2132
2133         with_intel_runtime_pm(dev_priv, wakeref)
2134                 seq_printf(m, "\nHuC status 0x%08x:\n", I915_READ(HUC_STATUS2));
2135
2136         return 0;
2137 }
2138
2139 static int i915_guc_load_status_info(struct seq_file *m, void *data)
2140 {
2141         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2142         intel_wakeref_t wakeref;
2143         struct drm_printer p;
2144
2145         if (!HAS_GUC(dev_priv))
2146                 return -ENODEV;
2147
2148         p = drm_seq_file_printer(m);
2149         intel_uc_fw_dump(&dev_priv->guc.fw, &p);
2150
2151         with_intel_runtime_pm(dev_priv, wakeref) {
2152                 u32 tmp = I915_READ(GUC_STATUS);
2153                 u32 i;
2154
2155                 seq_printf(m, "\nGuC status 0x%08x:\n", tmp);
2156                 seq_printf(m, "\tBootrom status = 0x%x\n",
2157                            (tmp & GS_BOOTROM_MASK) >> GS_BOOTROM_SHIFT);
2158                 seq_printf(m, "\tuKernel status = 0x%x\n",
2159                            (tmp & GS_UKERNEL_MASK) >> GS_UKERNEL_SHIFT);
2160                 seq_printf(m, "\tMIA Core status = 0x%x\n",
2161                            (tmp & GS_MIA_MASK) >> GS_MIA_SHIFT);
2162                 seq_puts(m, "\nScratch registers:\n");
2163                 for (i = 0; i < 16; i++) {
2164                         seq_printf(m, "\t%2d: \t0x%x\n",
2165                                    i, I915_READ(SOFT_SCRATCH(i)));
2166                 }
2167         }
2168
2169         return 0;
2170 }
2171
2172 static const char *
2173 stringify_guc_log_type(enum guc_log_buffer_type type)
2174 {
2175         switch (type) {
2176         case GUC_ISR_LOG_BUFFER:
2177                 return "ISR";
2178         case GUC_DPC_LOG_BUFFER:
2179                 return "DPC";
2180         case GUC_CRASH_DUMP_LOG_BUFFER:
2181                 return "CRASH";
2182         default:
2183                 MISSING_CASE(type);
2184         }
2185
2186         return "";
2187 }
2188
2189 static void i915_guc_log_info(struct seq_file *m,
2190                               struct drm_i915_private *dev_priv)
2191 {
2192         struct intel_guc_log *log = &dev_priv->guc.log;
2193         enum guc_log_buffer_type type;
2194
2195         if (!intel_guc_log_relay_enabled(log)) {
2196                 seq_puts(m, "GuC log relay disabled\n");
2197                 return;
2198         }
2199
2200         seq_puts(m, "GuC logging stats:\n");
2201
2202         seq_printf(m, "\tRelay full count: %u\n",
2203                    log->relay.full_count);
2204
2205         for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
2206                 seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
2207                            stringify_guc_log_type(type),
2208                            log->stats[type].flush,
2209                            log->stats[type].sampled_overflow);
2210         }
2211 }
2212
2213 static void i915_guc_client_info(struct seq_file *m,
2214                                  struct drm_i915_private *dev_priv,
2215                                  struct intel_guc_client *client)
2216 {
2217         struct intel_engine_cs *engine;
2218         enum intel_engine_id id;
2219         u64 tot = 0;
2220
2221         seq_printf(m, "\tPriority %d, GuC stage index: %u, PD offset 0x%x\n",
2222                 client->priority, client->stage_id, client->proc_desc_offset);
2223         seq_printf(m, "\tDoorbell id %d, offset: 0x%lx\n",
2224                 client->doorbell_id, client->doorbell_offset);
2225
2226         for_each_engine(engine, dev_priv, id) {
2227                 u64 submissions = client->submissions[id];
2228                 tot += submissions;
2229                 seq_printf(m, "\tSubmissions: %llu %s\n",
2230                                 submissions, engine->name);
2231         }
2232         seq_printf(m, "\tTotal: %llu\n", tot);
2233 }
2234
2235 static int i915_guc_info(struct seq_file *m, void *data)
2236 {
2237         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2238         const struct intel_guc *guc = &dev_priv->guc;
2239
2240         if (!USES_GUC(dev_priv))
2241                 return -ENODEV;
2242
2243         i915_guc_log_info(m, dev_priv);
2244
2245         if (!USES_GUC_SUBMISSION(dev_priv))
2246                 return 0;
2247
2248         GEM_BUG_ON(!guc->execbuf_client);
2249
2250         seq_printf(m, "\nDoorbell map:\n");
2251         seq_printf(m, "\t%*pb\n", GUC_NUM_DOORBELLS, guc->doorbell_bitmap);
2252         seq_printf(m, "Doorbell next cacheline: 0x%x\n", guc->db_cacheline);
2253
2254         seq_printf(m, "\nGuC execbuf client @ %p:\n", guc->execbuf_client);
2255         i915_guc_client_info(m, dev_priv, guc->execbuf_client);
2256         if (guc->preempt_client) {
2257                 seq_printf(m, "\nGuC preempt client @ %p:\n",
2258                            guc->preempt_client);
2259                 i915_guc_client_info(m, dev_priv, guc->preempt_client);
2260         }
2261
2262         /* Add more as required ... */
2263
2264         return 0;
2265 }
2266
2267 static int i915_guc_stage_pool(struct seq_file *m, void *data)
2268 {
2269         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2270         const struct intel_guc *guc = &dev_priv->guc;
2271         struct guc_stage_desc *desc = guc->stage_desc_pool_vaddr;
2272         struct intel_guc_client *client = guc->execbuf_client;
2273         unsigned int tmp;
2274         int index;
2275
2276         if (!USES_GUC_SUBMISSION(dev_priv))
2277                 return -ENODEV;
2278
2279         for (index = 0; index < GUC_MAX_STAGE_DESCRIPTORS; index++, desc++) {
2280                 struct intel_engine_cs *engine;
2281
2282                 if (!(desc->attribute & GUC_STAGE_DESC_ATTR_ACTIVE))
2283                         continue;
2284
2285                 seq_printf(m, "GuC stage descriptor %u:\n", index);
2286                 seq_printf(m, "\tIndex: %u\n", desc->stage_id);
2287                 seq_printf(m, "\tAttribute: 0x%x\n", desc->attribute);
2288                 seq_printf(m, "\tPriority: %d\n", desc->priority);
2289                 seq_printf(m, "\tDoorbell id: %d\n", desc->db_id);
2290                 seq_printf(m, "\tEngines used: 0x%x\n",
2291                            desc->engines_used);
2292                 seq_printf(m, "\tDoorbell trigger phy: 0x%llx, cpu: 0x%llx, uK: 0x%x\n",
2293                            desc->db_trigger_phy,
2294                            desc->db_trigger_cpu,
2295                            desc->db_trigger_uk);
2296                 seq_printf(m, "\tProcess descriptor: 0x%x\n",
2297                            desc->process_desc);
2298                 seq_printf(m, "\tWorkqueue address: 0x%x, size: 0x%x\n",
2299                            desc->wq_addr, desc->wq_size);
2300                 seq_putc(m, '\n');
2301
2302                 for_each_engine_masked(engine, dev_priv, client->engines, tmp) {
2303                         u32 guc_engine_id = engine->guc_id;
2304                         struct guc_execlist_context *lrc =
2305                                                 &desc->lrc[guc_engine_id];
2306
2307                         seq_printf(m, "\t%s LRC:\n", engine->name);
2308                         seq_printf(m, "\t\tContext desc: 0x%x\n",
2309                                    lrc->context_desc);
2310                         seq_printf(m, "\t\tContext id: 0x%x\n", lrc->context_id);
2311                         seq_printf(m, "\t\tLRCA: 0x%x\n", lrc->ring_lrca);
2312                         seq_printf(m, "\t\tRing begin: 0x%x\n", lrc->ring_begin);
2313                         seq_printf(m, "\t\tRing end: 0x%x\n", lrc->ring_end);
2314                         seq_putc(m, '\n');
2315                 }
2316         }
2317
2318         return 0;
2319 }
2320
2321 static int i915_guc_log_dump(struct seq_file *m, void *data)
2322 {
2323         struct drm_info_node *node = m->private;
2324         struct drm_i915_private *dev_priv = node_to_i915(node);
2325         bool dump_load_err = !!node->info_ent->data;
2326         struct drm_i915_gem_object *obj = NULL;
2327         u32 *log;
2328         int i = 0;
2329
2330         if (!HAS_GUC(dev_priv))
2331                 return -ENODEV;
2332
2333         if (dump_load_err)
2334                 obj = dev_priv->guc.load_err_log;
2335         else if (dev_priv->guc.log.vma)
2336                 obj = dev_priv->guc.log.vma->obj;
2337
2338         if (!obj)
2339                 return 0;
2340
2341         log = i915_gem_object_pin_map(obj, I915_MAP_WC);
2342         if (IS_ERR(log)) {
2343                 DRM_DEBUG("Failed to pin object\n");
2344                 seq_puts(m, "(log data unaccessible)\n");
2345                 return PTR_ERR(log);
2346         }
2347
2348         for (i = 0; i < obj->base.size / sizeof(u32); i += 4)
2349                 seq_printf(m, "0x%08x 0x%08x 0x%08x 0x%08x\n",
2350                            *(log + i), *(log + i + 1),
2351                            *(log + i + 2), *(log + i + 3));
2352
2353         seq_putc(m, '\n');
2354
2355         i915_gem_object_unpin_map(obj);
2356
2357         return 0;
2358 }
2359
2360 static int i915_guc_log_level_get(void *data, u64 *val)
2361 {
2362         struct drm_i915_private *dev_priv = data;
2363
2364         if (!USES_GUC(dev_priv))
2365                 return -ENODEV;
2366
2367         *val = intel_guc_log_get_level(&dev_priv->guc.log);
2368
2369         return 0;
2370 }
2371
2372 static int i915_guc_log_level_set(void *data, u64 val)
2373 {
2374         struct drm_i915_private *dev_priv = data;
2375
2376         if (!USES_GUC(dev_priv))
2377                 return -ENODEV;
2378
2379         return intel_guc_log_set_level(&dev_priv->guc.log, val);
2380 }
2381
2382 DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_level_fops,
2383                         i915_guc_log_level_get, i915_guc_log_level_set,
2384                         "%lld\n");
2385
2386 static int i915_guc_log_relay_open(struct inode *inode, struct file *file)
2387 {
2388         struct drm_i915_private *dev_priv = inode->i_private;
2389
2390         if (!USES_GUC(dev_priv))
2391                 return -ENODEV;
2392
2393         file->private_data = &dev_priv->guc.log;
2394
2395         return intel_guc_log_relay_open(&dev_priv->guc.log);
2396 }
2397
2398 static ssize_t
2399 i915_guc_log_relay_write(struct file *filp,
2400                          const char __user *ubuf,
2401                          size_t cnt,
2402                          loff_t *ppos)
2403 {
2404         struct intel_guc_log *log = filp->private_data;
2405
2406         intel_guc_log_relay_flush(log);
2407
2408         return cnt;
2409 }
2410
2411 static int i915_guc_log_relay_release(struct inode *inode, struct file *file)
2412 {
2413         struct drm_i915_private *dev_priv = inode->i_private;
2414
2415         intel_guc_log_relay_close(&dev_priv->guc.log);
2416
2417         return 0;
2418 }
2419
2420 static const struct file_operations i915_guc_log_relay_fops = {
2421         .owner = THIS_MODULE,
2422         .open = i915_guc_log_relay_open,
2423         .write = i915_guc_log_relay_write,
2424         .release = i915_guc_log_relay_release,
2425 };
2426
2427 static int i915_psr_sink_status_show(struct seq_file *m, void *data)
2428 {
2429         u8 val;
2430         static const char * const sink_status[] = {
2431                 "inactive",
2432                 "transition to active, capture and display",
2433                 "active, display from RFB",
2434                 "active, capture and display on sink device timings",
2435                 "transition to inactive, capture and display, timing re-sync",
2436                 "reserved",
2437                 "reserved",
2438                 "sink internal error",
2439         };
2440         struct drm_connector *connector = m->private;
2441         struct drm_i915_private *dev_priv = to_i915(connector->dev);
2442         struct intel_dp *intel_dp =
2443                 enc_to_intel_dp(&intel_attached_encoder(connector)->base);
2444         int ret;
2445
2446         if (!CAN_PSR(dev_priv)) {
2447                 seq_puts(m, "PSR Unsupported\n");
2448                 return -ENODEV;
2449         }
2450
2451         if (connector->status != connector_status_connected)
2452                 return -ENODEV;
2453
2454         ret = drm_dp_dpcd_readb(&intel_dp->aux, DP_PSR_STATUS, &val);
2455
2456         if (ret == 1) {
2457                 const char *str = "unknown";
2458
2459                 val &= DP_PSR_SINK_STATE_MASK;
2460                 if (val < ARRAY_SIZE(sink_status))
2461                         str = sink_status[val];
2462                 seq_printf(m, "Sink PSR status: 0x%x [%s]\n", val, str);
2463         } else {
2464                 return ret;
2465         }
2466
2467         return 0;
2468 }
2469 DEFINE_SHOW_ATTRIBUTE(i915_psr_sink_status);
2470
2471 static void
2472 psr_source_status(struct drm_i915_private *dev_priv, struct seq_file *m)
2473 {
2474         u32 val, status_val;
2475         const char *status = "unknown";
2476
2477         if (dev_priv->psr.psr2_enabled) {
2478                 static const char * const live_status[] = {
2479                         "IDLE",
2480                         "CAPTURE",
2481                         "CAPTURE_FS",
2482                         "SLEEP",
2483                         "BUFON_FW",
2484                         "ML_UP",
2485                         "SU_STANDBY",
2486                         "FAST_SLEEP",
2487                         "DEEP_SLEEP",
2488                         "BUF_ON",
2489                         "TG_ON"
2490                 };
2491                 val = I915_READ(EDP_PSR2_STATUS);
2492                 status_val = (val & EDP_PSR2_STATUS_STATE_MASK) >>
2493                               EDP_PSR2_STATUS_STATE_SHIFT;
2494                 if (status_val < ARRAY_SIZE(live_status))
2495                         status = live_status[status_val];
2496         } else {
2497                 static const char * const live_status[] = {
2498                         "IDLE",
2499                         "SRDONACK",
2500                         "SRDENT",
2501                         "BUFOFF",
2502                         "BUFON",
2503                         "AUXACK",
2504                         "SRDOFFACK",
2505                         "SRDENT_ON",
2506                 };
2507                 val = I915_READ(EDP_PSR_STATUS);
2508                 status_val = (val & EDP_PSR_STATUS_STATE_MASK) >>
2509                               EDP_PSR_STATUS_STATE_SHIFT;
2510                 if (status_val < ARRAY_SIZE(live_status))
2511                         status = live_status[status_val];
2512         }
2513
2514         seq_printf(m, "Source PSR status: %s [0x%08x]\n", status, val);
2515 }
2516
2517 static int i915_edp_psr_status(struct seq_file *m, void *data)
2518 {
2519         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2520         struct i915_psr *psr = &dev_priv->psr;
2521         intel_wakeref_t wakeref;
2522         const char *status;
2523         bool enabled;
2524         u32 val;
2525
2526         if (!HAS_PSR(dev_priv))
2527                 return -ENODEV;
2528
2529         seq_printf(m, "Sink support: %s", yesno(psr->sink_support));
2530         if (psr->dp)
2531                 seq_printf(m, " [0x%02x]", psr->dp->psr_dpcd[0]);
2532         seq_puts(m, "\n");
2533
2534         if (!psr->sink_support)
2535                 return 0;
2536
2537         wakeref = intel_runtime_pm_get(dev_priv);
2538         mutex_lock(&psr->lock);
2539
2540         if (psr->enabled)
2541                 status = psr->psr2_enabled ? "PSR2 enabled" : "PSR1 enabled";
2542         else
2543                 status = "disabled";
2544         seq_printf(m, "PSR mode: %s\n", status);
2545
2546         if (!psr->enabled)
2547                 goto unlock;
2548
2549         if (psr->psr2_enabled) {
2550                 val = I915_READ(EDP_PSR2_CTL);
2551                 enabled = val & EDP_PSR2_ENABLE;
2552         } else {
2553                 val = I915_READ(EDP_PSR_CTL);
2554                 enabled = val & EDP_PSR_ENABLE;
2555         }
2556         seq_printf(m, "Source PSR ctl: %s [0x%08x]\n",
2557                    enableddisabled(enabled), val);
2558         psr_source_status(dev_priv, m);
2559         seq_printf(m, "Busy frontbuffer bits: 0x%08x\n",
2560                    psr->busy_frontbuffer_bits);
2561
2562         /*
2563          * SKL+ Perf counter is reset to 0 everytime DC state is entered
2564          */
2565         if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) {
2566                 val = I915_READ(EDP_PSR_PERF_CNT) & EDP_PSR_PERF_CNT_MASK;
2567                 seq_printf(m, "Performance counter: %u\n", val);
2568         }
2569
2570         if (psr->debug & I915_PSR_DEBUG_IRQ) {
2571                 seq_printf(m, "Last attempted entry at: %lld\n",
2572                            psr->last_entry_attempt);
2573                 seq_printf(m, "Last exit at: %lld\n", psr->last_exit);
2574         }
2575
2576         if (psr->psr2_enabled) {
2577                 u32 su_frames_val[3];
2578                 int frame;
2579
2580                 /*
2581                  * Reading all 3 registers before hand to minimize crossing a
2582                  * frame boundary between register reads
2583                  */
2584                 for (frame = 0; frame < PSR2_SU_STATUS_FRAMES; frame += 3)
2585                         su_frames_val[frame / 3] = I915_READ(PSR2_SU_STATUS(frame));
2586
2587                 seq_puts(m, "Frame:\tPSR2 SU blocks:\n");
2588
2589                 for (frame = 0; frame < PSR2_SU_STATUS_FRAMES; frame++) {
2590                         u32 su_blocks;
2591
2592                         su_blocks = su_frames_val[frame / 3] &
2593                                     PSR2_SU_STATUS_MASK(frame);
2594                         su_blocks = su_blocks >> PSR2_SU_STATUS_SHIFT(frame);
2595                         seq_printf(m, "%d\t%d\n", frame, su_blocks);
2596                 }
2597         }
2598
2599 unlock:
2600         mutex_unlock(&psr->lock);
2601         intel_runtime_pm_put(dev_priv, wakeref);
2602
2603         return 0;
2604 }
2605
2606 static int
2607 i915_edp_psr_debug_set(void *data, u64 val)
2608 {
2609         struct drm_i915_private *dev_priv = data;
2610         struct drm_modeset_acquire_ctx ctx;
2611         intel_wakeref_t wakeref;
2612         int ret;
2613
2614         if (!CAN_PSR(dev_priv))
2615                 return -ENODEV;
2616
2617         DRM_DEBUG_KMS("Setting PSR debug to %llx\n", val);
2618
2619         wakeref = intel_runtime_pm_get(dev_priv);
2620
2621         drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
2622
2623 retry:
2624         ret = intel_psr_set_debugfs_mode(dev_priv, &ctx, val);
2625         if (ret == -EDEADLK) {
2626                 ret = drm_modeset_backoff(&ctx);
2627                 if (!ret)
2628                         goto retry;
2629         }
2630
2631         drm_modeset_drop_locks(&ctx);
2632         drm_modeset_acquire_fini(&ctx);
2633
2634         intel_runtime_pm_put(dev_priv, wakeref);
2635
2636         return ret;
2637 }
2638
2639 static int
2640 i915_edp_psr_debug_get(void *data, u64 *val)
2641 {
2642         struct drm_i915_private *dev_priv = data;
2643
2644         if (!CAN_PSR(dev_priv))
2645                 return -ENODEV;
2646
2647         *val = READ_ONCE(dev_priv->psr.debug);
2648         return 0;
2649 }
2650
2651 DEFINE_SIMPLE_ATTRIBUTE(i915_edp_psr_debug_fops,
2652                         i915_edp_psr_debug_get, i915_edp_psr_debug_set,
2653                         "%llu\n");
2654
2655 static int i915_energy_uJ(struct seq_file *m, void *data)
2656 {
2657         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2658         unsigned long long power;
2659         intel_wakeref_t wakeref;
2660         u32 units;
2661
2662         if (INTEL_GEN(dev_priv) < 6)
2663                 return -ENODEV;
2664
2665         if (rdmsrl_safe(MSR_RAPL_POWER_UNIT, &power))
2666                 return -ENODEV;
2667
2668         units = (power & 0x1f00) >> 8;
2669         with_intel_runtime_pm(dev_priv, wakeref)
2670                 power = I915_READ(MCH_SECP_NRG_STTS);
2671
2672         power = (1000000 * power) >> units; /* convert to uJ */
2673         seq_printf(m, "%llu", power);
2674
2675         return 0;
2676 }
2677
2678 static int i915_runtime_pm_status(struct seq_file *m, void *unused)
2679 {
2680         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2681         struct pci_dev *pdev = dev_priv->drm.pdev;
2682
2683         if (!HAS_RUNTIME_PM(dev_priv))
2684                 seq_puts(m, "Runtime power management not supported\n");
2685
2686         seq_printf(m, "Runtime power status: %s\n",
2687                    enableddisabled(!dev_priv->power_domains.wakeref));
2688
2689         seq_printf(m, "GPU idle: %s (epoch %u)\n",
2690                    yesno(!dev_priv->gt.awake), dev_priv->gt.epoch);
2691         seq_printf(m, "IRQs disabled: %s\n",
2692                    yesno(!intel_irqs_enabled(dev_priv)));
2693 #ifdef CONFIG_PM
2694         seq_printf(m, "Usage count: %d\n",
2695                    atomic_read(&dev_priv->drm.dev->power.usage_count));
2696 #else
2697         seq_printf(m, "Device Power Management (CONFIG_PM) disabled\n");
2698 #endif
2699         seq_printf(m, "PCI device power state: %s [%d]\n",
2700                    pci_power_name(pdev->current_state),
2701                    pdev->current_state);
2702
2703         if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)) {
2704                 struct drm_printer p = drm_seq_file_printer(m);
2705
2706                 print_intel_runtime_pm_wakeref(dev_priv, &p);
2707         }
2708
2709         return 0;
2710 }
2711
2712 static int i915_power_domain_info(struct seq_file *m, void *unused)
2713 {
2714         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2715         struct i915_power_domains *power_domains = &dev_priv->power_domains;
2716         int i;
2717
2718         mutex_lock(&power_domains->lock);
2719
2720         seq_printf(m, "%-25s %s\n", "Power well/domain", "Use count");
2721         for (i = 0; i < power_domains->power_well_count; i++) {
2722                 struct i915_power_well *power_well;
2723                 enum intel_display_power_domain power_domain;
2724
2725                 power_well = &power_domains->power_wells[i];
2726                 seq_printf(m, "%-25s %d\n", power_well->desc->name,
2727                            power_well->count);
2728
2729                 for_each_power_domain(power_domain, power_well->desc->domains)
2730                         seq_printf(m, "  %-23s %d\n",
2731                                  intel_display_power_domain_str(power_domain),
2732                                  power_domains->domain_use_count[power_domain]);
2733         }
2734
2735         mutex_unlock(&power_domains->lock);
2736
2737         return 0;
2738 }
2739
2740 static int i915_dmc_info(struct seq_file *m, void *unused)
2741 {
2742         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2743         intel_wakeref_t wakeref;
2744         struct intel_csr *csr;
2745
2746         if (!HAS_CSR(dev_priv))
2747                 return -ENODEV;
2748
2749         csr = &dev_priv->csr;
2750
2751         wakeref = intel_runtime_pm_get(dev_priv);
2752
2753         seq_printf(m, "fw loaded: %s\n", yesno(csr->dmc_payload != NULL));
2754         seq_printf(m, "path: %s\n", csr->fw_path);
2755
2756         if (!csr->dmc_payload)
2757                 goto out;
2758
2759         seq_printf(m, "version: %d.%d\n", CSR_VERSION_MAJOR(csr->version),
2760                    CSR_VERSION_MINOR(csr->version));
2761
2762         if (WARN_ON(INTEL_GEN(dev_priv) > 11))
2763                 goto out;
2764
2765         seq_printf(m, "DC3 -> DC5 count: %d\n",
2766                    I915_READ(IS_BROXTON(dev_priv) ? BXT_CSR_DC3_DC5_COUNT :
2767                                                     SKL_CSR_DC3_DC5_COUNT));
2768         if (!IS_GEN9_LP(dev_priv))
2769                 seq_printf(m, "DC5 -> DC6 count: %d\n",
2770                            I915_READ(SKL_CSR_DC5_DC6_COUNT));
2771
2772 out:
2773         seq_printf(m, "program base: 0x%08x\n", I915_READ(CSR_PROGRAM(0)));
2774         seq_printf(m, "ssp base: 0x%08x\n", I915_READ(CSR_SSP_BASE));
2775         seq_printf(m, "htp: 0x%08x\n", I915_READ(CSR_HTP_SKL));
2776
2777         intel_runtime_pm_put(dev_priv, wakeref);
2778
2779         return 0;
2780 }
2781
2782 static void intel_seq_print_mode(struct seq_file *m, int tabs,
2783                                  struct drm_display_mode *mode)
2784 {
2785         int i;
2786
2787         for (i = 0; i < tabs; i++)
2788                 seq_putc(m, '\t');
2789
2790         seq_printf(m, DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
2791 }
2792
2793 static void intel_encoder_info(struct seq_file *m,
2794                                struct intel_crtc *intel_crtc,
2795                                struct intel_encoder *intel_encoder)
2796 {
2797         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2798         struct drm_device *dev = &dev_priv->drm;
2799         struct drm_crtc *crtc = &intel_crtc->base;
2800         struct intel_connector *intel_connector;
2801         struct drm_encoder *encoder;
2802
2803         encoder = &intel_encoder->base;
2804         seq_printf(m, "\tencoder %d: type: %s, connectors:\n",
2805                    encoder->base.id, encoder->name);
2806         for_each_connector_on_encoder(dev, encoder, intel_connector) {
2807                 struct drm_connector *connector = &intel_connector->base;
2808                 seq_printf(m, "\t\tconnector %d: type: %s, status: %s",
2809                            connector->base.id,
2810                            connector->name,
2811                            drm_get_connector_status_name(connector->status));
2812                 if (connector->status == connector_status_connected) {
2813                         struct drm_display_mode *mode = &crtc->mode;
2814                         seq_printf(m, ", mode:\n");
2815                         intel_seq_print_mode(m, 2, mode);
2816                 } else {
2817                         seq_putc(m, '\n');
2818                 }
2819         }
2820 }
2821
2822 static void intel_crtc_info(struct seq_file *m, struct intel_crtc *intel_crtc)
2823 {
2824         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2825         struct drm_device *dev = &dev_priv->drm;
2826         struct drm_crtc *crtc = &intel_crtc->base;
2827         struct intel_encoder *intel_encoder;
2828         struct drm_plane_state *plane_state = crtc->primary->state;
2829         struct drm_framebuffer *fb = plane_state->fb;
2830
2831         if (fb)
2832                 seq_printf(m, "\tfb: %d, pos: %dx%d, size: %dx%d\n",
2833                            fb->base.id, plane_state->src_x >> 16,
2834                            plane_state->src_y >> 16, fb->width, fb->height);
2835         else
2836                 seq_puts(m, "\tprimary plane disabled\n");
2837         for_each_encoder_on_crtc(dev, crtc, intel_encoder)
2838                 intel_encoder_info(m, intel_crtc, intel_encoder);
2839 }
2840
2841 static void intel_panel_info(struct seq_file *m, struct intel_panel *panel)
2842 {
2843         struct drm_display_mode *mode = panel->fixed_mode;
2844
2845         seq_printf(m, "\tfixed mode:\n");
2846         intel_seq_print_mode(m, 2, mode);
2847 }
2848
2849 static void intel_dp_info(struct seq_file *m,
2850                           struct intel_connector *intel_connector)
2851 {
2852         struct intel_encoder *intel_encoder = intel_connector->encoder;
2853         struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
2854
2855         seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
2856         seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio));
2857         if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)
2858                 intel_panel_info(m, &intel_connector->panel);
2859
2860         drm_dp_downstream_debug(m, intel_dp->dpcd, intel_dp->downstream_ports,
2861                                 &intel_dp->aux);
2862 }
2863
2864 static void intel_dp_mst_info(struct seq_file *m,
2865                           struct intel_connector *intel_connector)
2866 {
2867         struct intel_encoder *intel_encoder = intel_connector->encoder;
2868         struct intel_dp_mst_encoder *intel_mst =
2869                 enc_to_mst(&intel_encoder->base);
2870         struct intel_digital_port *intel_dig_port = intel_mst->primary;
2871         struct intel_dp *intel_dp = &intel_dig_port->dp;
2872         bool has_audio = drm_dp_mst_port_has_audio(&intel_dp->mst_mgr,
2873                                         intel_connector->port);
2874
2875         seq_printf(m, "\taudio support: %s\n", yesno(has_audio));
2876 }
2877
2878 static void intel_hdmi_info(struct seq_file *m,
2879                             struct intel_connector *intel_connector)
2880 {
2881         struct intel_encoder *intel_encoder = intel_connector->encoder;
2882         struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&intel_encoder->base);
2883
2884         seq_printf(m, "\taudio support: %s\n", yesno(intel_hdmi->has_audio));
2885 }
2886
2887 static void intel_lvds_info(struct seq_file *m,
2888                             struct intel_connector *intel_connector)
2889 {
2890         intel_panel_info(m, &intel_connector->panel);
2891 }
2892
2893 static void intel_connector_info(struct seq_file *m,
2894                                  struct drm_connector *connector)
2895 {
2896         struct intel_connector *intel_connector = to_intel_connector(connector);
2897         struct intel_encoder *intel_encoder = intel_connector->encoder;
2898         struct drm_display_mode *mode;
2899
2900         seq_printf(m, "connector %d: type %s, status: %s\n",
2901                    connector->base.id, connector->name,
2902                    drm_get_connector_status_name(connector->status));
2903
2904         if (connector->status == connector_status_disconnected)
2905                 return;
2906
2907         seq_printf(m, "\tname: %s\n", connector->display_info.name);
2908         seq_printf(m, "\tphysical dimensions: %dx%dmm\n",
2909                    connector->display_info.width_mm,
2910                    connector->display_info.height_mm);
2911         seq_printf(m, "\tsubpixel order: %s\n",
2912                    drm_get_subpixel_order_name(connector->display_info.subpixel_order));
2913         seq_printf(m, "\tCEA rev: %d\n", connector->display_info.cea_rev);
2914
2915         if (!intel_encoder)
2916                 return;
2917
2918         switch (connector->connector_type) {
2919         case DRM_MODE_CONNECTOR_DisplayPort:
2920         case DRM_MODE_CONNECTOR_eDP:
2921                 if (intel_encoder->type == INTEL_OUTPUT_DP_MST)
2922                         intel_dp_mst_info(m, intel_connector);
2923                 else
2924                         intel_dp_info(m, intel_connector);
2925                 break;
2926         case DRM_MODE_CONNECTOR_LVDS:
2927                 if (intel_encoder->type == INTEL_OUTPUT_LVDS)
2928                         intel_lvds_info(m, intel_connector);
2929                 break;
2930         case DRM_MODE_CONNECTOR_HDMIA:
2931                 if (intel_encoder->type == INTEL_OUTPUT_HDMI ||
2932                     intel_encoder->type == INTEL_OUTPUT_DDI)
2933                         intel_hdmi_info(m, intel_connector);
2934                 break;
2935         default:
2936                 break;
2937         }
2938
2939         seq_printf(m, "\tmodes:\n");
2940         list_for_each_entry(mode, &connector->modes, head)
2941                 intel_seq_print_mode(m, 2, mode);
2942 }
2943
2944 static const char *plane_type(enum drm_plane_type type)
2945 {
2946         switch (type) {
2947         case DRM_PLANE_TYPE_OVERLAY:
2948                 return "OVL";
2949         case DRM_PLANE_TYPE_PRIMARY:
2950                 return "PRI";
2951         case DRM_PLANE_TYPE_CURSOR:
2952                 return "CUR";
2953         /*
2954          * Deliberately omitting default: to generate compiler warnings
2955          * when a new drm_plane_type gets added.
2956          */
2957         }
2958
2959         return "unknown";
2960 }
2961
2962 static void plane_rotation(char *buf, size_t bufsize, unsigned int rotation)
2963 {
2964         /*
2965          * According to doc only one DRM_MODE_ROTATE_ is allowed but this
2966          * will print them all to visualize if the values are misused
2967          */
2968         snprintf(buf, bufsize,
2969                  "%s%s%s%s%s%s(0x%08x)",
2970                  (rotation & DRM_MODE_ROTATE_0) ? "0 " : "",
2971                  (rotation & DRM_MODE_ROTATE_90) ? "90 " : "",
2972                  (rotation & DRM_MODE_ROTATE_180) ? "180 " : "",
2973                  (rotation & DRM_MODE_ROTATE_270) ? "270 " : "",
2974                  (rotation & DRM_MODE_REFLECT_X) ? "FLIPX " : "",
2975                  (rotation & DRM_MODE_REFLECT_Y) ? "FLIPY " : "",
2976                  rotation);
2977 }
2978
2979 static void intel_plane_info(struct seq_file *m, struct intel_crtc *intel_crtc)
2980 {
2981         struct drm_i915_private *dev_priv = node_to_i915(m->private);
2982         struct drm_device *dev = &dev_priv->drm;
2983         struct intel_plane *intel_plane;
2984
2985         for_each_intel_plane_on_crtc(dev, intel_crtc, intel_plane) {
2986                 struct drm_plane_state *state;
2987                 struct drm_plane *plane = &intel_plane->base;
2988                 struct drm_format_name_buf format_name;
2989                 char rot_str[48];
2990
2991                 if (!plane->state) {
2992                         seq_puts(m, "plane->state is NULL!\n");
2993                         continue;
2994                 }
2995
2996                 state = plane->state;
2997
2998                 if (state->fb) {
2999                         drm_get_format_name(state->fb->format->format,
3000                                             &format_name);
3001                 } else {
3002                         sprintf(format_name.str, "N/A");
3003                 }
3004
3005                 plane_rotation(rot_str, sizeof(rot_str), state->rotation);
3006
3007                 seq_printf(m, "\t--Plane id %d: type=%s, crtc_pos=%4dx%4d, crtc_size=%4dx%4d, src_pos=%d.%04ux%d.%04u, src_size=%d.%04ux%d.%04u, format=%s, rotation=%s\n",
3008                            plane->base.id,
3009                            plane_type(intel_plane->base.type),
3010                            state->crtc_x, state->crtc_y,
3011                            state->crtc_w, state->crtc_h,
3012                            (state->src_x >> 16),
3013                            ((state->src_x & 0xffff) * 15625) >> 10,
3014                            (state->src_y >> 16),
3015                            ((state->src_y & 0xffff) * 15625) >> 10,
3016                            (state->src_w >> 16),
3017                            ((state->src_w & 0xffff) * 15625) >> 10,
3018                            (state->src_h >> 16),
3019                            ((state->src_h & 0xffff) * 15625) >> 10,
3020                            format_name.str,
3021                            rot_str);
3022         }
3023 }
3024
3025 static void intel_scaler_info(struct seq_file *m, struct intel_crtc *intel_crtc)
3026 {
3027         struct intel_crtc_state *pipe_config;
3028         int num_scalers = intel_crtc->num_scalers;
3029         int i;
3030
3031         pipe_config = to_intel_crtc_state(intel_crtc->base.state);
3032
3033         /* Not all platformas have a scaler */
3034         if (num_scalers) {
3035                 seq_printf(m, "\tnum_scalers=%d, scaler_users=%x scaler_id=%d",
3036                            num_scalers,
3037                            pipe_config->scaler_state.scaler_users,
3038                            pipe_config->scaler_state.scaler_id);
3039
3040                 for (i = 0; i < num_scalers; i++) {
3041                         struct intel_scaler *sc =
3042                                         &pipe_config->scaler_state.scalers[i];
3043
3044                         seq_printf(m, ", scalers[%d]: use=%s, mode=%x",
3045                                    i, yesno(sc->in_use), sc->mode);
3046                 }
3047                 seq_puts(m, "\n");
3048         } else {
3049                 seq_puts(m, "\tNo scalers available on this platform\n");
3050         }
3051 }
3052
3053 static int i915_display_info(struct seq_file *m, void *unused)
3054 {
3055         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3056         struct drm_device *dev = &dev_priv->drm;
3057         struct intel_crtc *crtc;
3058         struct drm_connector *connector;
3059         struct drm_connector_list_iter conn_iter;
3060         intel_wakeref_t wakeref;
3061
3062         wakeref = intel_runtime_pm_get(dev_priv);
3063
3064         seq_printf(m, "CRTC info\n");
3065         seq_printf(m, "---------\n");
3066         for_each_intel_crtc(dev, crtc) {
3067                 struct intel_crtc_state *pipe_config;
3068
3069                 drm_modeset_lock(&crtc->base.mutex, NULL);
3070                 pipe_config = to_intel_crtc_state(crtc->base.state);
3071
3072                 seq_printf(m, "CRTC %d: pipe: %c, active=%s, (size=%dx%d), dither=%s, bpp=%d\n",
3073                            crtc->base.base.id, pipe_name(crtc->pipe),
3074                            yesno(pipe_config->base.active),
3075                            pipe_config->pipe_src_w, pipe_config->pipe_src_h,
3076                            yesno(pipe_config->dither), pipe_config->pipe_bpp);
3077
3078                 if (pipe_config->base.active) {
3079                         struct intel_plane *cursor =
3080                                 to_intel_plane(crtc->base.cursor);
3081
3082                         intel_crtc_info(m, crtc);
3083
3084                         seq_printf(m, "\tcursor visible? %s, position (%d, %d), size %dx%d, addr 0x%08x\n",
3085                                    yesno(cursor->base.state->visible),
3086                                    cursor->base.state->crtc_x,
3087                                    cursor->base.state->crtc_y,
3088                                    cursor->base.state->crtc_w,
3089                                    cursor->base.state->crtc_h,
3090                                    cursor->cursor.base);
3091                         intel_scaler_info(m, crtc);
3092                         intel_plane_info(m, crtc);
3093                 }
3094
3095                 seq_printf(m, "\tunderrun reporting: cpu=%s pch=%s \n",
3096                            yesno(!crtc->cpu_fifo_underrun_disabled),
3097                            yesno(!crtc->pch_fifo_underrun_disabled));
3098                 drm_modeset_unlock(&crtc->base.mutex);
3099         }
3100
3101         seq_printf(m, "\n");
3102         seq_printf(m, "Connector info\n");
3103         seq_printf(m, "--------------\n");
3104         mutex_lock(&dev->mode_config.mutex);
3105         drm_connector_list_iter_begin(dev, &conn_iter);
3106         drm_for_each_connector_iter(connector, &conn_iter)
3107                 intel_connector_info(m, connector);
3108         drm_connector_list_iter_end(&conn_iter);
3109         mutex_unlock(&dev->mode_config.mutex);
3110
3111         intel_runtime_pm_put(dev_priv, wakeref);
3112
3113         return 0;
3114 }
3115
3116 static int i915_engine_info(struct seq_file *m, void *unused)
3117 {
3118         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3119         struct intel_engine_cs *engine;
3120         intel_wakeref_t wakeref;
3121         enum intel_engine_id id;
3122         struct drm_printer p;
3123
3124         wakeref = intel_runtime_pm_get(dev_priv);
3125
3126         seq_printf(m, "GT awake? %s (epoch %u)\n",
3127                    yesno(dev_priv->gt.awake), dev_priv->gt.epoch);
3128         seq_printf(m, "Global active requests: %d\n",
3129                    dev_priv->gt.active_requests);
3130         seq_printf(m, "CS timestamp frequency: %u kHz\n",
3131                    RUNTIME_INFO(dev_priv)->cs_timestamp_frequency_khz);
3132
3133         p = drm_seq_file_printer(m);
3134         for_each_engine(engine, dev_priv, id)
3135                 intel_engine_dump(engine, &p, "%s\n", engine->name);
3136
3137         intel_runtime_pm_put(dev_priv, wakeref);
3138
3139         return 0;
3140 }
3141
3142 static int i915_rcs_topology(struct seq_file *m, void *unused)
3143 {
3144         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3145         struct drm_printer p = drm_seq_file_printer(m);
3146
3147         intel_device_info_dump_topology(&RUNTIME_INFO(dev_priv)->sseu, &p);
3148
3149         return 0;
3150 }
3151
3152 static int i915_shrinker_info(struct seq_file *m, void *unused)
3153 {
3154         struct drm_i915_private *i915 = node_to_i915(m->private);
3155
3156         seq_printf(m, "seeks = %d\n", i915->mm.shrinker.seeks);
3157         seq_printf(m, "batch = %lu\n", i915->mm.shrinker.batch);
3158
3159         return 0;
3160 }
3161
3162 static int i915_shared_dplls_info(struct seq_file *m, void *unused)
3163 {
3164         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3165         struct drm_device *dev = &dev_priv->drm;
3166         int i;
3167
3168         drm_modeset_lock_all(dev);
3169         for (i = 0; i < dev_priv->num_shared_dpll; i++) {
3170                 struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i];
3171
3172                 seq_printf(m, "DPLL%i: %s, id: %i\n", i, pll->info->name,
3173                            pll->info->id);
3174                 seq_printf(m, " crtc_mask: 0x%08x, active: 0x%x, on: %s\n",
3175                            pll->state.crtc_mask, pll->active_mask, yesno(pll->on));
3176                 seq_printf(m, " tracked hardware state:\n");
3177                 seq_printf(m, " dpll:    0x%08x\n", pll->state.hw_state.dpll);
3178                 seq_printf(m, " dpll_md: 0x%08x\n",
3179                            pll->state.hw_state.dpll_md);
3180                 seq_printf(m, " fp0:     0x%08x\n", pll->state.hw_state.fp0);
3181                 seq_printf(m, " fp1:     0x%08x\n", pll->state.hw_state.fp1);
3182                 seq_printf(m, " wrpll:   0x%08x\n", pll->state.hw_state.wrpll);
3183                 seq_printf(m, " cfgcr0:  0x%08x\n", pll->state.hw_state.cfgcr0);
3184                 seq_printf(m, " cfgcr1:  0x%08x\n", pll->state.hw_state.cfgcr1);
3185                 seq_printf(m, " mg_refclkin_ctl:        0x%08x\n",
3186                            pll->state.hw_state.mg_refclkin_ctl);
3187                 seq_printf(m, " mg_clktop2_coreclkctl1: 0x%08x\n",
3188                            pll->state.hw_state.mg_clktop2_coreclkctl1);
3189                 seq_printf(m, " mg_clktop2_hsclkctl:    0x%08x\n",
3190                            pll->state.hw_state.mg_clktop2_hsclkctl);
3191                 seq_printf(m, " mg_pll_div0:  0x%08x\n",
3192                            pll->state.hw_state.mg_pll_div0);
3193                 seq_printf(m, " mg_pll_div1:  0x%08x\n",
3194                            pll->state.hw_state.mg_pll_div1);
3195                 seq_printf(m, " mg_pll_lf:    0x%08x\n",
3196                            pll->state.hw_state.mg_pll_lf);
3197                 seq_printf(m, " mg_pll_frac_lock: 0x%08x\n",
3198                            pll->state.hw_state.mg_pll_frac_lock);
3199                 seq_printf(m, " mg_pll_ssc:   0x%08x\n",
3200                            pll->state.hw_state.mg_pll_ssc);
3201                 seq_printf(m, " mg_pll_bias:  0x%08x\n",
3202                            pll->state.hw_state.mg_pll_bias);
3203                 seq_printf(m, " mg_pll_tdc_coldst_bias: 0x%08x\n",
3204                            pll->state.hw_state.mg_pll_tdc_coldst_bias);
3205         }
3206         drm_modeset_unlock_all(dev);
3207
3208         return 0;
3209 }
3210
3211 static int i915_wa_registers(struct seq_file *m, void *unused)
3212 {
3213         struct drm_i915_private *i915 = node_to_i915(m->private);
3214         const struct i915_wa_list *wal = &i915->engine[RCS]->ctx_wa_list;
3215         struct i915_wa *wa;
3216         unsigned int i;
3217
3218         seq_printf(m, "Workarounds applied: %u\n", wal->count);
3219         for (i = 0, wa = wal->list; i < wal->count; i++, wa++)
3220                 seq_printf(m, "0x%X: 0x%08X, mask: 0x%08X\n",
3221                            i915_mmio_reg_offset(wa->reg), wa->val, wa->mask);
3222
3223         return 0;
3224 }
3225
3226 static int i915_ipc_status_show(struct seq_file *m, void *data)
3227 {
3228         struct drm_i915_private *dev_priv = m->private;
3229
3230         seq_printf(m, "Isochronous Priority Control: %s\n",
3231                         yesno(dev_priv->ipc_enabled));
3232         return 0;
3233 }
3234
3235 static int i915_ipc_status_open(struct inode *inode, struct file *file)
3236 {
3237         struct drm_i915_private *dev_priv = inode->i_private;
3238
3239         if (!HAS_IPC(dev_priv))
3240                 return -ENODEV;
3241
3242         return single_open(file, i915_ipc_status_show, dev_priv);
3243 }
3244
3245 static ssize_t i915_ipc_status_write(struct file *file, const char __user *ubuf,
3246                                      size_t len, loff_t *offp)
3247 {
3248         struct seq_file *m = file->private_data;
3249         struct drm_i915_private *dev_priv = m->private;
3250         intel_wakeref_t wakeref;
3251         bool enable;
3252         int ret;
3253
3254         ret = kstrtobool_from_user(ubuf, len, &enable);
3255         if (ret < 0)
3256                 return ret;
3257
3258         with_intel_runtime_pm(dev_priv, wakeref) {
3259                 if (!dev_priv->ipc_enabled && enable)
3260                         DRM_INFO("Enabling IPC: WM will be proper only after next commit\n");
3261                 dev_priv->wm.distrust_bios_wm = true;
3262                 dev_priv->ipc_enabled = enable;
3263                 intel_enable_ipc(dev_priv);
3264         }
3265
3266         return len;
3267 }
3268
3269 static const struct file_operations i915_ipc_status_fops = {
3270         .owner = THIS_MODULE,
3271         .open = i915_ipc_status_open,
3272         .read = seq_read,
3273         .llseek = seq_lseek,
3274         .release = single_release,
3275         .write = i915_ipc_status_write
3276 };
3277
3278 static int i915_ddb_info(struct seq_file *m, void *unused)
3279 {
3280         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3281         struct drm_device *dev = &dev_priv->drm;
3282         struct skl_ddb_entry *entry;
3283         struct intel_crtc *crtc;
3284
3285         if (INTEL_GEN(dev_priv) < 9)
3286                 return -ENODEV;
3287
3288         drm_modeset_lock_all(dev);
3289
3290         seq_printf(m, "%-15s%8s%8s%8s\n", "", "Start", "End", "Size");
3291
3292         for_each_intel_crtc(&dev_priv->drm, crtc) {
3293                 struct intel_crtc_state *crtc_state =
3294                         to_intel_crtc_state(crtc->base.state);
3295                 enum pipe pipe = crtc->pipe;
3296                 enum plane_id plane_id;
3297
3298                 seq_printf(m, "Pipe %c\n", pipe_name(pipe));
3299
3300                 for_each_plane_id_on_crtc(crtc, plane_id) {
3301                         entry = &crtc_state->wm.skl.plane_ddb_y[plane_id];
3302                         seq_printf(m, "  Plane%-8d%8u%8u%8u\n", plane_id + 1,
3303                                    entry->start, entry->end,
3304                                    skl_ddb_entry_size(entry));
3305                 }
3306
3307                 entry = &crtc_state->wm.skl.plane_ddb_y[PLANE_CURSOR];
3308                 seq_printf(m, "  %-13s%8u%8u%8u\n", "Cursor", entry->start,
3309                            entry->end, skl_ddb_entry_size(entry));
3310         }
3311
3312         drm_modeset_unlock_all(dev);
3313
3314         return 0;
3315 }
3316
3317 static void drrs_status_per_crtc(struct seq_file *m,
3318                                  struct drm_device *dev,
3319                                  struct intel_crtc *intel_crtc)
3320 {
3321         struct drm_i915_private *dev_priv = to_i915(dev);
3322         struct i915_drrs *drrs = &dev_priv->drrs;
3323         int vrefresh = 0;
3324         struct drm_connector *connector;
3325         struct drm_connector_list_iter conn_iter;
3326
3327         drm_connector_list_iter_begin(dev, &conn_iter);
3328         drm_for_each_connector_iter(connector, &conn_iter) {
3329                 if (connector->state->crtc != &intel_crtc->base)
3330                         continue;
3331
3332                 seq_printf(m, "%s:\n", connector->name);
3333         }
3334         drm_connector_list_iter_end(&conn_iter);
3335
3336         if (dev_priv->vbt.drrs_type == STATIC_DRRS_SUPPORT)
3337                 seq_puts(m, "\tVBT: DRRS_type: Static");
3338         else if (dev_priv->vbt.drrs_type == SEAMLESS_DRRS_SUPPORT)
3339                 seq_puts(m, "\tVBT: DRRS_type: Seamless");
3340         else if (dev_priv->vbt.drrs_type == DRRS_NOT_SUPPORTED)
3341                 seq_puts(m, "\tVBT: DRRS_type: None");
3342         else
3343                 seq_puts(m, "\tVBT: DRRS_type: FIXME: Unrecognized Value");
3344
3345         seq_puts(m, "\n\n");
3346
3347         if (to_intel_crtc_state(intel_crtc->base.state)->has_drrs) {
3348                 struct intel_panel *panel;
3349
3350                 mutex_lock(&drrs->mutex);
3351                 /* DRRS Supported */
3352                 seq_puts(m, "\tDRRS Supported: Yes\n");
3353
3354                 /* disable_drrs() will make drrs->dp NULL */
3355                 if (!drrs->dp) {
3356                         seq_puts(m, "Idleness DRRS: Disabled\n");
3357                         if (dev_priv->psr.enabled)
3358                                 seq_puts(m,
3359                                 "\tAs PSR is enabled, DRRS is not enabled\n");
3360                         mutex_unlock(&drrs->mutex);
3361                         return;
3362                 }
3363
3364                 panel = &drrs->dp->attached_connector->panel;
3365                 seq_printf(m, "\t\tBusy_frontbuffer_bits: 0x%X",
3366                                         drrs->busy_frontbuffer_bits);
3367
3368                 seq_puts(m, "\n\t\t");
3369                 if (drrs->refresh_rate_type == DRRS_HIGH_RR) {
3370                         seq_puts(m, "DRRS_State: DRRS_HIGH_RR\n");
3371                         vrefresh = panel->fixed_mode->vrefresh;
3372                 } else if (drrs->refresh_rate_type == DRRS_LOW_RR) {
3373                         seq_puts(m, "DRRS_State: DRRS_LOW_RR\n");
3374                         vrefresh = panel->downclock_mode->vrefresh;
3375                 } else {
3376                         seq_printf(m, "DRRS_State: Unknown(%d)\n",
3377                                                 drrs->refresh_rate_type);
3378                         mutex_unlock(&drrs->mutex);
3379                         return;
3380                 }
3381                 seq_printf(m, "\t\tVrefresh: %d", vrefresh);
3382
3383                 seq_puts(m, "\n\t\t");
3384                 mutex_unlock(&drrs->mutex);
3385         } else {
3386                 /* DRRS not supported. Print the VBT parameter*/
3387                 seq_puts(m, "\tDRRS Supported : No");
3388         }
3389         seq_puts(m, "\n");
3390 }
3391
3392 static int i915_drrs_status(struct seq_file *m, void *unused)
3393 {
3394         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3395         struct drm_device *dev = &dev_priv->drm;
3396         struct intel_crtc *intel_crtc;
3397         int active_crtc_cnt = 0;
3398
3399         drm_modeset_lock_all(dev);
3400         for_each_intel_crtc(dev, intel_crtc) {
3401                 if (intel_crtc->base.state->active) {
3402                         active_crtc_cnt++;
3403                         seq_printf(m, "\nCRTC %d:  ", active_crtc_cnt);
3404
3405                         drrs_status_per_crtc(m, dev, intel_crtc);
3406                 }
3407         }
3408         drm_modeset_unlock_all(dev);
3409
3410         if (!active_crtc_cnt)
3411                 seq_puts(m, "No active crtc found\n");
3412
3413         return 0;
3414 }
3415
3416 static int i915_dp_mst_info(struct seq_file *m, void *unused)
3417 {
3418         struct drm_i915_private *dev_priv = node_to_i915(m->private);
3419         struct drm_device *dev = &dev_priv->drm;
3420         struct intel_encoder *intel_encoder;
3421         struct intel_digital_port *intel_dig_port;
3422         struct drm_connector *connector;
3423         struct drm_connector_list_iter conn_iter;
3424
3425         drm_connector_list_iter_begin(dev, &conn_iter);
3426         drm_for_each_connector_iter(connector, &conn_iter) {
3427                 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
3428                         continue;
3429
3430                 intel_encoder = intel_attached_encoder(connector);
3431                 if (!intel_encoder || intel_encoder->type == INTEL_OUTPUT_DP_MST)
3432                         continue;
3433
3434                 intel_dig_port = enc_to_dig_port(&intel_encoder->base);
3435                 if (!intel_dig_port->dp.can_mst)
3436                         continue;
3437
3438                 seq_printf(m, "MST Source Port %c\n",
3439                            port_name(intel_dig_port->base.port));
3440                 drm_dp_mst_dump_topology(m, &intel_dig_port->dp.mst_mgr);
3441         }
3442         drm_connector_list_iter_end(&conn_iter);
3443
3444         return 0;
3445 }
3446
3447 static ssize_t i915_displayport_test_active_write(struct file *file,
3448                                                   const char __user *ubuf,
3449                                                   size_t len, loff_t *offp)
3450 {
3451         char *input_buffer;
3452         int status = 0;
3453         struct drm_device *dev;
3454         struct drm_connector *connector;
3455         struct drm_connector_list_iter conn_iter;
3456         struct intel_dp *intel_dp;
3457         int val = 0;
3458
3459         dev = ((struct seq_file *)file->private_data)->private;
3460
3461         if (len == 0)
3462                 return 0;
3463
3464         input_buffer = memdup_user_nul(ubuf, len);
3465         if (IS_ERR(input_buffer))
3466                 return PTR_ERR(input_buffer);
3467
3468         DRM_DEBUG_DRIVER("Copied %d bytes from user\n", (unsigned int)len);
3469
3470         drm_connector_list_iter_begin(dev, &conn_iter);
3471         drm_for_each_connector_iter(connector, &conn_iter) {
3472                 struct intel_encoder *encoder;
3473
3474                 if (connector->connector_type !=
3475                     DRM_MODE_CONNECTOR_DisplayPort)
3476                         continue;
3477
3478                 encoder = to_intel_encoder(connector->encoder);
3479                 if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3480                         continue;
3481
3482                 if (encoder && connector->status == connector_status_connected) {
3483                         intel_dp = enc_to_intel_dp(&encoder->base);
3484                         status = kstrtoint(input_buffer, 10, &val);
3485                         if (status < 0)
3486                                 break;
3487                         DRM_DEBUG_DRIVER("Got %d for test active\n", val);
3488                         /* To prevent erroneous activation of the compliance
3489                          * testing code, only accept an actual value of 1 here
3490                          */
3491                         if (val == 1)
3492                                 intel_dp->compliance.test_active = 1;
3493                         else
3494                                 intel_dp->compliance.test_active = 0;
3495                 }
3496         }
3497         drm_connector_list_iter_end(&conn_iter);
3498         kfree(input_buffer);
3499         if (status < 0)
3500                 return status;
3501
3502         *offp += len;
3503         return len;
3504 }
3505
3506 static int i915_displayport_test_active_show(struct seq_file *m, void *data)
3507 {
3508         struct drm_i915_private *dev_priv = m->private;
3509         struct drm_device *dev = &dev_priv->drm;
3510         struct drm_connector *connector;
3511         struct drm_connector_list_iter conn_iter;
3512         struct intel_dp *intel_dp;
3513
3514         drm_connector_list_iter_begin(dev, &conn_iter);
3515         drm_for_each_connector_iter(connector, &conn_iter) {
3516                 struct intel_encoder *encoder;
3517
3518                 if (connector->connector_type !=
3519                     DRM_MODE_CONNECTOR_DisplayPort)
3520                         continue;
3521
3522                 encoder = to_intel_encoder(connector->encoder);
3523                 if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3524                         continue;
3525
3526                 if (encoder && connector->status == connector_status_connected) {
3527                         intel_dp = enc_to_intel_dp(&encoder->base);
3528                         if (intel_dp->compliance.test_active)
3529                                 seq_puts(m, "1");
3530                         else
3531                                 seq_puts(m, "0");
3532                 } else
3533                         seq_puts(m, "0");
3534         }
3535         drm_connector_list_iter_end(&conn_iter);
3536
3537         return 0;
3538 }
3539
3540 static int i915_displayport_test_active_open(struct inode *inode,
3541                                              struct file *file)
3542 {
3543         return single_open(file, i915_displayport_test_active_show,
3544                            inode->i_private);
3545 }
3546
3547 static const struct file_operations i915_displayport_test_active_fops = {
3548         .owner = THIS_MODULE,
3549         .open = i915_displayport_test_active_open,
3550         .read = seq_read,
3551         .llseek = seq_lseek,
3552         .release = single_release,
3553         .write = i915_displayport_test_active_write
3554 };
3555
3556 static int i915_displayport_test_data_show(struct seq_file *m, void *data)
3557 {
3558         struct drm_i915_private *dev_priv = m->private;
3559         struct drm_device *dev = &dev_priv->drm;
3560         struct drm_connector *connector;
3561         struct drm_connector_list_iter conn_iter;
3562         struct intel_dp *intel_dp;
3563
3564         drm_connector_list_iter_begin(dev, &conn_iter);
3565         drm_for_each_connector_iter(connector, &conn_iter) {
3566                 struct intel_encoder *encoder;
3567
3568                 if (connector->connector_type !=
3569                     DRM_MODE_CONNECTOR_DisplayPort)
3570                         continue;
3571
3572                 encoder = to_intel_encoder(connector->encoder);
3573                 if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3574                         continue;
3575
3576                 if (encoder && connector->status == connector_status_connected) {
3577                         intel_dp = enc_to_intel_dp(&encoder->base);
3578                         if (intel_dp->compliance.test_type ==
3579                             DP_TEST_LINK_EDID_READ)
3580                                 seq_printf(m, "%lx",
3581                                            intel_dp->compliance.test_data.edid);
3582                         else if (intel_dp->compliance.test_type ==
3583                                  DP_TEST_LINK_VIDEO_PATTERN) {
3584                                 seq_printf(m, "hdisplay: %d\n",
3585                                            intel_dp->compliance.test_data.hdisplay);
3586                                 seq_printf(m, "vdisplay: %d\n",
3587                                            intel_dp->compliance.test_data.vdisplay);
3588                                 seq_printf(m, "bpc: %u\n",
3589                                            intel_dp->compliance.test_data.bpc);
3590                         }
3591                 } else
3592                         seq_puts(m, "0");
3593         }
3594         drm_connector_list_iter_end(&conn_iter);
3595
3596         return 0;
3597 }
3598 DEFINE_SHOW_ATTRIBUTE(i915_displayport_test_data);
3599
3600 static int i915_displayport_test_type_show(struct seq_file *m, void *data)
3601 {
3602         struct drm_i915_private *dev_priv = m->private;
3603         struct drm_device *dev = &dev_priv->drm;
3604         struct drm_connector *connector;
3605         struct drm_connector_list_iter conn_iter;
3606         struct intel_dp *intel_dp;
3607
3608         drm_connector_list_iter_begin(dev, &conn_iter);
3609         drm_for_each_connector_iter(connector, &conn_iter) {
3610                 struct intel_encoder *encoder;
3611
3612                 if (connector->connector_type !=
3613                     DRM_MODE_CONNECTOR_DisplayPort)
3614                         continue;
3615
3616                 encoder = to_intel_encoder(connector->encoder);
3617                 if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3618                         continue;
3619
3620                 if (encoder && connector->status == connector_status_connected) {
3621                         intel_dp = enc_to_intel_dp(&encoder->base);
3622                         seq_printf(m, "%02lx", intel_dp->compliance.test_type);
3623                 } else
3624                         seq_puts(m, "0");
3625         }
3626         drm_connector_list_iter_end(&conn_iter);
3627
3628         return 0;
3629 }
3630 DEFINE_SHOW_ATTRIBUTE(i915_displayport_test_type);
3631
3632 static void wm_latency_show(struct seq_file *m, const u16 wm[8])
3633 {
3634         struct drm_i915_private *dev_priv = m->private;
3635         struct drm_device *dev = &dev_priv->drm;
3636         int level;
3637         int num_levels;
3638
3639         if (IS_CHERRYVIEW(dev_priv))
3640                 num_levels = 3;
3641         else if (IS_VALLEYVIEW(dev_priv))
3642                 num_levels = 1;
3643         else if (IS_G4X(dev_priv))
3644                 num_levels = 3;
3645         else
3646                 num_levels = ilk_wm_max_level(dev_priv) + 1;
3647
3648         drm_modeset_lock_all(dev);
3649
3650         for (level = 0; level < num_levels; level++) {
3651                 unsigned int latency = wm[level];
3652
3653                 /*
3654                  * - WM1+ latency values in 0.5us units
3655                  * - latencies are in us on gen9/vlv/chv
3656                  */
3657                 if (INTEL_GEN(dev_priv) >= 9 ||
3658                     IS_VALLEYVIEW(dev_priv) ||
3659                     IS_CHERRYVIEW(dev_priv) ||
3660                     IS_G4X(dev_priv))
3661                         latency *= 10;
3662                 else if (level > 0)
3663                         latency *= 5;
3664
3665                 seq_printf(m, "WM%d %u (%u.%u usec)\n",
3666                            level, wm[level], latency / 10, latency % 10);
3667         }
3668
3669         drm_modeset_unlock_all(dev);
3670 }
3671
3672 static int pri_wm_latency_show(struct seq_file *m, void *data)
3673 {
3674         struct drm_i915_private *dev_priv = m->private;
3675         const u16 *latencies;
3676
3677         if (INTEL_GEN(dev_priv) >= 9)
3678                 latencies = dev_priv->wm.skl_latency;
3679         else
3680                 latencies = dev_priv->wm.pri_latency;
3681
3682         wm_latency_show(m, latencies);
3683
3684         return 0;
3685 }
3686
3687 static int spr_wm_latency_show(struct seq_file *m, void *data)
3688 {
3689         struct drm_i915_private *dev_priv = m->private;
3690         const u16 *latencies;
3691
3692         if (INTEL_GEN(dev_priv) >= 9)
3693                 latencies = dev_priv->wm.skl_latency;
3694         else
3695                 latencies = dev_priv->wm.spr_latency;
3696
3697         wm_latency_show(m, latencies);
3698
3699         return 0;
3700 }
3701
3702 static int cur_wm_latency_show(struct seq_file *m, void *data)
3703 {
3704         struct drm_i915_private *dev_priv = m->private;
3705         const u16 *latencies;
3706
3707         if (INTEL_GEN(dev_priv) >= 9)
3708                 latencies = dev_priv->wm.skl_latency;
3709         else
3710                 latencies = dev_priv->wm.cur_latency;
3711
3712         wm_latency_show(m, latencies);
3713
3714         return 0;
3715 }
3716
3717 static int pri_wm_latency_open(struct inode *inode, struct file *file)
3718 {
3719         struct drm_i915_private *dev_priv = inode->i_private;
3720
3721         if (INTEL_GEN(dev_priv) < 5 && !IS_G4X(dev_priv))
3722                 return -ENODEV;
3723
3724         return single_open(file, pri_wm_latency_show, dev_priv);
3725 }
3726
3727 static int spr_wm_latency_open(struct inode *inode, struct file *file)
3728 {
3729         struct drm_i915_private *dev_priv = inode->i_private;
3730
3731         if (HAS_GMCH(dev_priv))
3732                 return -ENODEV;
3733
3734         return single_open(file, spr_wm_latency_show, dev_priv);
3735 }
3736
3737 static int cur_wm_latency_open(struct inode *inode, struct file *file)
3738 {
3739         struct drm_i915_private *dev_priv = inode->i_private;
3740
3741         if (HAS_GMCH(dev_priv))
3742                 return -ENODEV;
3743
3744         return single_open(file, cur_wm_latency_show, dev_priv);
3745 }
3746
3747 static ssize_t wm_latency_write(struct file *file, const char __user *ubuf,
3748                                 size_t len, loff_t *offp, u16 wm[8])
3749 {
3750         struct seq_file *m = file->private_data;
3751         struct drm_i915_private *dev_priv = m->private;
3752         struct drm_device *dev = &dev_priv->drm;
3753         u16 new[8] = { 0 };
3754         int num_levels;
3755         int level;
3756         int ret;
3757         char tmp[32];
3758
3759         if (IS_CHERRYVIEW(dev_priv))
3760                 num_levels = 3;
3761         else if (IS_VALLEYVIEW(dev_priv))
3762                 num_levels = 1;
3763         else if (IS_G4X(dev_priv))
3764                 num_levels = 3;
3765         else
3766                 num_levels = ilk_wm_max_level(dev_priv) + 1;
3767
3768         if (len >= sizeof(tmp))
3769                 return -EINVAL;
3770
3771         if (copy_from_user(tmp, ubuf, len))
3772                 return -EFAULT;
3773
3774         tmp[len] = '\0';
3775
3776         ret = sscanf(tmp, "%hu %hu %hu %hu %hu %hu %hu %hu",
3777                      &new[0], &new[1], &new[2], &new[3],
3778                      &new[4], &new[5], &new[6], &new[7]);
3779         if (ret != num_levels)
3780                 return -EINVAL;
3781
3782         drm_modeset_lock_all(dev);
3783
3784         for (level = 0; level < num_levels; level++)
3785                 wm[level] = new[level];
3786
3787         drm_modeset_unlock_all(dev);
3788
3789         return len;
3790 }
3791
3792
3793 static ssize_t pri_wm_latency_write(struct file *file, const char __user *ubuf,
3794                                     size_t len, loff_t *offp)
3795 {
3796         struct seq_file *m = file->private_data;
3797         struct drm_i915_private *dev_priv = m->private;
3798         u16 *latencies;
3799
3800         if (INTEL_GEN(dev_priv) >= 9)
3801                 latencies = dev_priv->wm.skl_latency;
3802         else
3803                 latencies = dev_priv->wm.pri_latency;
3804
3805         return wm_latency_write(file, ubuf, len, offp, latencies);
3806 }
3807
3808 static ssize_t spr_wm_latency_write(struct file *file, const char __user *ubuf,
3809                                     size_t len, loff_t *offp)
3810 {
3811         struct seq_file *m = file->private_data;
3812         struct drm_i915_private *dev_priv = m->private;
3813         u16 *latencies;
3814
3815         if (INTEL_GEN(dev_priv) >= 9)
3816                 latencies = dev_priv->wm.skl_latency;
3817         else
3818                 latencies = dev_priv->wm.spr_latency;
3819
3820         return wm_latency_write(file, ubuf, len, offp, latencies);
3821 }
3822
3823 static ssize_t cur_wm_latency_write(struct file *file, const char __user *ubuf,
3824                                     size_t len, loff_t *offp)
3825 {
3826         struct seq_file *m = file->private_data;
3827         struct drm_i915_private *dev_priv = m->private;
3828         u16 *latencies;
3829
3830         if (INTEL_GEN(dev_priv) >= 9)
3831                 latencies = dev_priv->wm.skl_latency;
3832         else
3833                 latencies = dev_priv->wm.cur_latency;
3834
3835         return wm_latency_write(file, ubuf, len, offp, latencies);
3836 }
3837
3838 static const struct file_operations i915_pri_wm_latency_fops = {
3839         .owner = THIS_MODULE,
3840         .open = pri_wm_latency_open,
3841         .read = seq_read,
3842         .llseek = seq_lseek,
3843         .release = single_release,
3844         .write = pri_wm_latency_write
3845 };
3846
3847 static const struct file_operations i915_spr_wm_latency_fops = {
3848         .owner = THIS_MODULE,
3849         .open = spr_wm_latency_open,
3850         .read = seq_read,
3851         .llseek = seq_lseek,
3852         .release = single_release,
3853         .write = spr_wm_latency_write
3854 };
3855
3856 static const struct file_operations i915_cur_wm_latency_fops = {
3857         .owner = THIS_MODULE,
3858         .open = cur_wm_latency_open,
3859         .read = seq_read,
3860         .llseek = seq_lseek,
3861         .release = single_release,
3862         .write = cur_wm_latency_write
3863 };
3864
3865 static int
3866 i915_wedged_get(void *data, u64 *val)
3867 {
3868         struct drm_i915_private *dev_priv = data;
3869
3870         *val = i915_terminally_wedged(&dev_priv->gpu_error);
3871
3872         return 0;
3873 }
3874
3875 static int
3876 i915_wedged_set(void *data, u64 val)
3877 {
3878         struct drm_i915_private *i915 = data;
3879
3880         /*
3881          * There is no safeguard against this debugfs entry colliding
3882          * with the hangcheck calling same i915_handle_error() in
3883          * parallel, causing an explosion. For now we assume that the
3884          * test harness is responsible enough not to inject gpu hangs
3885          * while it is writing to 'i915_wedged'
3886          */
3887
3888         if (i915_reset_backoff(&i915->gpu_error))
3889                 return -EAGAIN;
3890
3891         i915_handle_error(i915, val, I915_ERROR_CAPTURE,
3892                           "Manually set wedged engine mask = %llx", val);
3893         return 0;
3894 }
3895
3896 DEFINE_SIMPLE_ATTRIBUTE(i915_wedged_fops,
3897                         i915_wedged_get, i915_wedged_set,
3898                         "%llu\n");
3899
3900 #define DROP_UNBOUND    BIT(0)
3901 #define DROP_BOUND      BIT(1)
3902 #define DROP_RETIRE     BIT(2)
3903 #define DROP_ACTIVE     BIT(3)
3904 #define DROP_FREED      BIT(4)
3905 #define DROP_SHRINK_ALL BIT(5)
3906 #define DROP_IDLE       BIT(6)
3907 #define DROP_RESET_ACTIVE       BIT(7)
3908 #define DROP_RESET_SEQNO        BIT(8)
3909 #define DROP_ALL (DROP_UNBOUND  | \
3910                   DROP_BOUND    | \
3911                   DROP_RETIRE   | \
3912                   DROP_ACTIVE   | \
3913                   DROP_FREED    | \
3914                   DROP_SHRINK_ALL |\
3915                   DROP_IDLE     | \
3916                   DROP_RESET_ACTIVE | \
3917                   DROP_RESET_SEQNO)
3918 static int
3919 i915_drop_caches_get(void *data, u64 *val)
3920 {
3921         *val = DROP_ALL;
3922
3923         return 0;
3924 }
3925
3926 static int
3927 i915_drop_caches_set(void *data, u64 val)
3928 {
3929         struct drm_i915_private *i915 = data;
3930         intel_wakeref_t wakeref;
3931         int ret = 0;
3932
3933         DRM_DEBUG("Dropping caches: 0x%08llx [0x%08llx]\n",
3934                   val, val & DROP_ALL);
3935         wakeref = intel_runtime_pm_get(i915);
3936
3937         if (val & DROP_RESET_ACTIVE &&
3938             wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT))
3939                 i915_gem_set_wedged(i915);
3940
3941         /* No need to check and wait for gpu resets, only libdrm auto-restarts
3942          * on ioctls on -EAGAIN. */
3943         if (val & (DROP_ACTIVE | DROP_RETIRE | DROP_RESET_SEQNO)) {
3944                 ret = mutex_lock_interruptible(&i915->drm.struct_mutex);
3945                 if (ret)
3946                         goto out;
3947
3948                 if (val & DROP_ACTIVE)
3949                         ret = i915_gem_wait_for_idle(i915,
3950                                                      I915_WAIT_INTERRUPTIBLE |
3951                                                      I915_WAIT_LOCKED,
3952                                                      MAX_SCHEDULE_TIMEOUT);
3953
3954                 if (val & DROP_RETIRE)
3955                         i915_retire_requests(i915);
3956
3957                 mutex_unlock(&i915->drm.struct_mutex);
3958         }
3959
3960         if (val & DROP_RESET_ACTIVE && i915_terminally_wedged(&i915->gpu_error))
3961                 i915_handle_error(i915, ALL_ENGINES, 0, NULL);
3962
3963         fs_reclaim_acquire(GFP_KERNEL);
3964         if (val & DROP_BOUND)
3965                 i915_gem_shrink(i915, LONG_MAX, NULL, I915_SHRINK_BOUND);
3966
3967         if (val & DROP_UNBOUND)
3968                 i915_gem_shrink(i915, LONG_MAX, NULL, I915_SHRINK_UNBOUND);
3969
3970         if (val & DROP_SHRINK_ALL)
3971                 i915_gem_shrink_all(i915);
3972         fs_reclaim_release(GFP_KERNEL);
3973
3974         if (val & DROP_IDLE) {
3975                 do {
3976                         if (READ_ONCE(i915->gt.active_requests))
3977                                 flush_delayed_work(&i915->gt.retire_work);
3978                         drain_delayed_work(&i915->gt.idle_work);
3979                 } while (READ_ONCE(i915->gt.awake));
3980         }
3981
3982         if (val & DROP_FREED)
3983                 i915_gem_drain_freed_objects(i915);
3984
3985 out:
3986         intel_runtime_pm_put(i915, wakeref);
3987
3988         return ret;
3989 }
3990
3991 DEFINE_SIMPLE_ATTRIBUTE(i915_drop_caches_fops,
3992                         i915_drop_caches_get, i915_drop_caches_set,
3993                         "0x%08llx\n");
3994
3995 static int
3996 i915_cache_sharing_get(void *data, u64 *val)
3997 {
3998         struct drm_i915_private *dev_priv = data;
3999         intel_wakeref_t wakeref;
4000         u32 snpcr = 0;
4001
4002         if (!(IS_GEN_RANGE(dev_priv, 6, 7)))
4003                 return -ENODEV;
4004
4005         with_intel_runtime_pm(dev_priv, wakeref)
4006                 snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
4007
4008         *val = (snpcr & GEN6_MBC_SNPCR_MASK) >> GEN6_MBC_SNPCR_SHIFT;
4009
4010         return 0;
4011 }
4012
4013 static int
4014 i915_cache_sharing_set(void *data, u64 val)
4015 {
4016         struct drm_i915_private *dev_priv = data;
4017         intel_wakeref_t wakeref;
4018
4019         if (!(IS_GEN_RANGE(dev_priv, 6, 7)))
4020                 return -ENODEV;
4021
4022         if (val > 3)
4023                 return -EINVAL;
4024
4025         DRM_DEBUG_DRIVER("Manually setting uncore sharing to %llu\n", val);
4026         with_intel_runtime_pm(dev_priv, wakeref) {
4027                 u32 snpcr;
4028
4029                 /* Update the cache sharing policy here as well */
4030                 snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
4031                 snpcr &= ~GEN6_MBC_SNPCR_MASK;
4032                 snpcr |= val << GEN6_MBC_SNPCR_SHIFT;
4033                 I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
4034         }
4035
4036         return 0;
4037 }
4038
4039 DEFINE_SIMPLE_ATTRIBUTE(i915_cache_sharing_fops,
4040                         i915_cache_sharing_get, i915_cache_sharing_set,
4041                         "%llu\n");
4042
4043 static void cherryview_sseu_device_status(struct drm_i915_private *dev_priv,
4044                                           struct sseu_dev_info *sseu)
4045 {
4046 #define SS_MAX 2
4047         const int ss_max = SS_MAX;
4048         u32 sig1[SS_MAX], sig2[SS_MAX];
4049         int ss;
4050
4051         sig1[0] = I915_READ(CHV_POWER_SS0_SIG1);
4052         sig1[1] = I915_READ(CHV_POWER_SS1_SIG1);
4053         sig2[0] = I915_READ(CHV_POWER_SS0_SIG2);
4054         sig2[1] = I915_READ(CHV_POWER_SS1_SIG2);
4055
4056         for (ss = 0; ss < ss_max; ss++) {
4057                 unsigned int eu_cnt;
4058
4059                 if (sig1[ss] & CHV_SS_PG_ENABLE)
4060                         /* skip disabled subslice */
4061                         continue;
4062
4063                 sseu->slice_mask = BIT(0);
4064                 sseu->subslice_mask[0] |= BIT(ss);
4065                 eu_cnt = ((sig1[ss] & CHV_EU08_PG_ENABLE) ? 0 : 2) +
4066                          ((sig1[ss] & CHV_EU19_PG_ENABLE) ? 0 : 2) +
4067                          ((sig1[ss] & CHV_EU210_PG_ENABLE) ? 0 : 2) +
4068                          ((sig2[ss] & CHV_EU311_PG_ENABLE) ? 0 : 2);
4069                 sseu->eu_total += eu_cnt;
4070                 sseu->eu_per_subslice = max_t(unsigned int,
4071                                               sseu->eu_per_subslice, eu_cnt);
4072         }
4073 #undef SS_MAX
4074 }
4075
4076 static void gen10_sseu_device_status(struct drm_i915_private *dev_priv,
4077                                      struct sseu_dev_info *sseu)
4078 {
4079 #define SS_MAX 6
4080         const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
4081         u32 s_reg[SS_MAX], eu_reg[2 * SS_MAX], eu_mask[2];
4082         int s, ss;
4083
4084         for (s = 0; s < info->sseu.max_slices; s++) {
4085                 /*
4086                  * FIXME: Valid SS Mask respects the spec and read
4087                  * only valid bits for those registers, excluding reserved
4088                  * although this seems wrong because it would leave many
4089                  * subslices without ACK.
4090                  */
4091                 s_reg[s] = I915_READ(GEN10_SLICE_PGCTL_ACK(s)) &
4092                         GEN10_PGCTL_VALID_SS_MASK(s);
4093                 eu_reg[2 * s] = I915_READ(GEN10_SS01_EU_PGCTL_ACK(s));
4094                 eu_reg[2 * s + 1] = I915_READ(GEN10_SS23_EU_PGCTL_ACK(s));
4095         }
4096
4097         eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK |
4098                      GEN9_PGCTL_SSA_EU19_ACK |
4099                      GEN9_PGCTL_SSA_EU210_ACK |
4100                      GEN9_PGCTL_SSA_EU311_ACK;
4101         eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK |
4102                      GEN9_PGCTL_SSB_EU19_ACK |
4103                      GEN9_PGCTL_SSB_EU210_ACK |
4104                      GEN9_PGCTL_SSB_EU311_ACK;
4105
4106         for (s = 0; s < info->sseu.max_slices; s++) {
4107                 if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0)
4108                         /* skip disabled slice */
4109                         continue;
4110
4111                 sseu->slice_mask |= BIT(s);
4112                 sseu->subslice_mask[s] = info->sseu.subslice_mask[s];
4113
4114                 for (ss = 0; ss < info->sseu.max_subslices; ss++) {
4115                         unsigned int eu_cnt;
4116
4117                         if (!(s_reg[s] & (GEN9_PGCTL_SS_ACK(ss))))
4118                                 /* skip disabled subslice */
4119                                 continue;
4120
4121                         eu_cnt = 2 * hweight32(eu_reg[2 * s + ss / 2] &
4122                                                eu_mask[ss % 2]);
4123                         sseu->eu_total += eu_cnt;
4124                         sseu->eu_per_subslice = max_t(unsigned int,
4125                                                       sseu->eu_per_subslice,
4126                                                       eu_cnt);
4127                 }
4128         }
4129 #undef SS_MAX
4130 }
4131
4132 static void gen9_sseu_device_status(struct drm_i915_private *dev_priv,
4133                                     struct sseu_dev_info *sseu)
4134 {
4135 #define SS_MAX 3
4136         const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
4137         u32 s_reg[SS_MAX], eu_reg[2 * SS_MAX], eu_mask[2];
4138         int s, ss;
4139
4140         for (s = 0; s < info->sseu.max_slices; s++) {
4141                 s_reg[s] = I915_READ(GEN9_SLICE_PGCTL_ACK(s));
4142                 eu_reg[2*s] = I915_READ(GEN9_SS01_EU_PGCTL_ACK(s));
4143                 eu_reg[2*s + 1] = I915_READ(GEN9_SS23_EU_PGCTL_ACK(s));
4144         }
4145
4146         eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK |
4147                      GEN9_PGCTL_SSA_EU19_ACK |
4148                      GEN9_PGCTL_SSA_EU210_ACK |
4149                      GEN9_PGCTL_SSA_EU311_ACK;
4150         eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK |
4151                      GEN9_PGCTL_SSB_EU19_ACK |
4152                      GEN9_PGCTL_SSB_EU210_ACK |
4153                      GEN9_PGCTL_SSB_EU311_ACK;
4154
4155         for (s = 0; s < info->sseu.max_slices; s++) {
4156                 if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0)
4157                         /* skip disabled slice */
4158                         continue;
4159
4160                 sseu->slice_mask |= BIT(s);
4161
4162                 if (IS_GEN9_BC(dev_priv))
4163                         sseu->subslice_mask[s] =
4164                                 RUNTIME_INFO(dev_priv)->sseu.subslice_mask[s];
4165
4166                 for (ss = 0; ss < info->sseu.max_subslices; ss++) {
4167                         unsigned int eu_cnt;
4168
4169                         if (IS_GEN9_LP(dev_priv)) {
4170                                 if (!(s_reg[s] & (GEN9_PGCTL_SS_ACK(ss))))
4171                                         /* skip disabled subslice */
4172                                         continue;
4173
4174                                 sseu->subslice_mask[s] |= BIT(ss);
4175                         }
4176
4177                         eu_cnt = 2 * hweight32(eu_reg[2*s + ss/2] &
4178                                                eu_mask[ss%2]);
4179                         sseu->eu_total += eu_cnt;
4180                         sseu->eu_per_subslice = max_t(unsigned int,
4181                                                       sseu->eu_per_subslice,
4182                                                       eu_cnt);
4183                 }
4184         }
4185 #undef SS_MAX
4186 }
4187
4188 static void broadwell_sseu_device_status(struct drm_i915_private *dev_priv,
4189                                          struct sseu_dev_info *sseu)
4190 {
4191         u32 slice_info = I915_READ(GEN8_GT_SLICE_INFO);
4192         int s;
4193
4194         sseu->slice_mask = slice_info & GEN8_LSLICESTAT_MASK;
4195
4196         if (sseu->slice_mask) {
4197                 sseu->eu_per_subslice =
4198                         RUNTIME_INFO(dev_priv)->sseu.eu_per_subslice;
4199                 for (s = 0; s < fls(sseu->slice_mask); s++) {
4200                         sseu->subslice_mask[s] =
4201                                 RUNTIME_INFO(dev_priv)->sseu.subslice_mask[s];
4202                 }
4203                 sseu->eu_total = sseu->eu_per_subslice *
4204                                  sseu_subslice_total(sseu);
4205
4206                 /* subtract fused off EU(s) from enabled slice(s) */
4207                 for (s = 0; s < fls(sseu->slice_mask); s++) {
4208                         u8 subslice_7eu =
4209                                 RUNTIME_INFO(dev_priv)->sseu.subslice_7eu[s];
4210
4211                         sseu->eu_total -= hweight8(subslice_7eu);
4212                 }
4213         }
4214 }
4215
4216 static void i915_print_sseu_info(struct seq_file *m, bool is_available_info,
4217                                  const struct sseu_dev_info *sseu)
4218 {
4219         struct drm_i915_private *dev_priv = node_to_i915(m->private);
4220         const char *type = is_available_info ? "Available" : "Enabled";
4221         int s;
4222
4223         seq_printf(m, "  %s Slice Mask: %04x\n", type,
4224                    sseu->slice_mask);
4225         seq_printf(m, "  %s Slice Total: %u\n", type,
4226                    hweight8(sseu->slice_mask));
4227         seq_printf(m, "  %s Subslice Total: %u\n", type,
4228                    sseu_subslice_total(sseu));
4229         for (s = 0; s < fls(sseu->slice_mask); s++) {
4230                 seq_printf(m, "  %s Slice%i subslices: %u\n", type,
4231                            s, hweight8(sseu->subslice_mask[s]));
4232         }
4233         seq_printf(m, "  %s EU Total: %u\n", type,
4234                    sseu->eu_total);
4235         seq_printf(m, "  %s EU Per Subslice: %u\n", type,
4236                    sseu->eu_per_subslice);
4237
4238         if (!is_available_info)
4239                 return;
4240
4241         seq_printf(m, "  Has Pooled EU: %s\n", yesno(HAS_POOLED_EU(dev_priv)));
4242         if (HAS_POOLED_EU(dev_priv))
4243                 seq_printf(m, "  Min EU in pool: %u\n", sseu->min_eu_in_pool);
4244
4245         seq_printf(m, "  Has Slice Power Gating: %s\n",
4246                    yesno(sseu->has_slice_pg));
4247         seq_printf(m, "  Has Subslice Power Gating: %s\n",
4248                    yesno(sseu->has_subslice_pg));
4249         seq_printf(m, "  Has EU Power Gating: %s\n",
4250                    yesno(sseu->has_eu_pg));
4251 }
4252
4253 static int i915_sseu_status(struct seq_file *m, void *unused)
4254 {
4255         struct drm_i915_private *dev_priv = node_to_i915(m->private);
4256         struct sseu_dev_info sseu;
4257         intel_wakeref_t wakeref;
4258
4259         if (INTEL_GEN(dev_priv) < 8)
4260                 return -ENODEV;
4261
4262         seq_puts(m, "SSEU Device Info\n");
4263         i915_print_sseu_info(m, true, &RUNTIME_INFO(dev_priv)->sseu);
4264
4265         seq_puts(m, "SSEU Device Status\n");
4266         memset(&sseu, 0, sizeof(sseu));
4267         sseu.max_slices = RUNTIME_INFO(dev_priv)->sseu.max_slices;
4268         sseu.max_subslices = RUNTIME_INFO(dev_priv)->sseu.max_subslices;
4269         sseu.max_eus_per_subslice =
4270                 RUNTIME_INFO(dev_priv)->sseu.max_eus_per_subslice;
4271
4272         with_intel_runtime_pm(dev_priv, wakeref) {
4273                 if (IS_CHERRYVIEW(dev_priv))
4274                         cherryview_sseu_device_status(dev_priv, &sseu);
4275                 else if (IS_BROADWELL(dev_priv))
4276                         broadwell_sseu_device_status(dev_priv, &sseu);
4277                 else if (IS_GEN(dev_priv, 9))
4278                         gen9_sseu_device_status(dev_priv, &sseu);
4279                 else if (INTEL_GEN(dev_priv) >= 10)
4280                         gen10_sseu_device_status(dev_priv, &sseu);
4281         }
4282
4283         i915_print_sseu_info(m, false, &sseu);
4284
4285         return 0;
4286 }
4287
4288 static int i915_forcewake_open(struct inode *inode, struct file *file)
4289 {
4290         struct drm_i915_private *i915 = inode->i_private;
4291
4292         if (INTEL_GEN(i915) < 6)
4293                 return 0;
4294
4295         file->private_data = (void *)(uintptr_t)intel_runtime_pm_get(i915);
4296         intel_uncore_forcewake_user_get(i915);
4297
4298         return 0;
4299 }
4300
4301 static int i915_forcewake_release(struct inode *inode, struct file *file)
4302 {
4303         struct drm_i915_private *i915 = inode->i_private;
4304
4305         if (INTEL_GEN(i915) < 6)
4306                 return 0;
4307
4308         intel_uncore_forcewake_user_put(i915);
4309         intel_runtime_pm_put(i915,
4310                              (intel_wakeref_t)(uintptr_t)file->private_data);
4311
4312         return 0;
4313 }
4314
4315 static const struct file_operations i915_forcewake_fops = {
4316         .owner = THIS_MODULE,
4317         .open = i915_forcewake_open,
4318         .release = i915_forcewake_release,
4319 };
4320
4321 static int i915_hpd_storm_ctl_show(struct seq_file *m, void *data)
4322 {
4323         struct drm_i915_private *dev_priv = m->private;
4324         struct i915_hotplug *hotplug = &dev_priv->hotplug;
4325
4326         /* Synchronize with everything first in case there's been an HPD
4327          * storm, but we haven't finished handling it in the kernel yet
4328          */
4329         synchronize_irq(dev_priv->drm.irq);
4330         flush_work(&dev_priv->hotplug.dig_port_work);
4331         flush_work(&dev_priv->hotplug.hotplug_work);
4332
4333         seq_printf(m, "Threshold: %d\n", hotplug->hpd_storm_threshold);
4334         seq_printf(m, "Detected: %s\n",
4335                    yesno(delayed_work_pending(&hotplug->reenable_work)));
4336
4337         return 0;
4338 }
4339
4340 static ssize_t i915_hpd_storm_ctl_write(struct file *file,
4341                                         const char __user *ubuf, size_t len,
4342                                         loff_t *offp)
4343 {
4344         struct seq_file *m = file->private_data;
4345         struct drm_i915_private *dev_priv = m->private;
4346         struct i915_hotplug *hotplug = &dev_priv->hotplug;
4347         unsigned int new_threshold;
4348         int i;
4349         char *newline;
4350         char tmp[16];
4351
4352         if (len >= sizeof(tmp))
4353                 return -EINVAL;
4354
4355         if (copy_from_user(tmp, ubuf, len))
4356                 return -EFAULT;
4357
4358         tmp[len] = '\0';
4359
4360         /* Strip newline, if any */
4361         newline = strchr(tmp, '\n');
4362         if (newline)
4363                 *newline = '\0';
4364
4365         if (strcmp(tmp, "reset") == 0)
4366                 new_threshold = HPD_STORM_DEFAULT_THRESHOLD;
4367         else if (kstrtouint(tmp, 10, &new_threshold) != 0)
4368                 return -EINVAL;
4369
4370         if (new_threshold > 0)
4371                 DRM_DEBUG_KMS("Setting HPD storm detection threshold to %d\n",
4372                               new_threshold);
4373         else
4374                 DRM_DEBUG_KMS("Disabling HPD storm detection\n");
4375
4376         spin_lock_irq(&dev_priv->irq_lock);
4377         hotplug->hpd_storm_threshold = new_threshold;
4378         /* Reset the HPD storm stats so we don't accidentally trigger a storm */
4379         for_each_hpd_pin(i)
4380                 hotplug->stats[i].count = 0;
4381         spin_unlock_irq(&dev_priv->irq_lock);
4382
4383         /* Re-enable hpd immediately if we were in an irq storm */
4384         flush_delayed_work(&dev_priv->hotplug.reenable_work);
4385
4386         return len;
4387 }
4388
4389 static int i915_hpd_storm_ctl_open(struct inode *inode, struct file *file)
4390 {
4391         return single_open(file, i915_hpd_storm_ctl_show, inode->i_private);
4392 }
4393
4394 static const struct file_operations i915_hpd_storm_ctl_fops = {
4395         .owner = THIS_MODULE,
4396         .open = i915_hpd_storm_ctl_open,
4397         .read = seq_read,
4398         .llseek = seq_lseek,
4399         .release = single_release,
4400         .write = i915_hpd_storm_ctl_write
4401 };
4402
4403 static int i915_hpd_short_storm_ctl_show(struct seq_file *m, void *data)
4404 {
4405         struct drm_i915_private *dev_priv = m->private;
4406
4407         seq_printf(m, "Enabled: %s\n",
4408                    yesno(dev_priv->hotplug.hpd_short_storm_enabled));
4409
4410         return 0;
4411 }
4412
4413 static int
4414 i915_hpd_short_storm_ctl_open(struct inode *inode, struct file *file)
4415 {
4416         return single_open(file, i915_hpd_short_storm_ctl_show,
4417                            inode->i_private);
4418 }
4419
4420 static ssize_t i915_hpd_short_storm_ctl_write(struct file *file,
4421                                               const char __user *ubuf,
4422                                               size_t len, loff_t *offp)
4423 {
4424         struct seq_file *m = file->private_data;
4425         struct drm_i915_private *dev_priv = m->private;
4426         struct i915_hotplug *hotplug = &dev_priv->hotplug;
4427         char *newline;
4428         char tmp[16];
4429         int i;
4430         bool new_state;
4431
4432         if (len >= sizeof(tmp))
4433                 return -EINVAL;
4434
4435         if (copy_from_user(tmp, ubuf, len))
4436                 return -EFAULT;
4437
4438         tmp[len] = '\0';
4439
4440         /* Strip newline, if any */
4441         newline = strchr(tmp, '\n');
4442         if (newline)
4443                 *newline = '\0';
4444
4445         /* Reset to the "default" state for this system */
4446         if (strcmp(tmp, "reset") == 0)
4447                 new_state = !HAS_DP_MST(dev_priv);
4448         else if (kstrtobool(tmp, &new_state) != 0)
4449                 return -EINVAL;
4450
4451         DRM_DEBUG_KMS("%sabling HPD short storm detection\n",
4452                       new_state ? "En" : "Dis");
4453
4454         spin_lock_irq(&dev_priv->irq_lock);
4455         hotplug->hpd_short_storm_enabled = new_state;
4456         /* Reset the HPD storm stats so we don't accidentally trigger a storm */
4457         for_each_hpd_pin(i)
4458                 hotplug->stats[i].count = 0;
4459         spin_unlock_irq(&dev_priv->irq_lock);
4460
4461         /* Re-enable hpd immediately if we were in an irq storm */
4462         flush_delayed_work(&dev_priv->hotplug.reenable_work);
4463
4464         return len;
4465 }
4466
4467 static const struct file_operations i915_hpd_short_storm_ctl_fops = {
4468         .owner = THIS_MODULE,
4469         .open = i915_hpd_short_storm_ctl_open,
4470         .read = seq_read,
4471         .llseek = seq_lseek,
4472         .release = single_release,
4473         .write = i915_hpd_short_storm_ctl_write,
4474 };
4475
4476 static int i915_drrs_ctl_set(void *data, u64 val)
4477 {
4478         struct drm_i915_private *dev_priv = data;
4479         struct drm_device *dev = &dev_priv->drm;
4480         struct intel_crtc *crtc;
4481
4482         if (INTEL_GEN(dev_priv) < 7)
4483                 return -ENODEV;
4484
4485         for_each_intel_crtc(dev, crtc) {
4486                 struct drm_connector_list_iter conn_iter;
4487                 struct intel_crtc_state *crtc_state;
4488                 struct drm_connector *connector;
4489                 struct drm_crtc_commit *commit;
4490                 int ret;
4491
4492                 ret = drm_modeset_lock_single_interruptible(&crtc->base.mutex);
4493                 if (ret)
4494                         return ret;
4495
4496                 crtc_state = to_intel_crtc_state(crtc->base.state);
4497
4498                 if (!crtc_state->base.active ||
4499                     !crtc_state->has_drrs)
4500                         goto out;
4501
4502                 commit = crtc_state->base.commit;
4503                 if (commit) {
4504                         ret = wait_for_completion_interruptible(&commit->hw_done);
4505                         if (ret)
4506                                 goto out;
4507                 }
4508
4509                 drm_connector_list_iter_begin(dev, &conn_iter);
4510                 drm_for_each_connector_iter(connector, &conn_iter) {
4511                         struct intel_encoder *encoder;
4512                         struct intel_dp *intel_dp;
4513
4514                         if (!(crtc_state->base.connector_mask &
4515                               drm_connector_mask(connector)))
4516                                 continue;
4517
4518                         encoder = intel_attached_encoder(connector);
4519                         if (encoder->type != INTEL_OUTPUT_EDP)
4520                                 continue;
4521
4522                         DRM_DEBUG_DRIVER("Manually %sabling DRRS. %llu\n",
4523                                                 val ? "en" : "dis", val);
4524
4525                         intel_dp = enc_to_intel_dp(&encoder->base);
4526                         if (val)
4527                                 intel_edp_drrs_enable(intel_dp,
4528                                                       crtc_state);
4529                         else
4530                                 intel_edp_drrs_disable(intel_dp,
4531                                                        crtc_state);
4532                 }
4533                 drm_connector_list_iter_end(&conn_iter);
4534
4535 out:
4536                 drm_modeset_unlock(&crtc->base.mutex);
4537                 if (ret)
4538                         return ret;
4539         }
4540
4541         return 0;
4542 }
4543
4544 DEFINE_SIMPLE_ATTRIBUTE(i915_drrs_ctl_fops, NULL, i915_drrs_ctl_set, "%llu\n");
4545
4546 static ssize_t
4547 i915_fifo_underrun_reset_write(struct file *filp,
4548                                const char __user *ubuf,
4549                                size_t cnt, loff_t *ppos)
4550 {
4551         struct drm_i915_private *dev_priv = filp->private_data;
4552         struct intel_crtc *intel_crtc;
4553         struct drm_device *dev = &dev_priv->drm;
4554         int ret;
4555         bool reset;
4556
4557         ret = kstrtobool_from_user(ubuf, cnt, &reset);
4558         if (ret)
4559                 return ret;
4560
4561         if (!reset)
4562                 return cnt;
4563
4564         for_each_intel_crtc(dev, intel_crtc) {
4565                 struct drm_crtc_commit *commit;
4566                 struct intel_crtc_state *crtc_state;
4567
4568                 ret = drm_modeset_lock_single_interruptible(&intel_crtc->base.mutex);
4569                 if (ret)
4570                         return ret;
4571
4572                 crtc_state = to_intel_crtc_state(intel_crtc->base.state);
4573                 commit = crtc_state->base.commit;
4574                 if (commit) {
4575                         ret = wait_for_completion_interruptible(&commit->hw_done);
4576                         if (!ret)
4577                                 ret = wait_for_completion_interruptible(&commit->flip_done);
4578                 }
4579
4580                 if (!ret && crtc_state->base.active) {
4581                         DRM_DEBUG_KMS("Re-arming FIFO underruns on pipe %c\n",
4582                                       pipe_name(intel_crtc->pipe));
4583
4584                         intel_crtc_arm_fifo_underrun(intel_crtc, crtc_state);
4585                 }
4586
4587                 drm_modeset_unlock(&intel_crtc->base.mutex);
4588
4589                 if (ret)
4590                         return ret;
4591         }
4592
4593         ret = intel_fbc_reset_underrun(dev_priv);
4594         if (ret)
4595                 return ret;
4596
4597         return cnt;
4598 }
4599
4600 static const struct file_operations i915_fifo_underrun_reset_ops = {
4601         .owner = THIS_MODULE,
4602         .open = simple_open,
4603         .write = i915_fifo_underrun_reset_write,
4604         .llseek = default_llseek,
4605 };
4606
4607 static const struct drm_info_list i915_debugfs_list[] = {
4608         {"i915_capabilities", i915_capabilities, 0},
4609         {"i915_gem_objects", i915_gem_object_info, 0},
4610         {"i915_gem_gtt", i915_gem_gtt_info, 0},
4611         {"i915_gem_stolen", i915_gem_stolen_list_info },
4612         {"i915_gem_fence_regs", i915_gem_fence_regs_info, 0},
4613         {"i915_gem_interrupt", i915_interrupt_info, 0},
4614         {"i915_gem_batch_pool", i915_gem_batch_pool_info, 0},
4615         {"i915_guc_info", i915_guc_info, 0},
4616         {"i915_guc_load_status", i915_guc_load_status_info, 0},
4617         {"i915_guc_log_dump", i915_guc_log_dump, 0},
4618         {"i915_guc_load_err_log_dump", i915_guc_log_dump, 0, (void *)1},
4619         {"i915_guc_stage_pool", i915_guc_stage_pool, 0},
4620         {"i915_huc_load_status", i915_huc_load_status_info, 0},
4621         {"i915_frequency_info", i915_frequency_info, 0},
4622         {"i915_hangcheck_info", i915_hangcheck_info, 0},
4623         {"i915_reset_info", i915_reset_info, 0},
4624         {"i915_drpc_info", i915_drpc_info, 0},
4625         {"i915_emon_status", i915_emon_status, 0},
4626         {"i915_ring_freq_table", i915_ring_freq_table, 0},
4627         {"i915_frontbuffer_tracking", i915_frontbuffer_tracking, 0},
4628         {"i915_fbc_status", i915_fbc_status, 0},
4629         {"i915_ips_status", i915_ips_status, 0},
4630         {"i915_sr_status", i915_sr_status, 0},
4631         {"i915_opregion", i915_opregion, 0},
4632         {"i915_vbt", i915_vbt, 0},
4633         {"i915_gem_framebuffer", i915_gem_framebuffer_info, 0},
4634         {"i915_context_status", i915_context_status, 0},
4635         {"i915_forcewake_domains", i915_forcewake_domains, 0},
4636         {"i915_swizzle_info", i915_swizzle_info, 0},
4637         {"i915_llc", i915_llc, 0},
4638         {"i915_edp_psr_status", i915_edp_psr_status, 0},
4639         {"i915_energy_uJ", i915_energy_uJ, 0},
4640         {"i915_runtime_pm_status", i915_runtime_pm_status, 0},
4641         {"i915_power_domain_info", i915_power_domain_info, 0},
4642         {"i915_dmc_info", i915_dmc_info, 0},
4643         {"i915_display_info", i915_display_info, 0},
4644         {"i915_engine_info", i915_engine_info, 0},
4645         {"i915_rcs_topology", i915_rcs_topology, 0},
4646         {"i915_shrinker_info", i915_shrinker_info, 0},
4647         {"i915_shared_dplls_info", i915_shared_dplls_info, 0},
4648         {"i915_dp_mst_info", i915_dp_mst_info, 0},
4649         {"i915_wa_registers", i915_wa_registers, 0},
4650         {"i915_ddb_info", i915_ddb_info, 0},
4651         {"i915_sseu_status", i915_sseu_status, 0},
4652         {"i915_drrs_status", i915_drrs_status, 0},
4653         {"i915_rps_boost_info", i915_rps_boost_info, 0},
4654 };
4655 #define I915_DEBUGFS_ENTRIES ARRAY_SIZE(i915_debugfs_list)
4656
4657 static const struct i915_debugfs_files {
4658         const char *name;
4659         const struct file_operations *fops;
4660 } i915_debugfs_files[] = {
4661         {"i915_wedged", &i915_wedged_fops},
4662         {"i915_cache_sharing", &i915_cache_sharing_fops},
4663         {"i915_gem_drop_caches", &i915_drop_caches_fops},
4664 #if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR)
4665         {"i915_error_state", &i915_error_state_fops},
4666         {"i915_gpu_info", &i915_gpu_info_fops},
4667 #endif
4668         {"i915_fifo_underrun_reset", &i915_fifo_underrun_reset_ops},
4669         {"i915_pri_wm_latency", &i915_pri_wm_latency_fops},
4670         {"i915_spr_wm_latency", &i915_spr_wm_latency_fops},
4671         {"i915_cur_wm_latency", &i915_cur_wm_latency_fops},
4672         {"i915_fbc_false_color", &i915_fbc_false_color_fops},
4673         {"i915_dp_test_data", &i915_displayport_test_data_fops},
4674         {"i915_dp_test_type", &i915_displayport_test_type_fops},
4675         {"i915_dp_test_active", &i915_displayport_test_active_fops},
4676         {"i915_guc_log_level", &i915_guc_log_level_fops},
4677         {"i915_guc_log_relay", &i915_guc_log_relay_fops},
4678         {"i915_hpd_storm_ctl", &i915_hpd_storm_ctl_fops},
4679         {"i915_hpd_short_storm_ctl", &i915_hpd_short_storm_ctl_fops},
4680         {"i915_ipc_status", &i915_ipc_status_fops},
4681         {"i915_drrs_ctl", &i915_drrs_ctl_fops},
4682         {"i915_edp_psr_debug", &i915_edp_psr_debug_fops}
4683 };
4684
4685 int i915_debugfs_register(struct drm_i915_private *dev_priv)
4686 {
4687         struct drm_minor *minor = dev_priv->drm.primary;
4688         struct dentry *ent;
4689         int i;
4690
4691         ent = debugfs_create_file("i915_forcewake_user", S_IRUSR,
4692                                   minor->debugfs_root, to_i915(minor->dev),
4693                                   &i915_forcewake_fops);
4694         if (!ent)
4695                 return -ENOMEM;
4696
4697         for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
4698                 ent = debugfs_create_file(i915_debugfs_files[i].name,
4699                                           S_IRUGO | S_IWUSR,
4700                                           minor->debugfs_root,
4701                                           to_i915(minor->dev),
4702                                           i915_debugfs_files[i].fops);
4703                 if (!ent)
4704                         return -ENOMEM;
4705         }
4706
4707         return drm_debugfs_create_files(i915_debugfs_list,
4708                                         I915_DEBUGFS_ENTRIES,
4709                                         minor->debugfs_root, minor);
4710 }
4711
4712 struct dpcd_block {
4713         /* DPCD dump start address. */
4714         unsigned int offset;
4715         /* DPCD dump end address, inclusive. If unset, .size will be used. */
4716         unsigned int end;
4717         /* DPCD dump size. Used if .end is unset. If unset, defaults to 1. */
4718         size_t size;
4719         /* Only valid for eDP. */
4720         bool edp;
4721 };
4722
4723 static const struct dpcd_block i915_dpcd_debug[] = {
4724         { .offset = DP_DPCD_REV, .size = DP_RECEIVER_CAP_SIZE },
4725         { .offset = DP_PSR_SUPPORT, .end = DP_PSR_CAPS },
4726         { .offset = DP_DOWNSTREAM_PORT_0, .size = 16 },
4727         { .offset = DP_LINK_BW_SET, .end = DP_EDP_CONFIGURATION_SET },
4728         { .offset = DP_SINK_COUNT, .end = DP_ADJUST_REQUEST_LANE2_3 },
4729         { .offset = DP_SET_POWER },
4730         { .offset = DP_EDP_DPCD_REV },
4731         { .offset = DP_EDP_GENERAL_CAP_1, .end = DP_EDP_GENERAL_CAP_3 },
4732         { .offset = DP_EDP_DISPLAY_CONTROL_REGISTER, .end = DP_EDP_BACKLIGHT_FREQ_CAP_MAX_LSB },
4733         { .offset = DP_EDP_DBC_MINIMUM_BRIGHTNESS_SET, .end = DP_EDP_DBC_MAXIMUM_BRIGHTNESS_SET },
4734 };
4735
4736 static int i915_dpcd_show(struct seq_file *m, void *data)
4737 {
4738         struct drm_connector *connector = m->private;
4739         struct intel_dp *intel_dp =
4740                 enc_to_intel_dp(&intel_attached_encoder(connector)->base);
4741         u8 buf[16];
4742         ssize_t err;
4743         int i;
4744
4745         if (connector->status != connector_status_connected)
4746                 return -ENODEV;
4747
4748         for (i = 0; i < ARRAY_SIZE(i915_dpcd_debug); i++) {
4749                 const struct dpcd_block *b = &i915_dpcd_debug[i];
4750                 size_t size = b->end ? b->end - b->offset + 1 : (b->size ?: 1);
4751
4752                 if (b->edp &&
4753                     connector->connector_type != DRM_MODE_CONNECTOR_eDP)
4754                         continue;
4755
4756                 /* low tech for now */
4757                 if (WARN_ON(size > sizeof(buf)))
4758                         continue;
4759
4760                 err = drm_dp_dpcd_read(&intel_dp->aux, b->offset, buf, size);
4761                 if (err < 0)
4762                         seq_printf(m, "%04x: ERROR %d\n", b->offset, (int)err);
4763                 else
4764                         seq_printf(m, "%04x: %*ph\n", b->offset, (int)err, buf);
4765         }
4766
4767         return 0;
4768 }
4769 DEFINE_SHOW_ATTRIBUTE(i915_dpcd);
4770
4771 static int i915_panel_show(struct seq_file *m, void *data)
4772 {
4773         struct drm_connector *connector = m->private;
4774         struct intel_dp *intel_dp =
4775                 enc_to_intel_dp(&intel_attached_encoder(connector)->base);
4776
4777         if (connector->status != connector_status_connected)
4778                 return -ENODEV;
4779
4780         seq_printf(m, "Panel power up delay: %d\n",
4781                    intel_dp->panel_power_up_delay);
4782         seq_printf(m, "Panel power down delay: %d\n",
4783                    intel_dp->panel_power_down_delay);
4784         seq_printf(m, "Backlight on delay: %d\n",
4785                    intel_dp->backlight_on_delay);
4786         seq_printf(m, "Backlight off delay: %d\n",
4787                    intel_dp->backlight_off_delay);
4788
4789         return 0;
4790 }
4791 DEFINE_SHOW_ATTRIBUTE(i915_panel);
4792
4793 static int i915_hdcp_sink_capability_show(struct seq_file *m, void *data)
4794 {
4795         struct drm_connector *connector = m->private;
4796         struct intel_connector *intel_connector = to_intel_connector(connector);
4797
4798         if (connector->status != connector_status_connected)
4799                 return -ENODEV;
4800
4801         /* HDCP is supported by connector */
4802         if (!intel_connector->hdcp.shim)
4803                 return -EINVAL;
4804
4805         seq_printf(m, "%s:%d HDCP version: ", connector->name,
4806                    connector->base.id);
4807         seq_printf(m, "%s ", !intel_hdcp_capable(intel_connector) ?
4808                    "None" : "HDCP1.4");
4809         seq_puts(m, "\n");
4810
4811         return 0;
4812 }
4813 DEFINE_SHOW_ATTRIBUTE(i915_hdcp_sink_capability);
4814
4815 static int i915_dsc_fec_support_show(struct seq_file *m, void *data)
4816 {
4817         struct drm_connector *connector = m->private;
4818         struct drm_device *dev = connector->dev;
4819         struct drm_crtc *crtc;
4820         struct intel_dp *intel_dp;
4821         struct drm_modeset_acquire_ctx ctx;
4822         struct intel_crtc_state *crtc_state = NULL;
4823         int ret = 0;
4824         bool try_again = false;
4825
4826         drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
4827
4828         do {
4829                 try_again = false;
4830                 ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
4831                                        &ctx);
4832                 if (ret) {
4833                         ret = -EINTR;
4834                         break;
4835                 }
4836                 crtc = connector->state->crtc;
4837                 if (connector->status != connector_status_connected || !crtc) {
4838                         ret = -ENODEV;
4839                         break;
4840                 }
4841                 ret = drm_modeset_lock(&crtc->mutex, &ctx);
4842                 if (ret == -EDEADLK) {
4843                         ret = drm_modeset_backoff(&ctx);
4844                         if (!ret) {
4845                                 try_again = true;
4846                                 continue;
4847                         }
4848                         break;
4849                 } else if (ret) {
4850                         break;
4851                 }
4852                 intel_dp = enc_to_intel_dp(&intel_attached_encoder(connector)->base);
4853                 crtc_state = to_intel_crtc_state(crtc->state);
4854                 seq_printf(m, "DSC_Enabled: %s\n",
4855                            yesno(crtc_state->dsc_params.compression_enable));
4856                 seq_printf(m, "DSC_Sink_Support: %s\n",
4857                            yesno(drm_dp_sink_supports_dsc(intel_dp->dsc_dpcd)));
4858                 if (!intel_dp_is_edp(intel_dp))
4859                         seq_printf(m, "FEC_Sink_Support: %s\n",
4860                                    yesno(drm_dp_sink_supports_fec(intel_dp->fec_capable)));
4861         } while (try_again);
4862
4863         drm_modeset_drop_locks(&ctx);
4864         drm_modeset_acquire_fini(&ctx);
4865
4866         return ret;
4867 }
4868
4869 static ssize_t i915_dsc_fec_support_write(struct file *file,
4870                                           const char __user *ubuf,
4871                                           size_t len, loff_t *offp)
4872 {
4873         bool dsc_enable = false;
4874         int ret;
4875         struct drm_connector *connector =
4876                 ((struct seq_file *)file->private_data)->private;
4877         struct intel_encoder *encoder = intel_attached_encoder(connector);
4878         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
4879
4880         if (len == 0)
4881                 return 0;
4882
4883         DRM_DEBUG_DRIVER("Copied %zu bytes from user to force DSC\n",
4884                          len);
4885
4886         ret = kstrtobool_from_user(ubuf, len, &dsc_enable);
4887         if (ret < 0)
4888                 return ret;
4889
4890         DRM_DEBUG_DRIVER("Got %s for DSC Enable\n",
4891                          (dsc_enable) ? "true" : "false");
4892         intel_dp->force_dsc_en = dsc_enable;
4893
4894         *offp += len;
4895         return len;
4896 }
4897
4898 static int i915_dsc_fec_support_open(struct inode *inode,
4899                                      struct file *file)
4900 {
4901         return single_open(file, i915_dsc_fec_support_show,
4902                            inode->i_private);
4903 }
4904
4905 static const struct file_operations i915_dsc_fec_support_fops = {
4906         .owner = THIS_MODULE,
4907         .open = i915_dsc_fec_support_open,
4908         .read = seq_read,
4909         .llseek = seq_lseek,
4910         .release = single_release,
4911         .write = i915_dsc_fec_support_write
4912 };
4913
4914 /**
4915  * i915_debugfs_connector_add - add i915 specific connector debugfs files
4916  * @connector: pointer to a registered drm_connector
4917  *
4918  * Cleanup will be done by drm_connector_unregister() through a call to
4919  * drm_debugfs_connector_remove().
4920  *
4921  * Returns 0 on success, negative error codes on error.
4922  */
4923 int i915_debugfs_connector_add(struct drm_connector *connector)
4924 {
4925         struct dentry *root = connector->debugfs_entry;
4926         struct drm_i915_private *dev_priv = to_i915(connector->dev);
4927
4928         /* The connector must have been registered beforehands. */
4929         if (!root)
4930                 return -ENODEV;
4931
4932         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4933             connector->connector_type == DRM_MODE_CONNECTOR_eDP)
4934                 debugfs_create_file("i915_dpcd", S_IRUGO, root,
4935                                     connector, &i915_dpcd_fops);
4936
4937         if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
4938                 debugfs_create_file("i915_panel_timings", S_IRUGO, root,
4939                                     connector, &i915_panel_fops);
4940                 debugfs_create_file("i915_psr_sink_status", S_IRUGO, root,
4941                                     connector, &i915_psr_sink_status_fops);
4942         }
4943
4944         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4945             connector->connector_type == DRM_MODE_CONNECTOR_HDMIA ||
4946             connector->connector_type == DRM_MODE_CONNECTOR_HDMIB) {
4947                 debugfs_create_file("i915_hdcp_sink_capability", S_IRUGO, root,
4948                                     connector, &i915_hdcp_sink_capability_fops);
4949         }
4950
4951         if (INTEL_GEN(dev_priv) >= 10 &&
4952             (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4953              connector->connector_type == DRM_MODE_CONNECTOR_eDP))
4954                 debugfs_create_file("i915_dsc_fec_support", S_IRUGO, root,
4955                                     connector, &i915_dsc_fec_support_fops);
4956
4957         return 0;
4958 }