2009-02-18 08:08:50 +07:00
|
|
|
/*
|
|
|
|
* Copyright © 2008 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Eric Anholt <eric@anholt.net>
|
|
|
|
* Keith Packard <keithp@keithp.com>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/seq_file.h>
|
2013-10-16 00:55:29 +07:00
|
|
|
#include <linux/circ_buf.h>
|
2013-10-16 18:30:34 +07:00
|
|
|
#include <linux/ctype.h>
|
2009-10-14 04:20:20 +07:00
|
|
|
#include <linux/debugfs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2011-08-31 05:16:33 +07:00
|
|
|
#include <linux/export.h>
|
2013-08-08 00:30:54 +07:00
|
|
|
#include <linux/list_sort.h>
|
2013-08-20 16:29:23 +07:00
|
|
|
#include <asm/msr-index.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
2010-09-01 23:47:52 +07:00
|
|
|
#include "intel_drv.h"
|
2010-11-01 18:35:28 +07:00
|
|
|
#include "intel_ringbuffer.h"
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/i915_drm.h>
|
2009-02-18 08:08:50 +07:00
|
|
|
#include "i915_drv.h"
|
|
|
|
|
2010-09-20 23:36:15 +07:00
|
|
|
enum {
|
2010-10-19 16:36:51 +07:00
|
|
|
ACTIVE_LIST,
|
2010-09-20 23:36:15 +07:00
|
|
|
INACTIVE_LIST,
|
2010-09-26 17:19:33 +07:00
|
|
|
PINNED_LIST,
|
2010-09-20 23:36:15 +07:00
|
|
|
};
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2010-08-25 22:03:34 +07:00
|
|
|
static const char *yesno(int v)
|
|
|
|
{
|
|
|
|
return v ? "yes" : "no";
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:39 +07:00
|
|
|
/* As the drm_debugfs_init() routines are called before dev->dev_private is
|
|
|
|
* allocated we need to hook into the minor for release. */
|
|
|
|
static int
|
|
|
|
drm_add_fake_info_node(struct drm_minor *minor,
|
|
|
|
struct dentry *ent,
|
|
|
|
const void *key)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node;
|
|
|
|
|
|
|
|
node = kmalloc(sizeof(*node), GFP_KERNEL);
|
|
|
|
if (node == NULL) {
|
|
|
|
debugfs_remove(ent);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
node->minor = minor;
|
|
|
|
node->dent = ent;
|
|
|
|
node->info_ent = (void *) key;
|
|
|
|
|
|
|
|
mutex_lock(&minor->debugfs_lock);
|
|
|
|
list_add(&node->list, &minor->debugfs_list);
|
|
|
|
mutex_unlock(&minor->debugfs_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-25 22:03:34 +07:00
|
|
|
static int i915_capabilities(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-08-25 22:03:34 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
const struct intel_device_info *info = INTEL_INFO(dev);
|
|
|
|
|
|
|
|
seq_printf(m, "gen: %d\n", info->gen);
|
2011-10-15 04:17:41 +07:00
|
|
|
seq_printf(m, "pch: %d\n", INTEL_PCH_TYPE(dev));
|
2013-04-23 22:37:17 +07:00
|
|
|
#define PRINT_FLAG(x) seq_printf(m, #x ": %s\n", yesno(info->x))
|
|
|
|
#define SEP_SEMICOLON ;
|
|
|
|
DEV_INFO_FOR_EACH_FLAG(PRINT_FLAG, SEP_SEMICOLON);
|
|
|
|
#undef PRINT_FLAG
|
|
|
|
#undef SEP_SEMICOLON
|
2010-08-25 22:03:34 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2010-11-09 02:18:58 +07:00
|
|
|
static const char *get_pin_flag(struct drm_i915_gem_object *obj)
|
2009-02-11 21:26:38 +07:00
|
|
|
{
|
2014-11-24 17:21:52 +07:00
|
|
|
if (i915_gem_obj_is_pinned(obj))
|
2009-02-11 21:26:38 +07:00
|
|
|
return "p";
|
|
|
|
else
|
|
|
|
return " ";
|
|
|
|
}
|
|
|
|
|
2010-11-09 02:18:58 +07:00
|
|
|
static const char *get_tiling_flag(struct drm_i915_gem_object *obj)
|
2009-02-11 21:26:38 +07:00
|
|
|
{
|
2011-08-17 02:34:10 +07:00
|
|
|
switch (obj->tiling_mode) {
|
|
|
|
default:
|
|
|
|
case I915_TILING_NONE: return " ";
|
|
|
|
case I915_TILING_X: return "X";
|
|
|
|
case I915_TILING_Y: return "Y";
|
|
|
|
}
|
2009-02-11 21:26:38 +07:00
|
|
|
}
|
|
|
|
|
2013-08-01 07:00:00 +07:00
|
|
|
static inline const char *get_global_flag(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
2014-10-24 18:42:33 +07:00
|
|
|
return i915_gem_obj_to_ggtt(obj) ? "g" : " ";
|
2013-08-01 07:00:00 +07:00
|
|
|
}
|
|
|
|
|
2010-08-26 04:45:57 +07:00
|
|
|
static void
|
|
|
|
describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
|
|
|
|
{
|
2013-08-01 07:00:00 +07:00
|
|
|
struct i915_vma *vma;
|
2013-12-07 05:10:55 +07:00
|
|
|
int pin_count = 0;
|
|
|
|
|
2015-01-26 23:03:06 +07:00
|
|
|
seq_printf(m, "%pK: %s%s%s %8zdKiB %02x %02x %x %x %x%s%s%s",
|
2010-08-26 04:45:57 +07:00
|
|
|
&obj->base,
|
|
|
|
get_pin_flag(obj),
|
|
|
|
get_tiling_flag(obj),
|
2013-08-01 07:00:00 +07:00
|
|
|
get_global_flag(obj),
|
2011-12-20 23:54:15 +07:00
|
|
|
obj->base.size / 1024,
|
2010-08-26 04:45:57 +07:00
|
|
|
obj->base.read_domains,
|
|
|
|
obj->base.write_domain,
|
2014-11-25 01:49:26 +07:00
|
|
|
i915_gem_request_get_seqno(obj->last_read_req),
|
|
|
|
i915_gem_request_get_seqno(obj->last_write_req),
|
|
|
|
i915_gem_request_get_seqno(obj->last_fenced_req),
|
2014-08-22 20:41:39 +07:00
|
|
|
i915_cache_level_str(to_i915(obj->base.dev), obj->cache_level),
|
2010-08-26 04:45:57 +07:00
|
|
|
obj->dirty ? " dirty" : "",
|
|
|
|
obj->madv == I915_MADV_DONTNEED ? " purgeable" : "");
|
|
|
|
if (obj->base.name)
|
|
|
|
seq_printf(m, " (name: %d)", obj->base.name);
|
2015-02-25 20:17:48 +07:00
|
|
|
list_for_each_entry(vma, &obj->vma_list, vma_link) {
|
2013-12-07 05:10:55 +07:00
|
|
|
if (vma->pin_count > 0)
|
|
|
|
pin_count++;
|
2015-02-25 20:17:48 +07:00
|
|
|
}
|
|
|
|
seq_printf(m, " (pinned x %d)", pin_count);
|
2013-08-09 18:25:09 +07:00
|
|
|
if (obj->pin_display)
|
|
|
|
seq_printf(m, " (display)");
|
2010-08-26 04:45:57 +07:00
|
|
|
if (obj->fence_reg != I915_FENCE_REG_NONE)
|
|
|
|
seq_printf(m, " (fence: %d)", obj->fence_reg);
|
2013-08-01 07:00:00 +07:00
|
|
|
list_for_each_entry(vma, &obj->vma_list, vma_link) {
|
|
|
|
if (!i915_is_ggtt(vma->vm))
|
|
|
|
seq_puts(m, " (pp");
|
|
|
|
else
|
|
|
|
seq_puts(m, " (g");
|
2015-01-23 15:05:06 +07:00
|
|
|
seq_printf(m, "gtt offset: %08llx, size: %08llx, type: %u)",
|
2014-12-11 00:27:58 +07:00
|
|
|
vma->node.start, vma->node.size,
|
|
|
|
vma->ggtt_view.type);
|
2013-08-01 07:00:00 +07:00
|
|
|
}
|
2012-11-15 18:32:21 +07:00
|
|
|
if (obj->stolen)
|
2015-01-23 15:05:06 +07:00
|
|
|
seq_printf(m, " (stolen: %08llx)", obj->stolen->start);
|
2010-11-24 19:23:44 +07:00
|
|
|
if (obj->pin_mappable || obj->fault_mappable) {
|
|
|
|
char s[3], *t = s;
|
|
|
|
if (obj->pin_mappable)
|
|
|
|
*t++ = 'p';
|
|
|
|
if (obj->fault_mappable)
|
|
|
|
*t++ = 'f';
|
|
|
|
*t = '\0';
|
|
|
|
seq_printf(m, " (%s mappable)", s);
|
|
|
|
}
|
2014-11-25 01:49:43 +07:00
|
|
|
if (obj->last_read_req != NULL)
|
|
|
|
seq_printf(m, " (%s)",
|
|
|
|
i915_gem_request_get_ring(obj->last_read_req)->name);
|
2014-06-18 19:46:49 +07:00
|
|
|
if (obj->frontbuffer_bits)
|
|
|
|
seq_printf(m, " (frontbuffer: 0x%03x)", obj->frontbuffer_bits);
|
2010-08-26 04:45:57 +07:00
|
|
|
}
|
|
|
|
|
2014-05-22 20:13:37 +07:00
|
|
|
static void describe_ctx(struct seq_file *m, struct intel_context *ctx)
|
drm/i915: Do remaps for all contexts
On both Ivybridge and Haswell, row remapping information is saved and
restored with context. This means, we never actually properly supported
the l3 remapping because our sysfs interface is asynchronous (and not
tied to any context), and the known faulty HW would be reused by the
next context to run.
Not that due to the asynchronous nature of the sysfs entry, there is no
point modifying the registers for the existing context. Instead we set a
flag for all contexts to load the correct remapping information on the
next run. Interested clients can use debugfs to determine whether or not
the row has been remapped.
One could propose at this point that we just do the remapping in the
kernel. I guess since we have to maintain the sysfs interface anyway,
I'm not sure how useful it is, and I do like keeping the policy in
userspace; (it wasn't my original decision to make the
interface the way it is, so I'm not attached).
v2: Force a context switch when we have a remap on the next switch.
(Ville)
Don't let userspace use the interface with disabled contexts.
v3: Don't force a context switch, just let it nop
Improper context slice remap initialization, 1<<1 instead of 1<<i, but I
rewrote it to avoid a second round of confusion.
Error print moved to error path (All Ville)
Added a comment on why the slice remap initialization happens.
CC: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-09-19 09:03:18 +07:00
|
|
|
{
|
2014-07-03 22:27:59 +07:00
|
|
|
seq_putc(m, ctx->legacy_hw_ctx.initialized ? 'I' : 'i');
|
drm/i915: Do remaps for all contexts
On both Ivybridge and Haswell, row remapping information is saved and
restored with context. This means, we never actually properly supported
the l3 remapping because our sysfs interface is asynchronous (and not
tied to any context), and the known faulty HW would be reused by the
next context to run.
Not that due to the asynchronous nature of the sysfs entry, there is no
point modifying the registers for the existing context. Instead we set a
flag for all contexts to load the correct remapping information on the
next run. Interested clients can use debugfs to determine whether or not
the row has been remapped.
One could propose at this point that we just do the remapping in the
kernel. I guess since we have to maintain the sysfs interface anyway,
I'm not sure how useful it is, and I do like keeping the policy in
userspace; (it wasn't my original decision to make the
interface the way it is, so I'm not attached).
v2: Force a context switch when we have a remap on the next switch.
(Ville)
Don't let userspace use the interface with disabled contexts.
v3: Don't force a context switch, just let it nop
Improper context slice remap initialization, 1<<1 instead of 1<<i, but I
rewrote it to avoid a second round of confusion.
Error print moved to error path (All Ville)
Added a comment on why the slice remap initialization happens.
CC: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-09-19 09:03:18 +07:00
|
|
|
seq_putc(m, ctx->remap_slice ? 'R' : 'r');
|
|
|
|
seq_putc(m, ' ');
|
|
|
|
}
|
|
|
|
|
2009-02-18 08:08:51 +07:00
|
|
|
static int i915_gem_object_list_info(struct seq_file *m, void *data)
|
2009-02-18 08:08:50 +07:00
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-18 08:08:51 +07:00
|
|
|
uintptr_t list = (uintptr_t) node->info_ent->data;
|
|
|
|
struct list_head *head;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2013-07-17 06:50:08 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct i915_address_space *vm = &dev_priv->gtt.base;
|
2013-08-01 07:00:14 +07:00
|
|
|
struct i915_vma *vma;
|
2010-09-26 17:44:19 +07:00
|
|
|
size_t total_obj_size, total_gtt_size;
|
|
|
|
int count, ret;
|
2010-07-03 13:58:38 +07:00
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2013-08-01 07:00:14 +07:00
|
|
|
/* FIXME: the user of this interface might want more than just GGTT */
|
2009-02-18 08:08:51 +07:00
|
|
|
switch (list) {
|
|
|
|
case ACTIVE_LIST:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Active:\n");
|
2013-07-17 06:50:08 +07:00
|
|
|
head = &vm->active_list;
|
2009-02-18 08:08:51 +07:00
|
|
|
break;
|
|
|
|
case INACTIVE_LIST:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Inactive:\n");
|
2013-07-17 06:50:08 +07:00
|
|
|
head = &vm->inactive_list;
|
2009-02-18 08:08:51 +07:00
|
|
|
break;
|
|
|
|
default:
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return -EINVAL;
|
2009-02-18 08:08:50 +07:00
|
|
|
}
|
|
|
|
|
2010-09-26 17:44:19 +07:00
|
|
|
total_obj_size = total_gtt_size = count = 0;
|
2013-08-01 07:00:14 +07:00
|
|
|
list_for_each_entry(vma, head, mm_list) {
|
|
|
|
seq_printf(m, " ");
|
|
|
|
describe_obj(m, vma->obj);
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
total_obj_size += vma->obj->base.size;
|
|
|
|
total_gtt_size += vma->node.size;
|
2010-09-26 17:44:19 +07:00
|
|
|
count++;
|
2009-02-18 08:08:50 +07:00
|
|
|
}
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2009-03-21 01:54:25 +07:00
|
|
|
|
2010-09-26 17:44:19 +07:00
|
|
|
seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
|
|
|
|
count, total_obj_size, total_gtt_size);
|
2009-02-18 08:08:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-08 00:30:54 +07:00
|
|
|
static int obj_rank_by_stolen(void *priv,
|
|
|
|
struct list_head *A, struct list_head *B)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_object *a =
|
2013-08-14 16:38:33 +07:00
|
|
|
container_of(A, struct drm_i915_gem_object, obj_exec_link);
|
2013-08-08 00:30:54 +07:00
|
|
|
struct drm_i915_gem_object *b =
|
2013-08-14 16:38:33 +07:00
|
|
|
container_of(B, struct drm_i915_gem_object, obj_exec_link);
|
2013-08-08 00:30:54 +07:00
|
|
|
|
|
|
|
return a->stolen->start - b->stolen->start;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_gem_stolen_list_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-08-08 00:30:54 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
size_t total_obj_size, total_gtt_size;
|
|
|
|
LIST_HEAD(stolen);
|
|
|
|
int count, ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
total_obj_size = total_gtt_size = count = 0;
|
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) {
|
|
|
|
if (obj->stolen == NULL)
|
|
|
|
continue;
|
|
|
|
|
2013-08-14 16:38:33 +07:00
|
|
|
list_add(&obj->obj_exec_link, &stolen);
|
2013-08-08 00:30:54 +07:00
|
|
|
|
|
|
|
total_obj_size += obj->base.size;
|
|
|
|
total_gtt_size += i915_gem_obj_ggtt_size(obj);
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
list_for_each_entry(obj, &dev_priv->mm.unbound_list, global_list) {
|
|
|
|
if (obj->stolen == NULL)
|
|
|
|
continue;
|
|
|
|
|
2013-08-14 16:38:33 +07:00
|
|
|
list_add(&obj->obj_exec_link, &stolen);
|
2013-08-08 00:30:54 +07:00
|
|
|
|
|
|
|
total_obj_size += obj->base.size;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
list_sort(NULL, &stolen, obj_rank_by_stolen);
|
|
|
|
seq_puts(m, "Stolen:\n");
|
|
|
|
while (!list_empty(&stolen)) {
|
2013-08-14 16:38:33 +07:00
|
|
|
obj = list_first_entry(&stolen, typeof(*obj), obj_exec_link);
|
2013-08-08 00:30:54 +07:00
|
|
|
seq_puts(m, " ");
|
|
|
|
describe_obj(m, obj);
|
|
|
|
seq_putc(m, '\n');
|
2013-08-14 16:38:33 +07:00
|
|
|
list_del_init(&obj->obj_exec_link);
|
2013-08-08 00:30:54 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
|
|
|
|
count, total_obj_size, total_gtt_size);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-24 19:23:44 +07:00
|
|
|
#define count_objects(list, member) do { \
|
|
|
|
list_for_each_entry(obj, list, member) { \
|
2013-07-06 04:41:04 +07:00
|
|
|
size += i915_gem_obj_ggtt_size(obj); \
|
2010-11-24 19:23:44 +07:00
|
|
|
++count; \
|
|
|
|
if (obj->map_and_fenceable) { \
|
2013-07-06 04:41:04 +07:00
|
|
|
mappable_size += i915_gem_obj_ggtt_size(obj); \
|
2010-11-24 19:23:44 +07:00
|
|
|
++mappable_count; \
|
|
|
|
} \
|
|
|
|
} \
|
2011-08-17 02:34:10 +07:00
|
|
|
} while (0)
|
2010-11-24 19:23:44 +07:00
|
|
|
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
struct file_stats {
|
2014-03-19 20:45:45 +07:00
|
|
|
struct drm_i915_file_private *file_priv;
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
int count;
|
2014-03-19 20:45:46 +07:00
|
|
|
size_t total, unbound;
|
|
|
|
size_t global, shared;
|
|
|
|
size_t active, inactive;
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int per_file_stats(int id, void *ptr, void *data)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_object *obj = ptr;
|
|
|
|
struct file_stats *stats = data;
|
2014-03-19 20:45:45 +07:00
|
|
|
struct i915_vma *vma;
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
|
|
|
|
stats->count++;
|
|
|
|
stats->total += obj->base.size;
|
|
|
|
|
2014-03-19 20:45:46 +07:00
|
|
|
if (obj->base.name || obj->base.dma_buf)
|
|
|
|
stats->shared += obj->base.size;
|
|
|
|
|
2014-03-19 20:45:45 +07:00
|
|
|
if (USES_FULL_PPGTT(obj->base.dev)) {
|
|
|
|
list_for_each_entry(vma, &obj->vma_list, vma_link) {
|
|
|
|
struct i915_hw_ppgtt *ppgtt;
|
|
|
|
|
|
|
|
if (!drm_mm_node_allocated(&vma->node))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (i915_is_ggtt(vma->vm)) {
|
|
|
|
stats->global += obj->base.size;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ppgtt = container_of(vma->vm, struct i915_hw_ppgtt, base);
|
2014-08-06 20:04:47 +07:00
|
|
|
if (ppgtt->file_priv != stats->file_priv)
|
2014-03-19 20:45:45 +07:00
|
|
|
continue;
|
|
|
|
|
2014-11-25 01:49:43 +07:00
|
|
|
if (obj->active) /* XXX per-vma statistic */
|
2014-03-19 20:45:45 +07:00
|
|
|
stats->active += obj->base.size;
|
|
|
|
else
|
|
|
|
stats->inactive += obj->base.size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
} else {
|
2014-03-19 20:45:45 +07:00
|
|
|
if (i915_gem_obj_ggtt_bound(obj)) {
|
|
|
|
stats->global += obj->base.size;
|
2014-11-25 01:49:43 +07:00
|
|
|
if (obj->active)
|
2014-03-19 20:45:45 +07:00
|
|
|
stats->active += obj->base.size;
|
|
|
|
else
|
|
|
|
stats->inactive += obj->base.size;
|
|
|
|
return 0;
|
|
|
|
}
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
}
|
|
|
|
|
2014-03-19 20:45:45 +07:00
|
|
|
if (!list_empty(&obj->global_list))
|
|
|
|
stats->unbound += obj->base.size;
|
|
|
|
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 03:13:08 +07:00
|
|
|
#define print_file_stats(m, name, stats) \
|
|
|
|
seq_printf(m, "%s: %u objects, %zu bytes (%zu active, %zu inactive, %zu global, %zu shared, %zu unbound)\n", \
|
|
|
|
name, \
|
|
|
|
stats.count, \
|
|
|
|
stats.total, \
|
|
|
|
stats.active, \
|
|
|
|
stats.inactive, \
|
|
|
|
stats.global, \
|
|
|
|
stats.shared, \
|
|
|
|
stats.unbound)
|
|
|
|
|
|
|
|
static void print_batch_pool_stats(struct seq_file *m,
|
|
|
|
struct drm_i915_private *dev_priv)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
struct file_stats stats;
|
|
|
|
|
|
|
|
memset(&stats, 0, sizeof(stats));
|
|
|
|
|
|
|
|
list_for_each_entry(obj,
|
|
|
|
&dev_priv->mm.batch_pool.cache_list,
|
|
|
|
batch_pool_list)
|
|
|
|
per_file_stats(0, obj, &stats);
|
|
|
|
|
|
|
|
print_file_stats(m, "batch pool", stats);
|
|
|
|
}
|
|
|
|
|
2013-08-01 07:00:14 +07:00
|
|
|
#define count_vmas(list, member) do { \
|
|
|
|
list_for_each_entry(vma, list, member) { \
|
|
|
|
size += i915_gem_obj_ggtt_size(vma->obj); \
|
|
|
|
++count; \
|
|
|
|
if (vma->obj->map_and_fenceable) { \
|
|
|
|
mappable_size += i915_gem_obj_ggtt_size(vma->obj); \
|
|
|
|
++mappable_count; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static int i915_gem_object_info(struct seq_file *m, void* data)
|
2010-09-30 17:46:12 +07:00
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-09-30 17:46:12 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-08-20 16:33:30 +07:00
|
|
|
u32 count, mappable_count, purgeable_count;
|
|
|
|
size_t size, mappable_size, purgeable_size;
|
2010-11-24 19:23:44 +07:00
|
|
|
struct drm_i915_gem_object *obj;
|
2013-07-17 06:50:08 +07:00
|
|
|
struct i915_address_space *vm = &dev_priv->gtt.base;
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
struct drm_file *file;
|
2013-08-01 07:00:14 +07:00
|
|
|
struct i915_vma *vma;
|
2010-09-30 17:46:12 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2010-11-24 19:23:44 +07:00
|
|
|
seq_printf(m, "%u objects, %zu bytes\n",
|
|
|
|
dev_priv->mm.object_count,
|
|
|
|
dev_priv->mm.object_memory);
|
|
|
|
|
|
|
|
size = count = mappable_size = mappable_count = 0;
|
2013-06-01 01:28:48 +07:00
|
|
|
count_objects(&dev_priv->mm.bound_list, global_list);
|
2010-11-24 19:23:44 +07:00
|
|
|
seq_printf(m, "%u [%u] objects, %zu [%zu] bytes in gtt\n",
|
|
|
|
count, mappable_count, size, mappable_size);
|
|
|
|
|
|
|
|
size = count = mappable_size = mappable_count = 0;
|
2013-08-01 07:00:14 +07:00
|
|
|
count_vmas(&vm->active_list, mm_list);
|
2010-11-24 19:23:44 +07:00
|
|
|
seq_printf(m, " %u [%u] active objects, %zu [%zu] bytes\n",
|
|
|
|
count, mappable_count, size, mappable_size);
|
|
|
|
|
|
|
|
size = count = mappable_size = mappable_count = 0;
|
2013-08-01 07:00:14 +07:00
|
|
|
count_vmas(&vm->inactive_list, mm_list);
|
2010-11-24 19:23:44 +07:00
|
|
|
seq_printf(m, " %u [%u] inactive objects, %zu [%zu] bytes\n",
|
|
|
|
count, mappable_count, size, mappable_size);
|
|
|
|
|
2012-08-20 16:33:30 +07:00
|
|
|
size = count = purgeable_size = purgeable_count = 0;
|
2013-06-01 01:28:48 +07:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.unbound_list, global_list) {
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 16:40:46 +07:00
|
|
|
size += obj->base.size, ++count;
|
2012-08-20 16:33:30 +07:00
|
|
|
if (obj->madv == I915_MADV_DONTNEED)
|
|
|
|
purgeable_size += obj->base.size, ++purgeable_count;
|
|
|
|
}
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 16:40:46 +07:00
|
|
|
seq_printf(m, "%u unbound objects, %zu bytes\n", count, size);
|
|
|
|
|
2010-11-24 19:23:44 +07:00
|
|
|
size = count = mappable_size = mappable_count = 0;
|
2013-06-01 01:28:48 +07:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) {
|
2010-11-24 19:23:44 +07:00
|
|
|
if (obj->fault_mappable) {
|
2013-07-06 04:41:04 +07:00
|
|
|
size += i915_gem_obj_ggtt_size(obj);
|
2010-11-24 19:23:44 +07:00
|
|
|
++count;
|
|
|
|
}
|
|
|
|
if (obj->pin_mappable) {
|
2013-07-06 04:41:04 +07:00
|
|
|
mappable_size += i915_gem_obj_ggtt_size(obj);
|
2010-11-24 19:23:44 +07:00
|
|
|
++mappable_count;
|
|
|
|
}
|
2012-08-20 16:33:30 +07:00
|
|
|
if (obj->madv == I915_MADV_DONTNEED) {
|
|
|
|
purgeable_size += obj->base.size;
|
|
|
|
++purgeable_count;
|
|
|
|
}
|
2010-11-24 19:23:44 +07:00
|
|
|
}
|
2012-08-20 16:33:30 +07:00
|
|
|
seq_printf(m, "%u purgeable objects, %zu bytes\n",
|
|
|
|
purgeable_count, purgeable_size);
|
2010-11-24 19:23:44 +07:00
|
|
|
seq_printf(m, "%u pinned mappable objects, %zu bytes\n",
|
|
|
|
mappable_count, mappable_size);
|
|
|
|
seq_printf(m, "%u fault mappable objects, %zu bytes\n",
|
|
|
|
count, size);
|
|
|
|
|
2013-01-18 03:45:17 +07:00
|
|
|
seq_printf(m, "%zu [%lu] gtt total\n",
|
2013-07-17 06:50:05 +07:00
|
|
|
dev_priv->gtt.base.total,
|
|
|
|
dev_priv->gtt.mappable_end - dev_priv->gtt.base.start);
|
2010-09-30 17:46:12 +07:00
|
|
|
|
2014-12-12 03:13:08 +07:00
|
|
|
seq_putc(m, '\n');
|
|
|
|
print_batch_pool_stats(m, dev_priv);
|
|
|
|
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
list_for_each_entry_reverse(file, &dev->filelist, lhead) {
|
|
|
|
struct file_stats stats;
|
2014-01-03 18:42:18 +07:00
|
|
|
struct task_struct *task;
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
|
|
|
|
memset(&stats, 0, sizeof(stats));
|
2014-03-19 20:45:45 +07:00
|
|
|
stats.file_priv = file->driver_priv;
|
2014-06-17 15:56:24 +07:00
|
|
|
spin_lock(&file->table_lock);
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
idr_for_each(&file->object_idr, per_file_stats, &stats);
|
2014-06-17 15:56:24 +07:00
|
|
|
spin_unlock(&file->table_lock);
|
2014-01-03 18:42:18 +07:00
|
|
|
/*
|
|
|
|
* Although we have a valid reference on file->pid, that does
|
|
|
|
* not guarantee that the task_struct who called get_pid() is
|
|
|
|
* still alive (e.g. get_pid(current) => fork() => exit()).
|
|
|
|
* Therefore, we need to protect this ->comm access using RCU.
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
|
|
|
task = pid_task(file->pid, PIDTYPE_PID);
|
2014-12-12 03:13:08 +07:00
|
|
|
print_file_stats(m, task ? task->comm : "<unknown>", stats);
|
2014-01-03 18:42:18 +07:00
|
|
|
rcu_read_unlock();
|
drm/i915: Track clients and print their object usage in debugfs
By stashing a pointer of who opened the device and keeping a list of
open fd, we can then walk each client and inspect how many objects they
have open. For example,
i915_gem_objects:
1102 objects, 613646336 bytes
663 [662] objects, 468783104 [468750336] bytes in gtt
37 [37] active objects, 46874624 [46874624] bytes
626 [625] inactive objects, 421908480 [421875712] bytes
282 unbound objects, 6512640 bytes
85 purgeable objects, 6787072 bytes
28 pinned mappable objects, 3686400 bytes
40 fault mappable objects, 27783168 bytes
2145386496 [536870912] gtt total
Xorg: 43 objects, 32243712 bytes (10223616 active, 16683008 inactive, 4096 unbound)
gnome-shell: 30 objects, 28381184 bytes (0 active, 28336128 inactive, 0 unbound)
xonotic-linux64: 1032 objects, 569933824 bytes (46874624 active, 383545344 inactive, 6508544 unbound)
v2: Use existing drm->filelist as pointed out by Ben.
v3: Not even stashing the task_struct is required as Ben pointed out
drm_file->pid.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Ben Widawsky <ben@bwidawsk.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-06-05 05:49:08 +07:00
|
|
|
}
|
|
|
|
|
2010-09-30 17:46:12 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-25 04:59:49 +07:00
|
|
|
static int i915_gem_gtt_info(struct seq_file *m, void *data)
|
2011-01-10 07:00:24 +07:00
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-01-10 07:00:24 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2012-04-24 21:47:30 +07:00
|
|
|
uintptr_t list = (uintptr_t) node->info_ent->data;
|
2011-01-10 07:00:24 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
size_t total_obj_size, total_gtt_size;
|
|
|
|
int count, ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
total_obj_size = total_gtt_size = count = 0;
|
2013-06-01 01:28:48 +07:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) {
|
2013-12-07 05:10:55 +07:00
|
|
|
if (list == PINNED_LIST && !i915_gem_obj_is_pinned(obj))
|
2012-04-24 21:47:30 +07:00
|
|
|
continue;
|
|
|
|
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, " ");
|
2011-01-10 07:00:24 +07:00
|
|
|
describe_obj(m, obj);
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
2011-01-10 07:00:24 +07:00
|
|
|
total_obj_size += obj->base.size;
|
2013-07-06 04:41:04 +07:00
|
|
|
total_gtt_size += i915_gem_obj_ggtt_size(obj);
|
2011-01-10 07:00:24 +07:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
|
|
|
|
count, total_obj_size, total_gtt_size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-01 23:47:52 +07:00
|
|
|
static int i915_gem_pageflip_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-09-01 23:47:52 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-09-01 23:47:52 +07:00
|
|
|
struct intel_crtc *crtc;
|
2014-06-18 03:34:37 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-09-01 23:47:52 +07:00
|
|
|
|
2014-05-14 05:32:22 +07:00
|
|
|
for_each_intel_crtc(dev, crtc) {
|
2011-02-08 03:26:52 +07:00
|
|
|
const char pipe = pipe_name(crtc->pipe);
|
|
|
|
const char plane = plane_name(crtc->plane);
|
2010-09-01 23:47:52 +07:00
|
|
|
struct intel_unpin_work *work;
|
|
|
|
|
2014-09-15 19:55:22 +07:00
|
|
|
spin_lock_irq(&dev->event_lock);
|
2010-09-01 23:47:52 +07:00
|
|
|
work = crtc->unpin_work;
|
|
|
|
if (work == NULL) {
|
2011-02-08 03:26:52 +07:00
|
|
|
seq_printf(m, "No flip due on pipe %c (plane %c)\n",
|
2010-09-01 23:47:52 +07:00
|
|
|
pipe, plane);
|
|
|
|
} else {
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
u32 addr;
|
|
|
|
|
2012-12-03 18:36:30 +07:00
|
|
|
if (atomic_read(&work->pending) < INTEL_FLIP_COMPLETE) {
|
2011-02-08 03:26:52 +07:00
|
|
|
seq_printf(m, "Flip queued on pipe %c (plane %c)\n",
|
2010-09-01 23:47:52 +07:00
|
|
|
pipe, plane);
|
|
|
|
} else {
|
2011-02-08 03:26:52 +07:00
|
|
|
seq_printf(m, "Flip pending (waiting for vsync) on pipe %c (plane %c)\n",
|
2010-09-01 23:47:52 +07:00
|
|
|
pipe, plane);
|
|
|
|
}
|
2014-11-26 20:39:48 +07:00
|
|
|
if (work->flip_queued_req) {
|
|
|
|
struct intel_engine_cs *ring =
|
|
|
|
i915_gem_request_get_ring(work->flip_queued_req);
|
|
|
|
|
2015-01-26 23:03:06 +07:00
|
|
|
seq_printf(m, "Flip queued on %s at seqno %x, next seqno %x [current breadcrumb %x], completed? %d\n",
|
2014-11-26 20:39:48 +07:00
|
|
|
ring->name,
|
2014-11-25 01:49:37 +07:00
|
|
|
i915_gem_request_get_seqno(work->flip_queued_req),
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
dev_priv->next_seqno,
|
2014-11-26 20:39:48 +07:00
|
|
|
ring->get_seqno(ring, true),
|
2014-11-25 01:49:42 +07:00
|
|
|
i915_gem_request_completed(work->flip_queued_req, true));
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
} else
|
|
|
|
seq_printf(m, "Flip not associated with any ring\n");
|
|
|
|
seq_printf(m, "Flip queued on frame %d, (was ready on frame %d), now %d\n",
|
|
|
|
work->flip_queued_vblank,
|
|
|
|
work->flip_ready_vblank,
|
2015-02-14 03:03:45 +07:00
|
|
|
drm_crtc_vblank_count(&crtc->base));
|
2010-09-01 23:47:52 +07:00
|
|
|
if (work->enable_stall_check)
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Stall check enabled, ");
|
2010-09-01 23:47:52 +07:00
|
|
|
else
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Stall check waiting for page flip ioctl, ");
|
2012-12-03 18:36:30 +07:00
|
|
|
seq_printf(m, "%d prepares\n", atomic_read(&work->pending));
|
2010-09-01 23:47:52 +07:00
|
|
|
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
if (INTEL_INFO(dev)->gen >= 4)
|
|
|
|
addr = I915_HI_DISPBASE(I915_READ(DSPSURF(crtc->plane)));
|
|
|
|
else
|
|
|
|
addr = I915_READ(DSPADDR(crtc->plane));
|
|
|
|
seq_printf(m, "Current scanout address 0x%08x\n", addr);
|
|
|
|
|
2010-09-01 23:47:52 +07:00
|
|
|
if (work->pending_flip_obj) {
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
seq_printf(m, "New framebuffer address 0x%08lx\n", (long)work->gtt_offset);
|
|
|
|
seq_printf(m, "MMIO update completed? %d\n", addr == work->gtt_offset);
|
2010-09-01 23:47:52 +07:00
|
|
|
}
|
|
|
|
}
|
2014-09-15 19:55:22 +07:00
|
|
|
spin_unlock_irq(&dev->event_lock);
|
2010-09-01 23:47:52 +07:00
|
|
|
}
|
|
|
|
|
2014-06-18 03:34:37 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2010-09-01 23:47:52 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 03:13:08 +07:00
|
|
|
static int i915_gem_batch_pool_info(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
int count = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
seq_puts(m, "cache:\n");
|
|
|
|
list_for_each_entry(obj,
|
|
|
|
&dev_priv->mm.batch_pool.cache_list,
|
|
|
|
batch_pool_list) {
|
|
|
|
seq_puts(m, " ");
|
|
|
|
describe_obj(m, obj);
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "total: %d\n", count);
|
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
static int i915_gem_request_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_i915_gem_request *gem_request;
|
2012-09-02 02:51:22 +07:00
|
|
|
int ret, count, i;
|
2010-07-03 13:58:38 +07:00
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2010-10-27 21:11:53 +07:00
|
|
|
count = 0;
|
2012-09-02 02:51:22 +07:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
if (list_empty(&ring->request_list))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
seq_printf(m, "%s requests:\n", ring->name);
|
2010-10-27 21:11:53 +07:00
|
|
|
list_for_each_entry(gem_request,
|
2012-09-02 02:51:22 +07:00
|
|
|
&ring->request_list,
|
2010-10-27 21:11:53 +07:00
|
|
|
list) {
|
2015-01-26 23:03:06 +07:00
|
|
|
seq_printf(m, " %x @ %d\n",
|
2010-10-27 21:11:53 +07:00
|
|
|
gem_request->seqno,
|
|
|
|
(int) (jiffies - gem_request->emitted_jiffies));
|
|
|
|
}
|
|
|
|
count++;
|
2009-02-18 08:08:50 +07:00
|
|
|
}
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2010-10-27 21:11:53 +07:00
|
|
|
if (count == 0)
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "No requests\n");
|
2010-10-27 21:11:53 +07:00
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-27 21:27:33 +07:00
|
|
|
static void i915_ring_seqno_info(struct seq_file *m,
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring)
|
2010-10-27 21:27:33 +07:00
|
|
|
{
|
|
|
|
if (ring->get_seqno) {
|
2015-01-26 23:03:06 +07:00
|
|
|
seq_printf(m, "Current sequence (%s): %x\n",
|
2012-08-09 16:58:30 +07:00
|
|
|
ring->name, ring->get_seqno(ring, false));
|
2010-10-27 21:27:33 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
static int i915_gem_seqno_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2010-12-04 18:30:53 +07:00
|
|
|
int ret, i;
|
2010-07-03 13:58:38 +07:00
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2012-09-02 02:51:22 +07:00
|
|
|
for_each_ring(ring, dev_priv, i)
|
|
|
|
i915_ring_seqno_info(m, ring);
|
2010-07-03 13:58:38 +07:00
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int i915_interrupt_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2011-02-08 03:26:52 +07:00
|
|
|
int ret, i, pipe;
|
2010-07-03 13:58:38 +07:00
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2014-04-09 17:28:09 +07:00
|
|
|
if (IS_CHERRYVIEW(dev)) {
|
|
|
|
seq_printf(m, "Master Interrupt Control:\t%08x\n",
|
|
|
|
I915_READ(GEN8_MASTER_IRQ));
|
|
|
|
|
|
|
|
seq_printf(m, "Display IER:\t%08x\n",
|
|
|
|
I915_READ(VLV_IER));
|
|
|
|
seq_printf(m, "Display IIR:\t%08x\n",
|
|
|
|
I915_READ(VLV_IIR));
|
|
|
|
seq_printf(m, "Display IIR_RW:\t%08x\n",
|
|
|
|
I915_READ(VLV_IIR_RW));
|
|
|
|
seq_printf(m, "Display IMR:\t%08x\n",
|
|
|
|
I915_READ(VLV_IMR));
|
2014-08-18 19:49:10 +07:00
|
|
|
for_each_pipe(dev_priv, pipe)
|
2014-04-09 17:28:09 +07:00
|
|
|
seq_printf(m, "Pipe %c stat:\t%08x\n",
|
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(PIPESTAT(pipe)));
|
|
|
|
|
|
|
|
seq_printf(m, "Port hotplug:\t%08x\n",
|
|
|
|
I915_READ(PORT_HOTPLUG_EN));
|
|
|
|
seq_printf(m, "DPFLIPSTAT:\t%08x\n",
|
|
|
|
I915_READ(VLV_DPFLIPSTAT));
|
|
|
|
seq_printf(m, "DPINVGTT:\t%08x\n",
|
|
|
|
I915_READ(DPINVGTT));
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IMR(i)));
|
|
|
|
seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IIR(i)));
|
|
|
|
seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IER(i)));
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "PCU interrupt mask:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IMR));
|
|
|
|
seq_printf(m, "PCU interrupt identity:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IIR));
|
|
|
|
seq_printf(m, "PCU interrupt enable:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IER));
|
|
|
|
} else if (INTEL_INFO(dev)->gen >= 8) {
|
2013-11-03 11:07:10 +07:00
|
|
|
seq_printf(m, "Master Interrupt Control:\t%08x\n",
|
|
|
|
I915_READ(GEN8_MASTER_IRQ));
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IMR(i)));
|
|
|
|
seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IIR(i)));
|
|
|
|
seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
|
|
|
|
i, I915_READ(GEN8_GT_IER(i)));
|
|
|
|
}
|
|
|
|
|
2014-08-18 19:49:10 +07:00
|
|
|
for_each_pipe(dev_priv, pipe) {
|
2014-09-30 15:56:39 +07:00
|
|
|
if (!intel_display_power_is_enabled(dev_priv,
|
2014-08-09 03:45:32 +07:00
|
|
|
POWER_DOMAIN_PIPE(pipe))) {
|
|
|
|
seq_printf(m, "Pipe %c power disabled\n",
|
|
|
|
pipe_name(pipe));
|
|
|
|
continue;
|
|
|
|
}
|
2013-11-03 11:07:10 +07:00
|
|
|
seq_printf(m, "Pipe %c IMR:\t%08x\n",
|
2014-03-04 00:31:46 +07:00
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(GEN8_DE_PIPE_IMR(pipe)));
|
2013-11-03 11:07:10 +07:00
|
|
|
seq_printf(m, "Pipe %c IIR:\t%08x\n",
|
2014-03-04 00:31:46 +07:00
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(GEN8_DE_PIPE_IIR(pipe)));
|
2013-11-03 11:07:10 +07:00
|
|
|
seq_printf(m, "Pipe %c IER:\t%08x\n",
|
2014-03-04 00:31:46 +07:00
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(GEN8_DE_PIPE_IER(pipe)));
|
2013-11-03 11:07:10 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "Display Engine port interrupt mask:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_PORT_IMR));
|
|
|
|
seq_printf(m, "Display Engine port interrupt identity:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_PORT_IIR));
|
|
|
|
seq_printf(m, "Display Engine port interrupt enable:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_PORT_IER));
|
|
|
|
|
|
|
|
seq_printf(m, "Display Engine misc interrupt mask:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_MISC_IMR));
|
|
|
|
seq_printf(m, "Display Engine misc interrupt identity:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_MISC_IIR));
|
|
|
|
seq_printf(m, "Display Engine misc interrupt enable:\t%08x\n",
|
|
|
|
I915_READ(GEN8_DE_MISC_IER));
|
|
|
|
|
|
|
|
seq_printf(m, "PCU interrupt mask:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IMR));
|
|
|
|
seq_printf(m, "PCU interrupt identity:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IIR));
|
|
|
|
seq_printf(m, "PCU interrupt enable:\t%08x\n",
|
|
|
|
I915_READ(GEN8_PCU_IER));
|
|
|
|
} else if (IS_VALLEYVIEW(dev)) {
|
2012-03-29 03:39:38 +07:00
|
|
|
seq_printf(m, "Display IER:\t%08x\n",
|
|
|
|
I915_READ(VLV_IER));
|
|
|
|
seq_printf(m, "Display IIR:\t%08x\n",
|
|
|
|
I915_READ(VLV_IIR));
|
|
|
|
seq_printf(m, "Display IIR_RW:\t%08x\n",
|
|
|
|
I915_READ(VLV_IIR_RW));
|
|
|
|
seq_printf(m, "Display IMR:\t%08x\n",
|
|
|
|
I915_READ(VLV_IMR));
|
2014-08-18 19:49:10 +07:00
|
|
|
for_each_pipe(dev_priv, pipe)
|
2012-03-29 03:39:38 +07:00
|
|
|
seq_printf(m, "Pipe %c stat:\t%08x\n",
|
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(PIPESTAT(pipe)));
|
|
|
|
|
|
|
|
seq_printf(m, "Master IER:\t%08x\n",
|
|
|
|
I915_READ(VLV_MASTER_IER));
|
|
|
|
|
|
|
|
seq_printf(m, "Render IER:\t%08x\n",
|
|
|
|
I915_READ(GTIER));
|
|
|
|
seq_printf(m, "Render IIR:\t%08x\n",
|
|
|
|
I915_READ(GTIIR));
|
|
|
|
seq_printf(m, "Render IMR:\t%08x\n",
|
|
|
|
I915_READ(GTIMR));
|
|
|
|
|
|
|
|
seq_printf(m, "PM IER:\t\t%08x\n",
|
|
|
|
I915_READ(GEN6_PMIER));
|
|
|
|
seq_printf(m, "PM IIR:\t\t%08x\n",
|
|
|
|
I915_READ(GEN6_PMIIR));
|
|
|
|
seq_printf(m, "PM IMR:\t\t%08x\n",
|
|
|
|
I915_READ(GEN6_PMIMR));
|
|
|
|
|
|
|
|
seq_printf(m, "Port hotplug:\t%08x\n",
|
|
|
|
I915_READ(PORT_HOTPLUG_EN));
|
|
|
|
seq_printf(m, "DPFLIPSTAT:\t%08x\n",
|
|
|
|
I915_READ(VLV_DPFLIPSTAT));
|
|
|
|
seq_printf(m, "DPINVGTT:\t%08x\n",
|
|
|
|
I915_READ(DPINVGTT));
|
|
|
|
|
|
|
|
} else if (!HAS_PCH_SPLIT(dev)) {
|
2009-08-10 20:37:24 +07:00
|
|
|
seq_printf(m, "Interrupt enable: %08x\n",
|
|
|
|
I915_READ(IER));
|
|
|
|
seq_printf(m, "Interrupt identity: %08x\n",
|
|
|
|
I915_READ(IIR));
|
|
|
|
seq_printf(m, "Interrupt mask: %08x\n",
|
|
|
|
I915_READ(IMR));
|
2014-08-18 19:49:10 +07:00
|
|
|
for_each_pipe(dev_priv, pipe)
|
2011-02-08 03:26:52 +07:00
|
|
|
seq_printf(m, "Pipe %c stat: %08x\n",
|
|
|
|
pipe_name(pipe),
|
|
|
|
I915_READ(PIPESTAT(pipe)));
|
2009-08-10 20:37:24 +07:00
|
|
|
} else {
|
|
|
|
seq_printf(m, "North Display Interrupt enable: %08x\n",
|
|
|
|
I915_READ(DEIER));
|
|
|
|
seq_printf(m, "North Display Interrupt identity: %08x\n",
|
|
|
|
I915_READ(DEIIR));
|
|
|
|
seq_printf(m, "North Display Interrupt mask: %08x\n",
|
|
|
|
I915_READ(DEIMR));
|
|
|
|
seq_printf(m, "South Display Interrupt enable: %08x\n",
|
|
|
|
I915_READ(SDEIER));
|
|
|
|
seq_printf(m, "South Display Interrupt identity: %08x\n",
|
|
|
|
I915_READ(SDEIIR));
|
|
|
|
seq_printf(m, "South Display Interrupt mask: %08x\n",
|
|
|
|
I915_READ(SDEIMR));
|
|
|
|
seq_printf(m, "Graphics Interrupt enable: %08x\n",
|
|
|
|
I915_READ(GTIER));
|
|
|
|
seq_printf(m, "Graphics Interrupt identity: %08x\n",
|
|
|
|
I915_READ(GTIIR));
|
|
|
|
seq_printf(m, "Graphics Interrupt mask: %08x\n",
|
|
|
|
I915_READ(GTIMR));
|
|
|
|
}
|
2012-09-02 02:51:22 +07:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2013-11-03 11:07:10 +07:00
|
|
|
if (INTEL_INFO(dev)->gen >= 6) {
|
2012-09-02 02:51:22 +07:00
|
|
|
seq_printf(m,
|
|
|
|
"Graphics Interrupt mask (%s): %08x\n",
|
|
|
|
ring->name, I915_READ_IMR(ring));
|
2011-01-05 05:22:17 +07:00
|
|
|
}
|
2012-09-02 02:51:22 +07:00
|
|
|
i915_ring_seqno_info(m, ring);
|
2011-01-05 05:22:17 +07:00
|
|
|
}
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-11 21:26:38 +07:00
|
|
|
static int i915_gem_fence_regs_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-11 21:26:38 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-07-03 13:58:38 +07:00
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-02-11 21:26:38 +07:00
|
|
|
|
|
|
|
seq_printf(m, "Reserved fences = %d\n", dev_priv->fence_reg_start);
|
|
|
|
seq_printf(m, "Total fences = %d\n", dev_priv->num_fence_regs);
|
|
|
|
for (i = 0; i < dev_priv->num_fence_regs; i++) {
|
2010-11-09 02:18:58 +07:00
|
|
|
struct drm_i915_gem_object *obj = dev_priv->fence_regs[i].obj;
|
2009-02-11 21:26:38 +07:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 16:40:46 +07:00
|
|
|
seq_printf(m, "Fence %d, pin count = %d, object = ",
|
|
|
|
i, dev_priv->fence_regs[i].pin_count);
|
2010-10-27 21:11:53 +07:00
|
|
|
if (obj == NULL)
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "unused");
|
2010-10-27 21:11:53 +07:00
|
|
|
else
|
2010-11-09 02:18:58 +07:00
|
|
|
describe_obj(m, obj);
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
2009-02-11 21:26:38 +07:00
|
|
|
}
|
|
|
|
|
2010-11-09 02:18:58 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2009-02-11 21:26:38 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-18 08:08:50 +07:00
|
|
|
static int i915_hws_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2009-02-18 08:08:50 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2012-11-30 04:18:51 +07:00
|
|
|
const u32 *hws;
|
2010-10-30 03:00:54 +07:00
|
|
|
int i;
|
|
|
|
|
2010-12-04 18:30:53 +07:00
|
|
|
ring = &dev_priv->ring[(uintptr_t)node->info_ent->data];
|
2012-11-30 04:18:51 +07:00
|
|
|
hws = ring->status_page.page_addr;
|
2009-02-18 08:08:50 +07:00
|
|
|
if (hws == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < 4096 / sizeof(u32) / 4; i += 4) {
|
|
|
|
seq_printf(m, "0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
|
|
i * 4,
|
|
|
|
hws[i], hws[i + 1], hws[i + 2], hws[i + 3]);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-27 20:17:40 +07:00
|
|
|
static ssize_t
|
|
|
|
i915_error_state_write(struct file *filp,
|
|
|
|
const char __user *ubuf,
|
|
|
|
size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
2013-05-23 17:55:35 +07:00
|
|
|
struct i915_error_state_file_priv *error_priv = filp->private_data;
|
2012-04-27 20:17:40 +07:00
|
|
|
struct drm_device *dev = error_priv->dev;
|
2012-08-09 20:07:02 +07:00
|
|
|
int ret;
|
2012-04-27 20:17:40 +07:00
|
|
|
|
|
|
|
DRM_DEBUG_DRIVER("Resetting error state\n");
|
|
|
|
|
2012-08-09 20:07:02 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-04-27 20:17:40 +07:00
|
|
|
i915_destroy_error_state(dev);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_error_state_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
struct i915_error_state_file_priv *error_priv;
|
|
|
|
|
|
|
|
error_priv = kzalloc(sizeof(*error_priv), GFP_KERNEL);
|
|
|
|
if (!error_priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
error_priv->dev = dev;
|
|
|
|
|
2013-06-06 19:18:40 +07:00
|
|
|
i915_error_state_get(dev, error_priv);
|
2012-04-27 20:17:40 +07:00
|
|
|
|
2013-05-23 17:55:35 +07:00
|
|
|
file->private_data = error_priv;
|
|
|
|
|
|
|
|
return 0;
|
2012-04-27 20:17:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_error_state_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-05-23 17:55:35 +07:00
|
|
|
struct i915_error_state_file_priv *error_priv = file->private_data;
|
2012-04-27 20:17:40 +07:00
|
|
|
|
2013-06-06 19:18:40 +07:00
|
|
|
i915_error_state_put(error_priv);
|
2012-04-27 20:17:40 +07:00
|
|
|
kfree(error_priv);
|
|
|
|
|
2013-05-23 17:55:35 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-06 19:18:41 +07:00
|
|
|
static ssize_t i915_error_state_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct i915_error_state_file_priv *error_priv = file->private_data;
|
|
|
|
struct drm_i915_error_state_buf error_str;
|
|
|
|
loff_t tmp_pos = 0;
|
|
|
|
ssize_t ret_count = 0;
|
|
|
|
int ret;
|
|
|
|
|
2014-08-22 20:41:39 +07:00
|
|
|
ret = i915_error_state_buf_init(&error_str, to_i915(error_priv->dev), count, *pos);
|
2013-06-06 19:18:41 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-05-23 17:55:35 +07:00
|
|
|
|
2013-06-06 19:18:39 +07:00
|
|
|
ret = i915_error_state_to_str(&error_str, error_priv);
|
2013-05-23 17:55:35 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret_count = simple_read_from_buffer(userbuf, count, &tmp_pos,
|
|
|
|
error_str.buf,
|
|
|
|
error_str.bytes);
|
|
|
|
|
|
|
|
if (ret_count < 0)
|
|
|
|
ret = ret_count;
|
|
|
|
else
|
|
|
|
*pos = error_str.start + ret_count;
|
|
|
|
out:
|
2013-06-06 19:18:41 +07:00
|
|
|
i915_error_state_buf_release(&error_str);
|
2013-05-23 17:55:35 +07:00
|
|
|
return ret ?: ret_count;
|
2012-04-27 20:17:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations i915_error_state_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = i915_error_state_open,
|
2013-05-23 17:55:35 +07:00
|
|
|
.read = i915_error_state_read,
|
2012-04-27 20:17:40 +07:00
|
|
|
.write = i915_error_state_write,
|
|
|
|
.llseek = default_llseek,
|
|
|
|
.release = i915_error_state_release,
|
|
|
|
};
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_next_seqno_get(void *data, u64 *val)
|
2012-12-04 20:12:00 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-12-04 20:12:00 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
*val = dev_priv->next_seqno;
|
2012-12-04 20:12:00 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2012-12-04 20:12:00 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_next_seqno_set(void *data, u64 val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
2012-12-04 20:12:00 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-12-19 16:13:09 +07:00
|
|
|
ret = i915_gem_set_seqno(dev, val);
|
2012-12-04 20:12:00 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return ret;
|
2012-12-04 20:12:00 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_next_seqno_fops,
|
|
|
|
i915_next_seqno_get, i915_next_seqno_set,
|
2013-04-12 16:10:05 +07:00
|
|
|
"0x%llx\n");
|
2012-12-04 20:12:00 +07:00
|
|
|
|
2014-03-31 13:00:02 +07:00
|
|
|
static int i915_frequency_info(struct seq_file *m, void *unused)
|
2010-01-30 02:27:07 +07:00
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-01-30 02:27:07 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-28 03:21:54 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
intel_runtime_pm_get(dev_priv);
|
2010-12-18 05:19:02 +07:00
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2010-12-18 05:19:02 +07:00
|
|
|
if (IS_GEN5(dev)) {
|
|
|
|
u16 rgvswctl = I915_READ16(MEMSWCTL);
|
|
|
|
u16 rgvstat = I915_READ16(MEMSTAT_ILK);
|
|
|
|
|
|
|
|
seq_printf(m, "Requested P-state: %d\n", (rgvswctl >> 8) & 0xf);
|
|
|
|
seq_printf(m, "Requested VID: %d\n", rgvswctl & 0x3f);
|
|
|
|
seq_printf(m, "Current VID: %d\n", (rgvstat & MEMSTAT_VID_MASK) >>
|
|
|
|
MEMSTAT_VID_SHIFT);
|
|
|
|
seq_printf(m, "Current P-state: %d\n",
|
|
|
|
(rgvstat & MEMSTAT_PSTATE_MASK) >> MEMSTAT_PSTATE_SHIFT);
|
2014-05-31 06:22:10 +07:00
|
|
|
} else if (IS_GEN6(dev) || (IS_GEN7(dev) && !IS_VALLEYVIEW(dev)) ||
|
2015-03-06 12:37:21 +07:00
|
|
|
IS_BROADWELL(dev) || IS_GEN9(dev)) {
|
2010-12-18 05:19:02 +07:00
|
|
|
u32 gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
|
|
|
|
u32 rp_state_limits = I915_READ(GEN6_RP_STATE_LIMITS);
|
|
|
|
u32 rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
|
2014-03-27 16:06:14 +07:00
|
|
|
u32 rpmodectl, rpinclimit, rpdeclimit;
|
2013-08-27 05:51:01 +07:00
|
|
|
u32 rpstat, cagf, reqf;
|
2011-01-19 06:49:25 +07:00
|
|
|
u32 rpupei, rpcurup, rpprevup;
|
|
|
|
u32 rpdownei, rpcurdown, rpprevdown;
|
2014-08-02 04:14:48 +07:00
|
|
|
u32 pm_ier, pm_imr, pm_isr, pm_iir, pm_mask;
|
2010-12-18 05:19:02 +07:00
|
|
|
int max_freq;
|
|
|
|
|
|
|
|
/* RPSTAT1 is in the GT power well */
|
2011-04-26 02:11:50 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
2013-11-28 03:21:54 +07:00
|
|
|
goto out;
|
2011-04-26 02:11:50 +07:00
|
|
|
|
2015-01-16 16:34:40 +07:00
|
|
|
intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
|
2010-12-18 05:19:02 +07:00
|
|
|
|
2013-08-27 05:51:01 +07:00
|
|
|
reqf = I915_READ(GEN6_RPNSWREQ);
|
2015-03-06 12:37:21 +07:00
|
|
|
if (IS_GEN9(dev))
|
|
|
|
reqf >>= 23;
|
|
|
|
else {
|
|
|
|
reqf &= ~GEN6_TURBO_DISABLE;
|
|
|
|
if (IS_HASWELL(dev) || IS_BROADWELL(dev))
|
|
|
|
reqf >>= 24;
|
|
|
|
else
|
|
|
|
reqf >>= 25;
|
|
|
|
}
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
reqf = intel_gpu_freq(dev_priv, reqf);
|
2013-08-27 05:51:01 +07:00
|
|
|
|
2014-03-27 16:06:14 +07:00
|
|
|
rpmodectl = I915_READ(GEN6_RP_CONTROL);
|
|
|
|
rpinclimit = I915_READ(GEN6_RP_UP_THRESHOLD);
|
|
|
|
rpdeclimit = I915_READ(GEN6_RP_DOWN_THRESHOLD);
|
|
|
|
|
2011-01-19 06:49:25 +07:00
|
|
|
rpstat = I915_READ(GEN6_RPSTAT1);
|
|
|
|
rpupei = I915_READ(GEN6_RP_CUR_UP_EI);
|
|
|
|
rpcurup = I915_READ(GEN6_RP_CUR_UP);
|
|
|
|
rpprevup = I915_READ(GEN6_RP_PREV_UP);
|
|
|
|
rpdownei = I915_READ(GEN6_RP_CUR_DOWN_EI);
|
|
|
|
rpcurdown = I915_READ(GEN6_RP_CUR_DOWN);
|
|
|
|
rpprevdown = I915_READ(GEN6_RP_PREV_DOWN);
|
2015-03-06 12:37:21 +07:00
|
|
|
if (IS_GEN9(dev))
|
|
|
|
cagf = (rpstat & GEN9_CAGF_MASK) >> GEN9_CAGF_SHIFT;
|
|
|
|
else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
|
2013-01-30 03:00:15 +07:00
|
|
|
cagf = (rpstat & HSW_CAGF_MASK) >> HSW_CAGF_SHIFT;
|
|
|
|
else
|
|
|
|
cagf = (rpstat & GEN6_CAGF_MASK) >> GEN6_CAGF_SHIFT;
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
cagf = intel_gpu_freq(dev_priv, cagf);
|
2011-01-19 06:49:25 +07:00
|
|
|
|
2015-01-16 16:34:40 +07:00
|
|
|
intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
|
2011-04-26 02:11:50 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2014-08-02 04:14:48 +07:00
|
|
|
if (IS_GEN6(dev) || IS_GEN7(dev)) {
|
|
|
|
pm_ier = I915_READ(GEN6_PMIER);
|
|
|
|
pm_imr = I915_READ(GEN6_PMIMR);
|
|
|
|
pm_isr = I915_READ(GEN6_PMISR);
|
|
|
|
pm_iir = I915_READ(GEN6_PMIIR);
|
|
|
|
pm_mask = I915_READ(GEN6_PMINTRMSK);
|
|
|
|
} else {
|
|
|
|
pm_ier = I915_READ(GEN8_GT_IER(2));
|
|
|
|
pm_imr = I915_READ(GEN8_GT_IMR(2));
|
|
|
|
pm_isr = I915_READ(GEN8_GT_ISR(2));
|
|
|
|
pm_iir = I915_READ(GEN8_GT_IIR(2));
|
|
|
|
pm_mask = I915_READ(GEN6_PMINTRMSK);
|
|
|
|
}
|
2014-03-27 16:06:14 +07:00
|
|
|
seq_printf(m, "PM IER=0x%08x IMR=0x%08x ISR=0x%08x IIR=0x%08x, MASK=0x%08x\n",
|
2014-08-02 04:14:48 +07:00
|
|
|
pm_ier, pm_imr, pm_isr, pm_iir, pm_mask);
|
2010-12-18 05:19:02 +07:00
|
|
|
seq_printf(m, "GT_PERF_STATUS: 0x%08x\n", gt_perf_status);
|
|
|
|
seq_printf(m, "Render p-state ratio: %d\n",
|
2015-03-06 12:37:21 +07:00
|
|
|
(gt_perf_status & (IS_GEN9(dev) ? 0x1ff00 : 0xff00)) >> 8);
|
2010-12-18 05:19:02 +07:00
|
|
|
seq_printf(m, "Render p-state VID: %d\n",
|
|
|
|
gt_perf_status & 0xff);
|
|
|
|
seq_printf(m, "Render p-state limit: %d\n",
|
|
|
|
rp_state_limits & 0xff);
|
2014-03-27 16:06:14 +07:00
|
|
|
seq_printf(m, "RPSTAT1: 0x%08x\n", rpstat);
|
|
|
|
seq_printf(m, "RPMODECTL: 0x%08x\n", rpmodectl);
|
|
|
|
seq_printf(m, "RPINCLIMIT: 0x%08x\n", rpinclimit);
|
|
|
|
seq_printf(m, "RPDECLIMIT: 0x%08x\n", rpdeclimit);
|
2013-08-27 05:51:01 +07:00
|
|
|
seq_printf(m, "RPNSWREQ: %dMHz\n", reqf);
|
2013-01-30 03:00:15 +07:00
|
|
|
seq_printf(m, "CAGF: %dMHz\n", cagf);
|
2011-01-19 06:49:25 +07:00
|
|
|
seq_printf(m, "RP CUR UP EI: %dus\n", rpupei &
|
|
|
|
GEN6_CURICONT_MASK);
|
|
|
|
seq_printf(m, "RP CUR UP: %dus\n", rpcurup &
|
|
|
|
GEN6_CURBSYTAVG_MASK);
|
|
|
|
seq_printf(m, "RP PREV UP: %dus\n", rpprevup &
|
|
|
|
GEN6_CURBSYTAVG_MASK);
|
|
|
|
seq_printf(m, "RP CUR DOWN EI: %dus\n", rpdownei &
|
|
|
|
GEN6_CURIAVG_MASK);
|
|
|
|
seq_printf(m, "RP CUR DOWN: %dus\n", rpcurdown &
|
|
|
|
GEN6_CURBSYTAVG_MASK);
|
|
|
|
seq_printf(m, "RP PREV DOWN: %dus\n", rpprevdown &
|
|
|
|
GEN6_CURBSYTAVG_MASK);
|
2010-12-18 05:19:02 +07:00
|
|
|
|
|
|
|
max_freq = (rp_state_cap & 0xff0000) >> 16;
|
2015-03-06 12:37:21 +07:00
|
|
|
max_freq *= (IS_SKYLAKE(dev) ? GEN9_FREQ_SCALER : 1);
|
2010-12-18 05:19:02 +07:00
|
|
|
seq_printf(m, "Lowest (RPN) frequency: %dMHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, max_freq));
|
2010-12-18 05:19:02 +07:00
|
|
|
|
|
|
|
max_freq = (rp_state_cap & 0xff00) >> 8;
|
2015-03-06 12:37:21 +07:00
|
|
|
max_freq *= (IS_SKYLAKE(dev) ? GEN9_FREQ_SCALER : 1);
|
2010-12-18 05:19:02 +07:00
|
|
|
seq_printf(m, "Nominal (RP1) frequency: %dMHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, max_freq));
|
2010-12-18 05:19:02 +07:00
|
|
|
|
|
|
|
max_freq = rp_state_cap & 0xff;
|
2015-03-06 12:37:21 +07:00
|
|
|
max_freq *= (IS_SKYLAKE(dev) ? GEN9_FREQ_SCALER : 1);
|
2010-12-18 05:19:02 +07:00
|
|
|
seq_printf(m, "Max non-overclocked (RP0) frequency: %dMHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, max_freq));
|
2013-04-06 04:29:22 +07:00
|
|
|
|
|
|
|
seq_printf(m, "Max overclocked frequency: %dMHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.max_freq));
|
2015-03-18 16:48:21 +07:00
|
|
|
|
|
|
|
seq_printf(m, "Idle freq: %d MHz\n",
|
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.idle_freq));
|
2013-04-18 05:54:58 +07:00
|
|
|
} else if (IS_VALLEYVIEW(dev)) {
|
2014-06-28 06:03:53 +07:00
|
|
|
u32 freq_sts;
|
2013-04-18 05:54:58 +07:00
|
|
|
|
2013-04-23 05:59:30 +07:00
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
2013-05-22 19:36:20 +07:00
|
|
|
freq_sts = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS);
|
2013-04-18 05:54:58 +07:00
|
|
|
seq_printf(m, "PUNIT_REG_GPU_FREQ_STS: 0x%08x\n", freq_sts);
|
|
|
|
seq_printf(m, "DDR freq: %d MHz\n", dev_priv->mem_freq);
|
|
|
|
|
|
|
|
seq_printf(m, "max GPU freq: %d MHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.max_freq));
|
2013-04-18 05:54:58 +07:00
|
|
|
|
|
|
|
seq_printf(m, "min GPU freq: %d MHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.min_freq));
|
2014-06-28 06:03:53 +07:00
|
|
|
|
2015-03-18 16:48:21 +07:00
|
|
|
seq_printf(m, "idle GPU freq: %d MHz\n",
|
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.idle_freq));
|
|
|
|
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
seq_printf(m,
|
|
|
|
"efficient (RPe) frequency: %d MHz\n",
|
|
|
|
intel_gpu_freq(dev_priv, dev_priv->rps.efficient_freq));
|
2013-04-18 05:54:58 +07:00
|
|
|
|
|
|
|
seq_printf(m, "current GPU freq: %d MHz\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, (freq_sts >> 8) & 0xff));
|
2013-04-23 05:59:30 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2010-12-18 05:19:02 +07:00
|
|
|
} else {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "no P-state info available\n");
|
2010-12-18 05:19:02 +07:00
|
|
|
}
|
2010-01-30 02:27:07 +07:00
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
out:
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
return ret;
|
2010-01-30 02:27:07 +07:00
|
|
|
}
|
|
|
|
|
2015-01-26 23:03:04 +07:00
|
|
|
static int i915_hangcheck_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
2015-02-05 23:41:48 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2015-01-26 23:03:04 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2015-02-05 23:41:48 +07:00
|
|
|
u64 acthd[I915_NUM_RINGS];
|
|
|
|
u32 seqno[I915_NUM_RINGS];
|
2015-01-26 23:03:04 +07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!i915.enable_hangcheck) {
|
|
|
|
seq_printf(m, "Hangcheck disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-05 23:41:48 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
seqno[i] = ring->get_seqno(ring, false);
|
|
|
|
acthd[i] = intel_ring_get_active_head(ring);
|
|
|
|
}
|
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2015-01-26 23:03:04 +07:00
|
|
|
if (delayed_work_pending(&dev_priv->gpu_error.hangcheck_work)) {
|
|
|
|
seq_printf(m, "Hangcheck active, fires in %dms\n",
|
|
|
|
jiffies_to_msecs(dev_priv->gpu_error.hangcheck_work.timer.expires -
|
|
|
|
jiffies));
|
|
|
|
} else
|
|
|
|
seq_printf(m, "Hangcheck inactive\n");
|
|
|
|
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
seq_printf(m, "%s:\n", ring->name);
|
|
|
|
seq_printf(m, "\tseqno = %x [current %x]\n",
|
2015-02-05 23:41:48 +07:00
|
|
|
ring->hangcheck.seqno, seqno[i]);
|
2015-01-26 23:03:04 +07:00
|
|
|
seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n",
|
|
|
|
(long long)ring->hangcheck.acthd,
|
2015-02-05 23:41:48 +07:00
|
|
|
(long long)acthd[i]);
|
2015-01-26 23:03:04 +07:00
|
|
|
seq_printf(m, "\tmax ACTHD = 0x%08llx\n",
|
|
|
|
(long long)ring->hangcheck.max_acthd);
|
2015-02-05 23:41:48 +07:00
|
|
|
seq_printf(m, "\tscore = %d\n", ring->hangcheck.score);
|
|
|
|
seq_printf(m, "\taction = %d\n", ring->hangcheck.action);
|
2015-01-26 23:03:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-13 10:34:16 +07:00
|
|
|
static int ironlake_drpc_info(struct seq_file *m)
|
2010-01-30 02:27:07 +07:00
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-01-30 02:27:07 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2011-10-06 01:44:54 +07:00
|
|
|
u32 rgvmodectl, rstdbyctl;
|
|
|
|
u16 crstandvid;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2011-10-06 01:44:54 +07:00
|
|
|
|
|
|
|
rgvmodectl = I915_READ(MEMMODECTL);
|
|
|
|
rstdbyctl = I915_READ(RSTDBYCTL);
|
|
|
|
crstandvid = I915_READ16(CRSTANDVID);
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2011-10-06 01:44:54 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-01-30 02:27:07 +07:00
|
|
|
|
|
|
|
seq_printf(m, "HD boost: %s\n", (rgvmodectl & MEMMODE_BOOST_EN) ?
|
|
|
|
"yes" : "no");
|
|
|
|
seq_printf(m, "Boost freq: %d\n",
|
|
|
|
(rgvmodectl & MEMMODE_BOOST_FREQ_MASK) >>
|
|
|
|
MEMMODE_BOOST_FREQ_SHIFT);
|
|
|
|
seq_printf(m, "HW control enabled: %s\n",
|
|
|
|
rgvmodectl & MEMMODE_HWIDLE_EN ? "yes" : "no");
|
|
|
|
seq_printf(m, "SW control enabled: %s\n",
|
|
|
|
rgvmodectl & MEMMODE_SWMODE_EN ? "yes" : "no");
|
|
|
|
seq_printf(m, "Gated voltage change: %s\n",
|
|
|
|
rgvmodectl & MEMMODE_RCLK_GATE ? "yes" : "no");
|
|
|
|
seq_printf(m, "Starting frequency: P%d\n",
|
|
|
|
(rgvmodectl & MEMMODE_FSTART_MASK) >> MEMMODE_FSTART_SHIFT);
|
2010-05-21 04:28:11 +07:00
|
|
|
seq_printf(m, "Max P-state: P%d\n",
|
2010-01-30 02:27:07 +07:00
|
|
|
(rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT);
|
2010-05-21 04:28:11 +07:00
|
|
|
seq_printf(m, "Min P-state: P%d\n", (rgvmodectl & MEMMODE_FMIN_MASK));
|
|
|
|
seq_printf(m, "RS1 VID: %d\n", (crstandvid & 0x3f));
|
|
|
|
seq_printf(m, "RS2 VID: %d\n", ((crstandvid >> 8) & 0x3f));
|
|
|
|
seq_printf(m, "Render standby enabled: %s\n",
|
|
|
|
(rstdbyctl & RCX_SW_EXIT) ? "no" : "yes");
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Current RS state: ");
|
2011-01-06 03:01:24 +07:00
|
|
|
switch (rstdbyctl & RSX_STATUS_MASK) {
|
|
|
|
case RSX_STATUS_ON:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "on\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
case RSX_STATUS_RC1:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC1\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
case RSX_STATUS_RC1E:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC1E\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
case RSX_STATUS_RS1:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RS1\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
case RSX_STATUS_RS2:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RS2 (RC6)\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
case RSX_STATUS_RS3:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC3 (RC6+)\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
default:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "unknown\n");
|
2011-01-06 03:01:24 +07:00
|
|
|
break;
|
|
|
|
}
|
2010-01-30 02:27:07 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-16 16:34:42 +07:00
|
|
|
static int i915_forcewake_domains(struct seq_file *m, void *data)
|
2014-01-10 16:48:26 +07:00
|
|
|
{
|
2015-01-16 16:34:37 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_uncore_forcewake_domain *fw_domain;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev_priv->uncore.lock);
|
|
|
|
for_each_fw_domain(fw_domain, dev_priv, i) {
|
|
|
|
seq_printf(m, "%s.wake_count = %u\n",
|
2015-01-19 21:20:43 +07:00
|
|
|
intel_uncore_forcewake_domain_to_str(i),
|
2015-01-16 16:34:37 +07:00
|
|
|
fw_domain->wake_count);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&dev_priv->uncore.lock);
|
2014-01-10 16:48:26 +07:00
|
|
|
|
2015-01-16 16:34:37 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vlv_drpc_info(struct seq_file *m)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2014-01-10 16:48:26 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-11-20 01:07:42 +07:00
|
|
|
u32 rpmodectl1, rcctl1, pw_status;
|
2014-01-10 16:48:26 +07:00
|
|
|
|
2014-04-15 00:24:27 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-11-20 01:07:42 +07:00
|
|
|
pw_status = I915_READ(VLV_GTLC_PW_STATUS);
|
2014-01-10 16:48:26 +07:00
|
|
|
rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
|
|
|
|
rcctl1 = I915_READ(GEN6_RC_CONTROL);
|
|
|
|
|
2014-04-15 00:24:27 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2014-01-10 16:48:26 +07:00
|
|
|
seq_printf(m, "Video Turbo Mode: %s\n",
|
|
|
|
yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
|
|
|
|
seq_printf(m, "Turbo enabled: %s\n",
|
|
|
|
yesno(rpmodectl1 & GEN6_RP_ENABLE));
|
|
|
|
seq_printf(m, "HW control enabled: %s\n",
|
|
|
|
yesno(rpmodectl1 & GEN6_RP_ENABLE));
|
|
|
|
seq_printf(m, "SW control enabled: %s\n",
|
|
|
|
yesno((rpmodectl1 & GEN6_RP_MEDIA_MODE_MASK) ==
|
|
|
|
GEN6_RP_MEDIA_SW_MODE));
|
|
|
|
seq_printf(m, "RC6 Enabled: %s\n",
|
|
|
|
yesno(rcctl1 & (GEN7_RC_CTL_TO_MODE |
|
|
|
|
GEN6_RC_CTL_EI_MODE(1))));
|
|
|
|
seq_printf(m, "Render Power Well: %s\n",
|
2014-11-20 01:07:42 +07:00
|
|
|
(pw_status & VLV_GTLC_PW_RENDER_STATUS_MASK) ? "Up" : "Down");
|
2014-01-10 16:48:26 +07:00
|
|
|
seq_printf(m, "Media Power Well: %s\n",
|
2014-11-20 01:07:42 +07:00
|
|
|
(pw_status & VLV_GTLC_PW_MEDIA_STATUS_MASK) ? "Up" : "Down");
|
2014-01-10 16:48:26 +07:00
|
|
|
|
2014-04-15 00:24:24 +07:00
|
|
|
seq_printf(m, "Render RC6 residency since boot: %u\n",
|
|
|
|
I915_READ(VLV_GT_RENDER_RC6));
|
|
|
|
seq_printf(m, "Media RC6 residency since boot: %u\n",
|
|
|
|
I915_READ(VLV_GT_MEDIA_RC6));
|
|
|
|
|
2015-01-16 16:34:42 +07:00
|
|
|
return i915_forcewake_domains(m, NULL);
|
2014-01-10 16:48:26 +07:00
|
|
|
}
|
|
|
|
|
2011-12-13 10:34:16 +07:00
|
|
|
static int gen6_drpc_info(struct seq_file *m)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-12-13 10:34:16 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-09-27 00:34:02 +07:00
|
|
|
u32 rpmodectl1, gt_core_status, rcctl1, rc6vids = 0;
|
2012-01-25 19:52:43 +07:00
|
|
|
unsigned forcewake_count;
|
2013-06-25 04:59:49 +07:00
|
|
|
int count = 0, ret;
|
2011-12-13 10:34:16 +07:00
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2011-12-13 10:34:16 +07:00
|
|
|
|
2013-07-20 02:36:52 +07:00
|
|
|
spin_lock_irq(&dev_priv->uncore.lock);
|
2015-01-16 16:34:37 +07:00
|
|
|
forcewake_count = dev_priv->uncore.fw_domain[FW_DOMAIN_ID_RENDER].wake_count;
|
2013-07-20 02:36:52 +07:00
|
|
|
spin_unlock_irq(&dev_priv->uncore.lock);
|
2012-01-25 19:52:43 +07:00
|
|
|
|
|
|
|
if (forcewake_count) {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC information inaccurate because somebody "
|
|
|
|
"holds a forcewake reference \n");
|
2011-12-13 10:34:16 +07:00
|
|
|
} else {
|
|
|
|
/* NB: we cannot use forcewake, else we read the wrong values */
|
|
|
|
while (count++ < 50 && (I915_READ_NOTRACE(FORCEWAKE_ACK) & 1))
|
|
|
|
udelay(10);
|
|
|
|
seq_printf(m, "RC information accurate: %s\n", yesno(count < 51));
|
|
|
|
}
|
|
|
|
|
|
|
|
gt_core_status = readl(dev_priv->regs + GEN6_GT_CORE_STATUS);
|
2013-07-20 02:36:56 +07:00
|
|
|
trace_i915_reg_rw(false, GEN6_GT_CORE_STATUS, gt_core_status, 4, true);
|
2011-12-13 10:34:16 +07:00
|
|
|
|
|
|
|
rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
|
|
|
|
rcctl1 = I915_READ(GEN6_RC_CONTROL);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2012-11-06 21:36:36 +07:00
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
|
|
|
sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS, &rc6vids);
|
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2011-12-13 10:34:16 +07:00
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2011-12-13 10:34:16 +07:00
|
|
|
seq_printf(m, "Video Turbo Mode: %s\n",
|
|
|
|
yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
|
|
|
|
seq_printf(m, "HW control enabled: %s\n",
|
|
|
|
yesno(rpmodectl1 & GEN6_RP_ENABLE));
|
|
|
|
seq_printf(m, "SW control enabled: %s\n",
|
|
|
|
yesno((rpmodectl1 & GEN6_RP_MEDIA_MODE_MASK) ==
|
|
|
|
GEN6_RP_MEDIA_SW_MODE));
|
2012-01-24 07:14:05 +07:00
|
|
|
seq_printf(m, "RC1e Enabled: %s\n",
|
2011-12-13 10:34:16 +07:00
|
|
|
yesno(rcctl1 & GEN6_RC_CTL_RC1e_ENABLE));
|
|
|
|
seq_printf(m, "RC6 Enabled: %s\n",
|
|
|
|
yesno(rcctl1 & GEN6_RC_CTL_RC6_ENABLE));
|
|
|
|
seq_printf(m, "Deep RC6 Enabled: %s\n",
|
|
|
|
yesno(rcctl1 & GEN6_RC_CTL_RC6p_ENABLE));
|
|
|
|
seq_printf(m, "Deepest RC6 Enabled: %s\n",
|
|
|
|
yesno(rcctl1 & GEN6_RC_CTL_RC6pp_ENABLE));
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Current RC state: ");
|
2011-12-13 10:34:16 +07:00
|
|
|
switch (gt_core_status & GEN6_RCn_MASK) {
|
|
|
|
case GEN6_RC0:
|
|
|
|
if (gt_core_status & GEN6_CORE_CPD_STATE_MASK)
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Core Power Down\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
else
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "on\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
break;
|
|
|
|
case GEN6_RC3:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC3\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
break;
|
|
|
|
case GEN6_RC6:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC6\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
break;
|
|
|
|
case GEN6_RC7:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "RC7\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
break;
|
|
|
|
default:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "Unknown\n");
|
2011-12-13 10:34:16 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "Core Power Down: %s\n",
|
|
|
|
yesno(gt_core_status & GEN6_CORE_CPD_STATE_MASK));
|
2012-03-28 08:59:38 +07:00
|
|
|
|
|
|
|
/* Not exactly sure what this is */
|
|
|
|
seq_printf(m, "RC6 \"Locked to RPn\" residency since boot: %u\n",
|
|
|
|
I915_READ(GEN6_GT_GFX_RC6_LOCKED));
|
|
|
|
seq_printf(m, "RC6 residency since boot: %u\n",
|
|
|
|
I915_READ(GEN6_GT_GFX_RC6));
|
|
|
|
seq_printf(m, "RC6+ residency since boot: %u\n",
|
|
|
|
I915_READ(GEN6_GT_GFX_RC6p));
|
|
|
|
seq_printf(m, "RC6++ residency since boot: %u\n",
|
|
|
|
I915_READ(GEN6_GT_GFX_RC6pp));
|
|
|
|
|
2012-09-27 00:34:02 +07:00
|
|
|
seq_printf(m, "RC6 voltage: %dmV\n",
|
|
|
|
GEN6_DECODE_RC6_VID(((rc6vids >> 0) & 0xff)));
|
|
|
|
seq_printf(m, "RC6+ voltage: %dmV\n",
|
|
|
|
GEN6_DECODE_RC6_VID(((rc6vids >> 8) & 0xff)));
|
|
|
|
seq_printf(m, "RC6++ voltage: %dmV\n",
|
|
|
|
GEN6_DECODE_RC6_VID(((rc6vids >> 16) & 0xff)));
|
2011-12-13 10:34:16 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_drpc_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-12-13 10:34:16 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
|
2014-01-10 16:48:26 +07:00
|
|
|
if (IS_VALLEYVIEW(dev))
|
|
|
|
return vlv_drpc_info(m);
|
2014-08-27 00:42:51 +07:00
|
|
|
else if (INTEL_INFO(dev)->gen >= 6)
|
2011-12-13 10:34:16 +07:00
|
|
|
return gen6_drpc_info(m);
|
|
|
|
else
|
|
|
|
return ironlake_drpc_info(m);
|
|
|
|
}
|
|
|
|
|
2010-02-06 03:42:41 +07:00
|
|
|
static int i915_fbc_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-02-06 03:42:41 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-02-06 03:42:41 +07:00
|
|
|
|
2014-01-10 14:50:12 +07:00
|
|
|
if (!HAS_FBC(dev)) {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "FBC unsupported on this chipset\n");
|
2010-02-06 03:42:41 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2010-04-23 22:17:39 +07:00
|
|
|
if (intel_fbc_enabled(dev)) {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "FBC enabled\n");
|
2010-02-06 03:42:41 +07:00
|
|
|
} else {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "FBC disabled: ");
|
2013-06-28 06:30:21 +07:00
|
|
|
switch (dev_priv->fbc.no_fbc_reason) {
|
2013-07-27 23:23:55 +07:00
|
|
|
case FBC_OK:
|
|
|
|
seq_puts(m, "FBC actived, but currently disabled in hardware");
|
|
|
|
break;
|
|
|
|
case FBC_UNSUPPORTED:
|
|
|
|
seq_puts(m, "unsupported by this chipset");
|
|
|
|
break;
|
2010-09-11 16:47:47 +07:00
|
|
|
case FBC_NO_OUTPUT:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "no outputs");
|
2010-09-11 16:47:47 +07:00
|
|
|
break;
|
2010-02-06 03:42:41 +07:00
|
|
|
case FBC_STOLEN_TOO_SMALL:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "not enough stolen memory");
|
2010-02-06 03:42:41 +07:00
|
|
|
break;
|
|
|
|
case FBC_UNSUPPORTED_MODE:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "mode not supported");
|
2010-02-06 03:42:41 +07:00
|
|
|
break;
|
|
|
|
case FBC_MODE_TOO_LARGE:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "mode too large");
|
2010-02-06 03:42:41 +07:00
|
|
|
break;
|
|
|
|
case FBC_BAD_PLANE:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "FBC unsupported on plane");
|
2010-02-06 03:42:41 +07:00
|
|
|
break;
|
|
|
|
case FBC_NOT_TILED:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "scanout buffer not tiled");
|
2010-02-06 03:42:41 +07:00
|
|
|
break;
|
2010-07-24 05:20:00 +07:00
|
|
|
case FBC_MULTIPLE_PIPES:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "multiple pipes are enabled");
|
2010-07-24 05:20:00 +07:00
|
|
|
break;
|
2011-05-06 05:24:21 +07:00
|
|
|
case FBC_MODULE_PARAM:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "disabled per module param (default off)");
|
2011-05-06 05:24:21 +07:00
|
|
|
break;
|
2013-06-24 22:22:02 +07:00
|
|
|
case FBC_CHIP_DEFAULT:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "disabled per chip default");
|
2013-06-24 22:22:02 +07:00
|
|
|
break;
|
2010-02-06 03:42:41 +07:00
|
|
|
default:
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "unknown reason");
|
2010-02-06 03:42:41 +07:00
|
|
|
}
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
2010-02-06 03:42:41 +07:00
|
|
|
}
|
2014-02-21 23:52:23 +07:00
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2010-02-06 03:42:41 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-01 16:04:45 +07:00
|
|
|
static int i915_fbc_fc_get(void *data, u64 *val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen < 7 || !HAS_FBC(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
*val = dev_priv->fbc.false_color;
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_fbc_fc_set(void *data, u64 val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen < 7 || !HAS_FBC(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
|
|
|
reg = I915_READ(ILK_DPFC_CONTROL);
|
|
|
|
dev_priv->fbc.false_color = val;
|
|
|
|
|
|
|
|
I915_WRITE(ILK_DPFC_CONTROL, val ?
|
|
|
|
(reg | FBC_CTL_FALSE_COLOR) :
|
|
|
|
(reg & ~FBC_CTL_FALSE_COLOR));
|
|
|
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_fbc_fc_fops,
|
|
|
|
i915_fbc_fc_get, i915_fbc_fc_set,
|
|
|
|
"%llu\n");
|
|
|
|
|
2013-06-01 02:33:24 +07:00
|
|
|
static int i915_ips_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-06-01 02:33:24 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2013-06-25 00:29:34 +07:00
|
|
|
if (!HAS_IPS(dev)) {
|
2013-06-01 02:33:24 +07:00
|
|
|
seq_puts(m, "not supported\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-06-30 18:45:01 +07:00
|
|
|
seq_printf(m, "Enabled by kernel parameter: %s\n",
|
|
|
|
yesno(i915.enable_ips));
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 8) {
|
|
|
|
seq_puts(m, "Currently: unknown\n");
|
|
|
|
} else {
|
|
|
|
if (I915_READ(IPS_CTL) & IPS_ENABLE)
|
|
|
|
seq_puts(m, "Currently: enabled\n");
|
|
|
|
else
|
|
|
|
seq_puts(m, "Currently: disabled\n");
|
|
|
|
}
|
2013-06-01 02:33:24 +07:00
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2013-06-01 02:33:24 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-06 03:47:35 +07:00
|
|
|
static int i915_sr_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-02-06 03:47:35 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-02-06 03:47:35 +07:00
|
|
|
bool sr_enabled = false;
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2010-12-15 14:42:31 +07:00
|
|
|
if (HAS_PCH_SPLIT(dev))
|
2010-08-20 00:04:08 +07:00
|
|
|
sr_enabled = I915_READ(WM1_LP_ILK) & WM1_LP_SR_EN;
|
2010-09-17 06:32:17 +07:00
|
|
|
else if (IS_CRESTLINE(dev) || IS_I945G(dev) || IS_I945GM(dev))
|
2010-02-06 03:47:35 +07:00
|
|
|
sr_enabled = I915_READ(FW_BLC_SELF) & FW_BLC_SELF_EN;
|
|
|
|
else if (IS_I915GM(dev))
|
|
|
|
sr_enabled = I915_READ(INSTPM) & INSTPM_SELF_EN;
|
|
|
|
else if (IS_PINEVIEW(dev))
|
|
|
|
sr_enabled = I915_READ(DSPFW3) & PINEVIEW_SELF_REFRESH_EN;
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2010-08-20 00:04:08 +07:00
|
|
|
seq_printf(m, "self-refresh: %s\n",
|
|
|
|
sr_enabled ? "enabled" : "disabled");
|
2010-02-06 03:47:35 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-21 04:28:11 +07:00
|
|
|
static int i915_emon_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-05-21 04:28:11 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-05-21 04:28:11 +07:00
|
|
|
unsigned long temp, chipset, gfx;
|
2010-07-03 13:58:38 +07:00
|
|
|
int ret;
|
|
|
|
|
2012-05-01 01:35:02 +07:00
|
|
|
if (!IS_GEN5(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-07-03 13:58:38 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-05-21 04:28:11 +07:00
|
|
|
|
|
|
|
temp = i915_mch_val(dev_priv);
|
|
|
|
chipset = i915_chipset_val(dev_priv);
|
|
|
|
gfx = i915_gfx_val(dev_priv);
|
2010-07-03 13:58:38 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-05-21 04:28:11 +07:00
|
|
|
|
|
|
|
seq_printf(m, "GMCH temp: %ld\n", temp);
|
|
|
|
seq_printf(m, "Chipset power: %ld\n", chipset);
|
|
|
|
seq_printf(m, "GFX power: %ld\n", gfx);
|
|
|
|
seq_printf(m, "Total power: %ld\n", chipset + gfx);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-29 03:04:16 +07:00
|
|
|
static int i915_ring_freq_table(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-06-29 03:04:16 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-12-19 20:54:52 +07:00
|
|
|
int ret = 0;
|
2011-06-29 03:04:16 +07:00
|
|
|
int gpu_freq, ia_freq;
|
|
|
|
|
2011-06-30 03:34:36 +07:00
|
|
|
if (!(IS_GEN6(dev) || IS_GEN7(dev))) {
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "unsupported on this chipset\n");
|
2011-06-29 03:04:16 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-19 20:54:52 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
|
2011-06-29 03:04:16 +07:00
|
|
|
if (ret)
|
2013-12-19 20:54:52 +07:00
|
|
|
goto out;
|
2011-06-29 03:04:16 +07:00
|
|
|
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "GPU freq (MHz)\tEffective CPU freq (MHz)\tEffective Ring freq (MHz)\n");
|
2011-06-29 03:04:16 +07:00
|
|
|
|
2014-03-20 08:31:11 +07:00
|
|
|
for (gpu_freq = dev_priv->rps.min_freq_softlimit;
|
|
|
|
gpu_freq <= dev_priv->rps.max_freq_softlimit;
|
2011-06-29 03:04:16 +07:00
|
|
|
gpu_freq++) {
|
2012-09-27 00:34:00 +07:00
|
|
|
ia_freq = gpu_freq;
|
|
|
|
sandybridge_pcode_read(dev_priv,
|
|
|
|
GEN6_PCODE_READ_MIN_FREQ_TABLE,
|
|
|
|
&ia_freq);
|
2013-04-13 01:10:13 +07:00
|
|
|
seq_printf(m, "%d\t\t%d\t\t\t\t%d\n",
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
intel_gpu_freq(dev_priv, gpu_freq),
|
2013-04-13 01:10:13 +07:00
|
|
|
((ia_freq >> 0) & 0xff) * 100,
|
|
|
|
((ia_freq >> 8) & 0xff) * 100);
|
2011-06-29 03:04:16 +07:00
|
|
|
}
|
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2011-06-29 03:04:16 +07:00
|
|
|
|
2013-12-19 20:54:52 +07:00
|
|
|
out:
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
return ret;
|
2011-06-29 03:04:16 +07:00
|
|
|
}
|
|
|
|
|
2010-08-19 22:09:23 +07:00
|
|
|
static int i915_opregion(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-08-19 22:09:23 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-08-19 22:09:23 +07:00
|
|
|
struct intel_opregion *opregion = &dev_priv->opregion;
|
2012-04-22 03:49:10 +07:00
|
|
|
void *data = kmalloc(OPREGION_SIZE, GFP_KERNEL);
|
2010-08-19 22:09:23 +07:00
|
|
|
int ret;
|
|
|
|
|
2012-04-22 03:49:10 +07:00
|
|
|
if (data == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-08-19 22:09:23 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
2012-04-22 03:49:10 +07:00
|
|
|
goto out;
|
2010-08-19 22:09:23 +07:00
|
|
|
|
2012-04-22 03:49:10 +07:00
|
|
|
if (opregion->header) {
|
|
|
|
memcpy_fromio(data, opregion->header, OPREGION_SIZE);
|
|
|
|
seq_write(m, data, OPREGION_SIZE);
|
|
|
|
}
|
2010-08-19 22:09:23 +07:00
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2012-04-22 03:49:10 +07:00
|
|
|
out:
|
|
|
|
kfree(data);
|
2010-08-19 22:09:23 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-26 04:45:57 +07:00
|
|
|
static int i915_gem_framebuffer_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2010-08-26 04:45:57 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2013-10-09 14:18:51 +07:00
|
|
|
struct intel_fbdev *ifbdev = NULL;
|
2010-08-26 04:45:57 +07:00
|
|
|
struct intel_framebuffer *fb;
|
|
|
|
|
2013-10-09 14:18:51 +07:00
|
|
|
#ifdef CONFIG_DRM_I915_FBDEV
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-08-26 04:45:57 +07:00
|
|
|
|
|
|
|
ifbdev = dev_priv->fbdev;
|
|
|
|
fb = to_intel_framebuffer(ifbdev->helper.fb);
|
|
|
|
|
2015-02-11 00:16:07 +07:00
|
|
|
seq_printf(m, "fbcon size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
|
2010-08-26 04:45:57 +07:00
|
|
|
fb->base.width,
|
|
|
|
fb->base.height,
|
|
|
|
fb->base.depth,
|
2012-12-11 22:21:38 +07:00
|
|
|
fb->base.bits_per_pixel,
|
2015-02-11 00:16:07 +07:00
|
|
|
fb->base.modifier[0],
|
2012-12-11 22:21:38 +07:00
|
|
|
atomic_read(&fb->base.refcount.refcount));
|
2010-11-09 02:18:58 +07:00
|
|
|
describe_obj(m, fb->obj);
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
2013-10-09 14:18:51 +07:00
|
|
|
#endif
|
2010-08-26 04:45:57 +07:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-11 03:19:18 +07:00
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
2010-08-26 04:45:57 +07:00
|
|
|
list_for_each_entry(fb, &dev->mode_config.fb_list, base.head) {
|
2013-10-17 19:35:31 +07:00
|
|
|
if (ifbdev && &fb->base == ifbdev->helper.fb)
|
2010-08-26 04:45:57 +07:00
|
|
|
continue;
|
|
|
|
|
2015-02-11 00:16:07 +07:00
|
|
|
seq_printf(m, "user size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
|
2010-08-26 04:45:57 +07:00
|
|
|
fb->base.width,
|
|
|
|
fb->base.height,
|
|
|
|
fb->base.depth,
|
2012-12-11 22:21:38 +07:00
|
|
|
fb->base.bits_per_pixel,
|
2015-02-11 00:16:07 +07:00
|
|
|
fb->base.modifier[0],
|
2012-12-11 22:21:38 +07:00
|
|
|
atomic_read(&fb->base.refcount.refcount));
|
2010-11-09 02:18:58 +07:00
|
|
|
describe_obj(m, fb->obj);
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_putc(m, '\n');
|
2010-08-26 04:45:57 +07:00
|
|
|
}
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-11 03:19:18 +07:00
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
2010-08-26 04:45:57 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-24 23:04:46 +07:00
|
|
|
static void describe_ctx_ringbuf(struct seq_file *m,
|
|
|
|
struct intel_ringbuffer *ringbuf)
|
|
|
|
{
|
|
|
|
seq_printf(m, " (ringbuffer, space: %d, head: %u, tail: %u, last head: %d)",
|
|
|
|
ringbuf->space, ringbuf->head, ringbuf->tail,
|
|
|
|
ringbuf->last_retired_head);
|
|
|
|
}
|
|
|
|
|
2011-03-20 08:14:29 +07:00
|
|
|
static int i915_context_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-03-20 08:14:29 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2014-05-22 20:13:37 +07:00
|
|
|
struct intel_context *ctx;
|
2013-02-15 06:05:12 +07:00
|
|
|
int ret, i;
|
2011-03-20 08:14:29 +07:00
|
|
|
|
2014-05-30 04:23:08 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
2011-03-20 08:14:29 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-09-18 11:12:45 +07:00
|
|
|
list_for_each_entry(ctx, &dev_priv->context_list, link) {
|
2014-07-24 23:04:46 +07:00
|
|
|
if (!i915.enable_execlists &&
|
|
|
|
ctx->legacy_hw_ctx.rcs_state == NULL)
|
2014-04-30 14:30:00 +07:00
|
|
|
continue;
|
|
|
|
|
2013-09-18 11:12:45 +07:00
|
|
|
seq_puts(m, "HW context ");
|
drm/i915: Do remaps for all contexts
On both Ivybridge and Haswell, row remapping information is saved and
restored with context. This means, we never actually properly supported
the l3 remapping because our sysfs interface is asynchronous (and not
tied to any context), and the known faulty HW would be reused by the
next context to run.
Not that due to the asynchronous nature of the sysfs entry, there is no
point modifying the registers for the existing context. Instead we set a
flag for all contexts to load the correct remapping information on the
next run. Interested clients can use debugfs to determine whether or not
the row has been remapped.
One could propose at this point that we just do the remapping in the
kernel. I guess since we have to maintain the sysfs interface anyway,
I'm not sure how useful it is, and I do like keeping the policy in
userspace; (it wasn't my original decision to make the
interface the way it is, so I'm not attached).
v2: Force a context switch when we have a remap on the next switch.
(Ville)
Don't let userspace use the interface with disabled contexts.
v3: Don't force a context switch, just let it nop
Improper context slice remap initialization, 1<<1 instead of 1<<i, but I
rewrote it to avoid a second round of confusion.
Error print moved to error path (All Ville)
Added a comment on why the slice remap initialization happens.
CC: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-09-19 09:03:18 +07:00
|
|
|
describe_ctx(m, ctx);
|
2014-07-24 23:04:46 +07:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2013-09-18 11:12:45 +07:00
|
|
|
if (ring->default_context == ctx)
|
2014-07-24 23:04:46 +07:00
|
|
|
seq_printf(m, "(default context %s) ",
|
|
|
|
ring->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i915.enable_execlists) {
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
struct drm_i915_gem_object *ctx_obj =
|
|
|
|
ctx->engine[i].state;
|
|
|
|
struct intel_ringbuffer *ringbuf =
|
|
|
|
ctx->engine[i].ringbuf;
|
|
|
|
|
|
|
|
seq_printf(m, "%s: ", ring->name);
|
|
|
|
if (ctx_obj)
|
|
|
|
describe_obj(m, ctx_obj);
|
|
|
|
if (ringbuf)
|
|
|
|
describe_ctx_ringbuf(m, ringbuf);
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
describe_obj(m, ctx->legacy_hw_ctx.rcs_state);
|
|
|
|
}
|
2013-09-18 11:12:45 +07:00
|
|
|
|
|
|
|
seq_putc(m, '\n');
|
2013-02-15 06:05:12 +07:00
|
|
|
}
|
|
|
|
|
2014-05-30 04:23:08 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2011-03-20 08:14:29 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:21:18 +07:00
|
|
|
static void i915_dump_lrc_obj(struct seq_file *m,
|
|
|
|
struct intel_engine_cs *ring,
|
|
|
|
struct drm_i915_gem_object *ctx_obj)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
uint32_t *reg_state;
|
|
|
|
int j;
|
|
|
|
unsigned long ggtt_offset = 0;
|
|
|
|
|
|
|
|
if (ctx_obj == NULL) {
|
|
|
|
seq_printf(m, "Context on %s with no gem object\n",
|
|
|
|
ring->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "CONTEXT: %s %u\n", ring->name,
|
|
|
|
intel_execlists_ctx_id(ctx_obj));
|
|
|
|
|
|
|
|
if (!i915_gem_obj_ggtt_bound(ctx_obj))
|
|
|
|
seq_puts(m, "\tNot bound in GGTT\n");
|
|
|
|
else
|
|
|
|
ggtt_offset = i915_gem_obj_ggtt_offset(ctx_obj);
|
|
|
|
|
|
|
|
if (i915_gem_object_get_pages(ctx_obj)) {
|
|
|
|
seq_puts(m, "\tFailed to get pages for context object\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
page = i915_gem_object_get_page(ctx_obj, 1);
|
|
|
|
if (!WARN_ON(page == NULL)) {
|
|
|
|
reg_state = kmap_atomic(page);
|
|
|
|
|
|
|
|
for (j = 0; j < 0x600 / sizeof(u32) / 4; j += 4) {
|
|
|
|
seq_printf(m, "\t[0x%08lx] 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
|
|
ggtt_offset + 4096 + (j * 4),
|
|
|
|
reg_state[j], reg_state[j + 1],
|
|
|
|
reg_state[j + 2], reg_state[j + 3]);
|
|
|
|
}
|
|
|
|
kunmap_atomic(reg_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
|
2014-08-07 19:24:26 +07:00
|
|
|
static int i915_dump_lrc(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_engine_cs *ring;
|
|
|
|
struct intel_context *ctx;
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
if (!i915.enable_execlists) {
|
|
|
|
seq_printf(m, "Logical Ring Contexts are disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
list_for_each_entry(ctx, &dev_priv->context_list, link) {
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2014-12-02 20:21:18 +07:00
|
|
|
if (ring->default_context != ctx)
|
|
|
|
i915_dump_lrc_obj(m, ring,
|
|
|
|
ctx->engine[i].state);
|
2014-08-07 19:24:26 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-07 19:23:20 +07:00
|
|
|
static int i915_execlists(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *)m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_engine_cs *ring;
|
|
|
|
u32 status_pointer;
|
|
|
|
u8 read_pointer;
|
|
|
|
u8 write_pointer;
|
|
|
|
u32 status;
|
|
|
|
u32 ctx_id;
|
|
|
|
struct list_head *cursor;
|
|
|
|
int ring_id, i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!i915.enable_execlists) {
|
|
|
|
seq_puts(m, "Logical Ring Contexts are disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-10-16 22:13:38 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-08-07 19:23:20 +07:00
|
|
|
for_each_ring(ring, dev_priv, ring_id) {
|
2015-01-15 20:10:39 +07:00
|
|
|
struct drm_i915_gem_request *head_req = NULL;
|
2014-08-07 19:23:20 +07:00
|
|
|
int count = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
seq_printf(m, "%s\n", ring->name);
|
|
|
|
|
|
|
|
status = I915_READ(RING_EXECLIST_STATUS(ring));
|
|
|
|
ctx_id = I915_READ(RING_EXECLIST_STATUS(ring) + 4);
|
|
|
|
seq_printf(m, "\tExeclist status: 0x%08X, context: %u\n",
|
|
|
|
status, ctx_id);
|
|
|
|
|
|
|
|
status_pointer = I915_READ(RING_CONTEXT_STATUS_PTR(ring));
|
|
|
|
seq_printf(m, "\tStatus pointer: 0x%08X\n", status_pointer);
|
|
|
|
|
|
|
|
read_pointer = ring->next_context_status_buffer;
|
|
|
|
write_pointer = status_pointer & 0x07;
|
|
|
|
if (read_pointer > write_pointer)
|
|
|
|
write_pointer += 6;
|
|
|
|
seq_printf(m, "\tRead pointer: 0x%08X, write pointer 0x%08X\n",
|
|
|
|
read_pointer, write_pointer);
|
|
|
|
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
|
status = I915_READ(RING_CONTEXT_STATUS_BUF(ring) + 8*i);
|
|
|
|
ctx_id = I915_READ(RING_CONTEXT_STATUS_BUF(ring) + 8*i + 4);
|
|
|
|
|
|
|
|
seq_printf(m, "\tStatus buffer %d: 0x%08X, context: %u\n",
|
|
|
|
i, status, ctx_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ring->execlist_lock, flags);
|
|
|
|
list_for_each(cursor, &ring->execlist_queue)
|
|
|
|
count++;
|
|
|
|
head_req = list_first_entry_or_null(&ring->execlist_queue,
|
2015-01-15 20:10:39 +07:00
|
|
|
struct drm_i915_gem_request, execlist_link);
|
2014-08-07 19:23:20 +07:00
|
|
|
spin_unlock_irqrestore(&ring->execlist_lock, flags);
|
|
|
|
|
|
|
|
seq_printf(m, "\t%d requests in queue\n", count);
|
|
|
|
if (head_req) {
|
|
|
|
struct drm_i915_gem_object *ctx_obj;
|
|
|
|
|
2015-01-15 20:10:39 +07:00
|
|
|
ctx_obj = head_req->ctx->engine[ring_id].state;
|
2014-08-07 19:23:20 +07:00
|
|
|
seq_printf(m, "\tHead request id: %u\n",
|
|
|
|
intel_execlists_ctx_id(ctx_obj));
|
|
|
|
seq_printf(m, "\tHead request tail: %u\n",
|
2015-01-15 20:10:39 +07:00
|
|
|
head_req->tail);
|
2014-08-07 19:23:20 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
|
2014-10-16 22:13:38 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2014-08-07 19:23:20 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-14 19:57:16 +07:00
|
|
|
static const char *swizzle_string(unsigned swizzle)
|
|
|
|
{
|
2013-06-25 04:59:49 +07:00
|
|
|
switch (swizzle) {
|
2011-12-14 19:57:16 +07:00
|
|
|
case I915_BIT_6_SWIZZLE_NONE:
|
|
|
|
return "none";
|
|
|
|
case I915_BIT_6_SWIZZLE_9:
|
|
|
|
return "bit9";
|
|
|
|
case I915_BIT_6_SWIZZLE_9_10:
|
|
|
|
return "bit9/bit10";
|
|
|
|
case I915_BIT_6_SWIZZLE_9_11:
|
|
|
|
return "bit9/bit11";
|
|
|
|
case I915_BIT_6_SWIZZLE_9_10_11:
|
|
|
|
return "bit9/bit10/bit11";
|
|
|
|
case I915_BIT_6_SWIZZLE_9_17:
|
|
|
|
return "bit9/bit17";
|
|
|
|
case I915_BIT_6_SWIZZLE_9_10_17:
|
|
|
|
return "bit9/bit10/bit17";
|
|
|
|
case I915_BIT_6_SWIZZLE_UNKNOWN:
|
2012-12-29 00:00:09 +07:00
|
|
|
return "unknown";
|
2011-12-14 19:57:16 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return "bug";
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_swizzle_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2011-12-14 19:57:16 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-08-09 20:07:02 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2011-12-14 19:57:16 +07:00
|
|
|
|
|
|
|
seq_printf(m, "bit6 swizzle for X-tiling = %s\n",
|
|
|
|
swizzle_string(dev_priv->mm.bit_6_swizzle_x));
|
|
|
|
seq_printf(m, "bit6 swizzle for Y-tiling = %s\n",
|
|
|
|
swizzle_string(dev_priv->mm.bit_6_swizzle_y));
|
|
|
|
|
|
|
|
if (IS_GEN3(dev) || IS_GEN4(dev)) {
|
|
|
|
seq_printf(m, "DDC = 0x%08x\n",
|
|
|
|
I915_READ(DCC));
|
2014-11-20 15:26:30 +07:00
|
|
|
seq_printf(m, "DDC2 = 0x%08x\n",
|
|
|
|
I915_READ(DCC2));
|
2011-12-14 19:57:16 +07:00
|
|
|
seq_printf(m, "C0DRB3 = 0x%04x\n",
|
|
|
|
I915_READ16(C0DRB3));
|
|
|
|
seq_printf(m, "C1DRB3 = 0x%04x\n",
|
|
|
|
I915_READ16(C1DRB3));
|
2013-11-03 11:07:14 +07:00
|
|
|
} else if (INTEL_INFO(dev)->gen >= 6) {
|
2012-01-31 22:47:56 +07:00
|
|
|
seq_printf(m, "MAD_DIMM_C0 = 0x%08x\n",
|
|
|
|
I915_READ(MAD_DIMM_C0));
|
|
|
|
seq_printf(m, "MAD_DIMM_C1 = 0x%08x\n",
|
|
|
|
I915_READ(MAD_DIMM_C1));
|
|
|
|
seq_printf(m, "MAD_DIMM_C2 = 0x%08x\n",
|
|
|
|
I915_READ(MAD_DIMM_C2));
|
|
|
|
seq_printf(m, "TILECTL = 0x%08x\n",
|
|
|
|
I915_READ(TILECTL));
|
2014-01-23 21:23:14 +07:00
|
|
|
if (INTEL_INFO(dev)->gen >= 8)
|
2013-11-03 11:07:14 +07:00
|
|
|
seq_printf(m, "GAMTARBMODE = 0x%08x\n",
|
|
|
|
I915_READ(GAMTARBMODE));
|
|
|
|
else
|
|
|
|
seq_printf(m, "ARB_MODE = 0x%08x\n",
|
|
|
|
I915_READ(ARB_MODE));
|
2012-01-31 22:47:56 +07:00
|
|
|
seq_printf(m, "DISP_ARB_CTL = 0x%08x\n",
|
|
|
|
I915_READ(DISP_ARB_CTL));
|
2011-12-14 19:57:16 +07:00
|
|
|
}
|
2014-11-20 15:26:30 +07:00
|
|
|
|
|
|
|
if (dev_priv->quirks & QUIRK_PIN_SWIZZLED_PAGES)
|
|
|
|
seq_puts(m, "L-shaped memory detected\n");
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2011-12-14 19:57:16 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-07 05:11:30 +07:00
|
|
|
static int per_file_ctx(int id, void *ptr, void *data)
|
|
|
|
{
|
2014-05-22 20:13:37 +07:00
|
|
|
struct intel_context *ctx = ptr;
|
2013-12-07 05:11:30 +07:00
|
|
|
struct seq_file *m = data;
|
2014-08-06 20:04:53 +07:00
|
|
|
struct i915_hw_ppgtt *ppgtt = ctx->ppgtt;
|
|
|
|
|
|
|
|
if (!ppgtt) {
|
|
|
|
seq_printf(m, " no ppgtt for context %d\n",
|
|
|
|
ctx->user_handle);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-07 05:11:30 +07:00
|
|
|
|
2014-05-22 20:13:38 +07:00
|
|
|
if (i915_gem_context_is_default(ctx))
|
|
|
|
seq_puts(m, " default context:\n");
|
|
|
|
else
|
drm/i915: Emphasize that ctx->id is merely a user handle
This is an Execlists preparatory patch, since they make context ID become an
overloaded term:
- In the software, it was used to distinguish which context userspace was
trying to use.
- In the BSpec, the term is used to describe the 20-bits long field the
hardware uses to it to discriminate the contexts that are submitted to
the ELSP and inform the driver about their current status (via Context
Switch Interrupts and Context Status Buffers).
Initially, I tried to make the different meanings converge, but it proved
impossible:
- The software ctx->id is per-filp, while the hardware one needs to be
globally unique.
- Also, we multiplex several backing states objects per intel_context,
and all of them need unique HW IDs.
- I tried adding a per-filp ID and then composing the HW context ID as:
ctx->id + file_priv->id + ring->id, but the fact that the hardware only
uses 20-bits means we have to artificially limit the number of filps or
contexts the userspace can create.
The ctx->user_handle renaming bits are done with this Cocci patch (plus
manual frobbing of the struct declaration):
@@
struct intel_context c;
@@
- (c).id
+ c.user_handle
@@
struct intel_context *c;
@@
- (c)->id
+ c->user_handle
Also, while we are at it, s/DEFAULT_CONTEXT_ID/DEFAULT_CONTEXT_HANDLE and
change the type to unsigned 32 bits.
v2: s/handle/user_handle and change the type to uint32_t as suggested by
Chris Wilson.
Reviewed-by: Jesse Barnes <jbarnes@virtuousgeek.org> (v1)
Signed-off-by: Oscar Mateo <oscar.mateo@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-07-03 22:28:00 +07:00
|
|
|
seq_printf(m, " context %d:\n", ctx->user_handle);
|
2013-12-07 05:11:30 +07:00
|
|
|
ppgtt->debug_dump(ppgtt, m);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-03 11:07:30 +07:00
|
|
|
static void gen8_ppgtt_info(struct seq_file *m, struct drm_device *dev)
|
2012-02-09 23:15:49 +07:00
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2013-11-03 11:07:30 +07:00
|
|
|
struct i915_hw_ppgtt *ppgtt = dev_priv->mm.aliasing_ppgtt;
|
|
|
|
int unused, i;
|
2012-02-09 23:15:49 +07:00
|
|
|
|
2013-11-03 11:07:30 +07:00
|
|
|
if (!ppgtt)
|
|
|
|
return;
|
|
|
|
|
|
|
|
seq_printf(m, "Page directories: %d\n", ppgtt->num_pd_pages);
|
2014-02-22 04:06:34 +07:00
|
|
|
seq_printf(m, "Page tables: %d\n", ppgtt->num_pd_entries);
|
2013-11-03 11:07:30 +07:00
|
|
|
for_each_ring(ring, dev_priv, unused) {
|
|
|
|
seq_printf(m, "%s\n", ring->name);
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
u32 offset = 0x270 + i * 8;
|
|
|
|
u64 pdp = I915_READ(ring->mmio_base + offset + 4);
|
|
|
|
pdp <<= 32;
|
|
|
|
pdp |= I915_READ(ring->mmio_base + offset);
|
2014-03-31 22:17:16 +07:00
|
|
|
seq_printf(m, "\tPDP%d 0x%016llx\n", i, pdp);
|
2013-11-03 11:07:30 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gen6_ppgtt_info(struct seq_file *m, struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *ring;
|
2013-12-07 05:11:30 +07:00
|
|
|
struct drm_file *file;
|
2013-11-03 11:07:30 +07:00
|
|
|
int i;
|
2012-02-09 23:15:49 +07:00
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen == 6)
|
|
|
|
seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(GFX_MODE));
|
|
|
|
|
2012-09-02 02:51:22 +07:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2012-02-09 23:15:49 +07:00
|
|
|
seq_printf(m, "%s\n", ring->name);
|
|
|
|
if (INTEL_INFO(dev)->gen == 7)
|
|
|
|
seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(RING_MODE_GEN7(ring)));
|
|
|
|
seq_printf(m, "PP_DIR_BASE: 0x%08x\n", I915_READ(RING_PP_DIR_BASE(ring)));
|
|
|
|
seq_printf(m, "PP_DIR_BASE_READ: 0x%08x\n", I915_READ(RING_PP_DIR_BASE_READ(ring)));
|
|
|
|
seq_printf(m, "PP_DIR_DCLV: 0x%08x\n", I915_READ(RING_PP_DIR_DCLV(ring)));
|
|
|
|
}
|
|
|
|
if (dev_priv->mm.aliasing_ppgtt) {
|
|
|
|
struct i915_hw_ppgtt *ppgtt = dev_priv->mm.aliasing_ppgtt;
|
|
|
|
|
2013-06-25 04:59:48 +07:00
|
|
|
seq_puts(m, "aliasing PPGTT:\n");
|
2015-02-24 23:22:35 +07:00
|
|
|
seq_printf(m, "pd gtt offset: 0x%08x\n", ppgtt->pd.pd_offset);
|
2013-12-07 05:11:30 +07:00
|
|
|
|
2013-12-07 05:11:29 +07:00
|
|
|
ppgtt->debug_dump(ppgtt, m);
|
2014-08-06 20:04:53 +07:00
|
|
|
}
|
2013-12-07 05:11:30 +07:00
|
|
|
|
|
|
|
list_for_each_entry_reverse(file, &dev->filelist, lhead) {
|
|
|
|
struct drm_i915_file_private *file_priv = file->driver_priv;
|
|
|
|
|
|
|
|
seq_printf(m, "proc: %s\n",
|
|
|
|
get_pid_task(file->pid, PIDTYPE_PID)->comm);
|
|
|
|
idr_for_each(&file_priv->context_idr, per_file_ctx, m);
|
2012-02-09 23:15:49 +07:00
|
|
|
}
|
|
|
|
seq_printf(m, "ECOCHK: 0x%08x\n", I915_READ(GAM_ECOCHK));
|
2013-11-03 11:07:30 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_ppgtt_info(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-11-03 11:07:30 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2013-11-28 03:21:54 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-03 11:07:30 +07:00
|
|
|
|
|
|
|
int ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2013-11-03 11:07:30 +07:00
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 8)
|
|
|
|
gen8_ppgtt_info(m, dev);
|
|
|
|
else if (INTEL_INFO(dev)->gen >= 6)
|
|
|
|
gen6_ppgtt_info(m, dev);
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2012-02-09 23:15:49 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-05 01:02:07 +07:00
|
|
|
static int i915_llc(struct seq_file *m, void *data)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-07-05 01:02:07 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
/* Size calculation for LLC is a bit of a pain. Ignore for now. */
|
|
|
|
seq_printf(m, "LLC: %s\n", yesno(HAS_LLC(dev)));
|
|
|
|
seq_printf(m, "eLLC: %zuMB\n", dev_priv->ellc_size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-12 04:44:59 +07:00
|
|
|
static int i915_edp_psr_status(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-10-04 02:15:06 +07:00
|
|
|
u32 psrperf = 0;
|
2014-11-14 23:52:40 +07:00
|
|
|
u32 stat[3];
|
|
|
|
enum pipe pipe;
|
2013-10-04 02:15:06 +07:00
|
|
|
bool enabled = false;
|
2013-07-12 04:44:59 +07:00
|
|
|
|
2015-03-09 21:17:58 +07:00
|
|
|
if (!HAS_PSR(dev)) {
|
|
|
|
seq_puts(m, "PSR not supported\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-07-12 00:30:17 +07:00
|
|
|
mutex_lock(&dev_priv->psr.lock);
|
2013-10-04 02:15:06 +07:00
|
|
|
seq_printf(m, "Sink_Support: %s\n", yesno(dev_priv->psr.sink_support));
|
|
|
|
seq_printf(m, "Source_OK: %s\n", yesno(dev_priv->psr.source_ok));
|
2014-07-12 00:30:11 +07:00
|
|
|
seq_printf(m, "Enabled: %s\n", yesno((bool)dev_priv->psr.enabled));
|
2014-06-13 00:16:45 +07:00
|
|
|
seq_printf(m, "Active: %s\n", yesno(dev_priv->psr.active));
|
2014-07-12 00:30:17 +07:00
|
|
|
seq_printf(m, "Busy frontbuffer bits: 0x%03x\n",
|
|
|
|
dev_priv->psr.busy_frontbuffer_bits);
|
|
|
|
seq_printf(m, "Re-enable work scheduled: %s\n",
|
|
|
|
yesno(work_busy(&dev_priv->psr.work.work)));
|
2013-07-12 04:44:59 +07:00
|
|
|
|
2015-03-09 21:17:58 +07:00
|
|
|
if (HAS_DDI(dev))
|
|
|
|
enabled = I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE;
|
|
|
|
else {
|
|
|
|
for_each_pipe(dev_priv, pipe) {
|
|
|
|
stat[pipe] = I915_READ(VLV_PSRSTAT(pipe)) &
|
|
|
|
VLV_EDP_PSR_CURR_STATE_MASK;
|
|
|
|
if ((stat[pipe] == VLV_EDP_PSR_ACTIVE_NORFB_UP) ||
|
|
|
|
(stat[pipe] == VLV_EDP_PSR_ACTIVE_SF_UPDATE))
|
|
|
|
enabled = true;
|
2014-11-14 23:52:40 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
seq_printf(m, "HW Enabled & Active bit: %s", yesno(enabled));
|
|
|
|
|
|
|
|
if (!HAS_DDI(dev))
|
|
|
|
for_each_pipe(dev_priv, pipe) {
|
|
|
|
if ((stat[pipe] == VLV_EDP_PSR_ACTIVE_NORFB_UP) ||
|
|
|
|
(stat[pipe] == VLV_EDP_PSR_ACTIVE_SF_UPDATE))
|
|
|
|
seq_printf(m, " pipe %c", pipe_name(pipe));
|
|
|
|
}
|
|
|
|
seq_puts(m, "\n");
|
2013-07-12 04:44:59 +07:00
|
|
|
|
2015-01-13 01:14:33 +07:00
|
|
|
seq_printf(m, "Link standby: %s\n",
|
|
|
|
yesno((bool)dev_priv->psr.link_standby));
|
|
|
|
|
2014-11-14 23:52:40 +07:00
|
|
|
/* CHV PSR has no kind of performance counter */
|
2015-03-09 21:17:58 +07:00
|
|
|
if (HAS_DDI(dev)) {
|
2013-10-04 02:15:06 +07:00
|
|
|
psrperf = I915_READ(EDP_PSR_PERF_CNT(dev)) &
|
|
|
|
EDP_PSR_PERF_CNT_MASK;
|
2014-11-14 23:52:40 +07:00
|
|
|
|
|
|
|
seq_printf(m, "Performance_Counter: %u\n", psrperf);
|
|
|
|
}
|
2014-07-12 00:30:17 +07:00
|
|
|
mutex_unlock(&dev_priv->psr.lock);
|
2013-07-12 04:44:59 +07:00
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2013-07-12 04:44:59 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-24 22:36:17 +07:00
|
|
|
static int i915_sink_crc(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct intel_encoder *encoder;
|
|
|
|
struct intel_connector *connector;
|
|
|
|
struct intel_dp *intel_dp = NULL;
|
|
|
|
int ret;
|
|
|
|
u8 crc[6];
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
2015-03-14 06:13:59 +07:00
|
|
|
for_each_intel_connector(dev, connector) {
|
2014-01-24 22:36:17 +07:00
|
|
|
|
|
|
|
if (connector->base.dpms != DRM_MODE_DPMS_ON)
|
|
|
|
continue;
|
|
|
|
|
2014-02-14 02:51:33 +07:00
|
|
|
if (!connector->base.encoder)
|
|
|
|
continue;
|
|
|
|
|
2014-01-24 22:36:17 +07:00
|
|
|
encoder = to_intel_encoder(connector->base.encoder);
|
|
|
|
if (encoder->type != INTEL_OUTPUT_EDP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
|
|
|
ret = intel_dp_sink_crc(intel_dp, crc);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
seq_printf(m, "%02x%02x%02x%02x%02x%02x\n",
|
|
|
|
crc[0], crc[1], crc[2],
|
|
|
|
crc[3], crc[4], crc[5]);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = -ENODEV;
|
|
|
|
out:
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-20 16:29:23 +07:00
|
|
|
static int i915_energy_uJ(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u64 power;
|
|
|
|
u32 units;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2013-08-20 16:29:23 +07:00
|
|
|
rdmsrl(MSR_RAPL_POWER_UNIT, power);
|
|
|
|
power = (power & 0x1f00) >> 8;
|
|
|
|
units = 1000000 / (1 << power); /* convert to uJ */
|
|
|
|
power = I915_READ(MCH_SECP_NRG_STTS);
|
|
|
|
power *= units;
|
|
|
|
|
2014-02-21 23:52:23 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2013-08-20 16:29:23 +07:00
|
|
|
seq_printf(m, "%llu", (long long unsigned)power);
|
2013-08-19 23:18:10 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_pc8_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-08-19 23:18:10 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2014-04-02 05:39:48 +07:00
|
|
|
if (!IS_HASWELL(dev) && !IS_BROADWELL(dev)) {
|
2013-08-19 23:18:10 +07:00
|
|
|
seq_puts(m, "not supported\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:52:24 +07:00
|
|
|
seq_printf(m, "GPU idle: %s\n", yesno(!dev_priv->mm.busy));
|
2013-08-19 23:18:10 +07:00
|
|
|
seq_printf(m, "IRQs disabled: %s\n",
|
2014-06-20 23:29:20 +07:00
|
|
|
yesno(!intel_irqs_enabled(dev_priv)));
|
2013-08-19 23:18:10 +07:00
|
|
|
|
2013-08-20 16:29:23 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-25 22:15:35 +07:00
|
|
|
static const char *power_domain_str(enum intel_display_power_domain domain)
|
|
|
|
{
|
|
|
|
switch (domain) {
|
|
|
|
case POWER_DOMAIN_PIPE_A:
|
|
|
|
return "PIPE_A";
|
|
|
|
case POWER_DOMAIN_PIPE_B:
|
|
|
|
return "PIPE_B";
|
|
|
|
case POWER_DOMAIN_PIPE_C:
|
|
|
|
return "PIPE_C";
|
|
|
|
case POWER_DOMAIN_PIPE_A_PANEL_FITTER:
|
|
|
|
return "PIPE_A_PANEL_FITTER";
|
|
|
|
case POWER_DOMAIN_PIPE_B_PANEL_FITTER:
|
|
|
|
return "PIPE_B_PANEL_FITTER";
|
|
|
|
case POWER_DOMAIN_PIPE_C_PANEL_FITTER:
|
|
|
|
return "PIPE_C_PANEL_FITTER";
|
|
|
|
case POWER_DOMAIN_TRANSCODER_A:
|
|
|
|
return "TRANSCODER_A";
|
|
|
|
case POWER_DOMAIN_TRANSCODER_B:
|
|
|
|
return "TRANSCODER_B";
|
|
|
|
case POWER_DOMAIN_TRANSCODER_C:
|
|
|
|
return "TRANSCODER_C";
|
|
|
|
case POWER_DOMAIN_TRANSCODER_EDP:
|
|
|
|
return "TRANSCODER_EDP";
|
2014-03-05 00:22:57 +07:00
|
|
|
case POWER_DOMAIN_PORT_DDI_A_2_LANES:
|
|
|
|
return "PORT_DDI_A_2_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_A_4_LANES:
|
|
|
|
return "PORT_DDI_A_4_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_B_2_LANES:
|
|
|
|
return "PORT_DDI_B_2_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_B_4_LANES:
|
|
|
|
return "PORT_DDI_B_4_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_C_2_LANES:
|
|
|
|
return "PORT_DDI_C_2_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_C_4_LANES:
|
|
|
|
return "PORT_DDI_C_4_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_D_2_LANES:
|
|
|
|
return "PORT_DDI_D_2_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DDI_D_4_LANES:
|
|
|
|
return "PORT_DDI_D_4_LANES";
|
|
|
|
case POWER_DOMAIN_PORT_DSI:
|
|
|
|
return "PORT_DSI";
|
|
|
|
case POWER_DOMAIN_PORT_CRT:
|
|
|
|
return "PORT_CRT";
|
|
|
|
case POWER_DOMAIN_PORT_OTHER:
|
|
|
|
return "PORT_OTHER";
|
2013-11-25 22:15:35 +07:00
|
|
|
case POWER_DOMAIN_VGA:
|
|
|
|
return "VGA";
|
|
|
|
case POWER_DOMAIN_AUDIO:
|
|
|
|
return "AUDIO";
|
2014-07-04 21:27:38 +07:00
|
|
|
case POWER_DOMAIN_PLLS:
|
|
|
|
return "PLLS";
|
2015-01-16 22:57:51 +07:00
|
|
|
case POWER_DOMAIN_AUX_A:
|
|
|
|
return "AUX_A";
|
|
|
|
case POWER_DOMAIN_AUX_B:
|
|
|
|
return "AUX_B";
|
|
|
|
case POWER_DOMAIN_AUX_C:
|
|
|
|
return "AUX_C";
|
|
|
|
case POWER_DOMAIN_AUX_D:
|
|
|
|
return "AUX_D";
|
2013-11-25 22:15:35 +07:00
|
|
|
case POWER_DOMAIN_INIT:
|
|
|
|
return "INIT";
|
|
|
|
default:
|
2014-12-08 22:40:10 +07:00
|
|
|
MISSING_CASE(domain);
|
2013-11-25 22:15:35 +07:00
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_power_domain_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2013-11-25 22:15:35 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct i915_power_domains *power_domains = &dev_priv->power_domains;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&power_domains->lock);
|
|
|
|
|
|
|
|
seq_printf(m, "%-25s %s\n", "Power well/domain", "Use count");
|
|
|
|
for (i = 0; i < power_domains->power_well_count; i++) {
|
|
|
|
struct i915_power_well *power_well;
|
|
|
|
enum intel_display_power_domain power_domain;
|
|
|
|
|
|
|
|
power_well = &power_domains->power_wells[i];
|
|
|
|
seq_printf(m, "%-25s %d\n", power_well->name,
|
|
|
|
power_well->count);
|
|
|
|
|
|
|
|
for (power_domain = 0; power_domain < POWER_DOMAIN_NUM;
|
|
|
|
power_domain++) {
|
|
|
|
if (!(BIT(power_domain) & power_well->domains))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
seq_printf(m, " %-23s %d\n",
|
|
|
|
power_domain_str(power_domain),
|
|
|
|
power_domains->domain_use_count[power_domain]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&power_domains->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-08 03:48:15 +07:00
|
|
|
static void intel_seq_print_mode(struct seq_file *m, int tabs,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < tabs; i++)
|
|
|
|
seq_putc(m, '\t');
|
|
|
|
|
|
|
|
seq_printf(m, "id %d:\"%s\" freq %d clock %d hdisp %d hss %d hse %d htot %d vdisp %d vss %d vse %d vtot %d type 0x%x flags 0x%x\n",
|
|
|
|
mode->base.id, mode->name,
|
|
|
|
mode->vrefresh, mode->clock,
|
|
|
|
mode->hdisplay, mode->hsync_start,
|
|
|
|
mode->hsync_end, mode->htotal,
|
|
|
|
mode->vdisplay, mode->vsync_start,
|
|
|
|
mode->vsync_end, mode->vtotal,
|
|
|
|
mode->type, mode->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_encoder_info(struct seq_file *m,
|
|
|
|
struct intel_crtc *intel_crtc,
|
|
|
|
struct intel_encoder *intel_encoder)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2014-02-08 03:48:15 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_crtc *crtc = &intel_crtc->base;
|
|
|
|
struct intel_connector *intel_connector;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
|
|
|
encoder = &intel_encoder->base;
|
|
|
|
seq_printf(m, "\tencoder %d: type: %s, connectors:\n",
|
2014-06-03 18:56:21 +07:00
|
|
|
encoder->base.id, encoder->name);
|
2014-02-08 03:48:15 +07:00
|
|
|
for_each_connector_on_encoder(dev, encoder, intel_connector) {
|
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
|
|
|
seq_printf(m, "\t\tconnector %d: type: %s, status: %s",
|
|
|
|
connector->base.id,
|
2014-06-03 18:56:17 +07:00
|
|
|
connector->name,
|
2014-02-08 03:48:15 +07:00
|
|
|
drm_get_connector_status_name(connector->status));
|
|
|
|
if (connector->status == connector_status_connected) {
|
|
|
|
struct drm_display_mode *mode = &crtc->mode;
|
|
|
|
seq_printf(m, ", mode:\n");
|
|
|
|
intel_seq_print_mode(m, 2, mode);
|
|
|
|
} else {
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_crtc_info(struct seq_file *m, struct intel_crtc *intel_crtc)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2014-02-08 03:48:15 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_crtc *crtc = &intel_crtc->base;
|
|
|
|
struct intel_encoder *intel_encoder;
|
|
|
|
|
2014-06-17 00:12:55 +07:00
|
|
|
if (crtc->primary->fb)
|
|
|
|
seq_printf(m, "\tfb: %d, pos: %dx%d, size: %dx%d\n",
|
|
|
|
crtc->primary->fb->base.id, crtc->x, crtc->y,
|
|
|
|
crtc->primary->fb->width, crtc->primary->fb->height);
|
|
|
|
else
|
|
|
|
seq_puts(m, "\tprimary plane disabled\n");
|
2014-02-08 03:48:15 +07:00
|
|
|
for_each_encoder_on_crtc(dev, crtc, intel_encoder)
|
|
|
|
intel_encoder_info(m, intel_crtc, intel_encoder);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_panel_info(struct seq_file *m, struct intel_panel *panel)
|
|
|
|
{
|
|
|
|
struct drm_display_mode *mode = panel->fixed_mode;
|
|
|
|
|
|
|
|
seq_printf(m, "\tfixed mode:\n");
|
|
|
|
intel_seq_print_mode(m, 2, mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_dp_info(struct seq_file *m,
|
|
|
|
struct intel_connector *intel_connector)
|
|
|
|
{
|
|
|
|
struct intel_encoder *intel_encoder = intel_connector->encoder;
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
|
|
|
|
|
|
|
|
seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
|
|
|
|
seq_printf(m, "\taudio support: %s\n", intel_dp->has_audio ? "yes" :
|
|
|
|
"no");
|
|
|
|
if (intel_encoder->type == INTEL_OUTPUT_EDP)
|
|
|
|
intel_panel_info(m, &intel_connector->panel);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_hdmi_info(struct seq_file *m,
|
|
|
|
struct intel_connector *intel_connector)
|
|
|
|
{
|
|
|
|
struct intel_encoder *intel_encoder = intel_connector->encoder;
|
|
|
|
struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&intel_encoder->base);
|
|
|
|
|
|
|
|
seq_printf(m, "\taudio support: %s\n", intel_hdmi->has_audio ? "yes" :
|
|
|
|
"no");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_lvds_info(struct seq_file *m,
|
|
|
|
struct intel_connector *intel_connector)
|
|
|
|
{
|
|
|
|
intel_panel_info(m, &intel_connector->panel);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_connector_info(struct seq_file *m,
|
|
|
|
struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
|
|
|
struct intel_encoder *intel_encoder = intel_connector->encoder;
|
2014-02-21 03:39:57 +07:00
|
|
|
struct drm_display_mode *mode;
|
2014-02-08 03:48:15 +07:00
|
|
|
|
|
|
|
seq_printf(m, "connector %d: type %s, status: %s\n",
|
2014-06-03 18:56:17 +07:00
|
|
|
connector->base.id, connector->name,
|
2014-02-08 03:48:15 +07:00
|
|
|
drm_get_connector_status_name(connector->status));
|
|
|
|
if (connector->status == connector_status_connected) {
|
|
|
|
seq_printf(m, "\tname: %s\n", connector->display_info.name);
|
|
|
|
seq_printf(m, "\tphysical dimensions: %dx%dmm\n",
|
|
|
|
connector->display_info.width_mm,
|
|
|
|
connector->display_info.height_mm);
|
|
|
|
seq_printf(m, "\tsubpixel order: %s\n",
|
|
|
|
drm_get_subpixel_order_name(connector->display_info.subpixel_order));
|
|
|
|
seq_printf(m, "\tCEA rev: %d\n",
|
|
|
|
connector->display_info.cea_rev);
|
|
|
|
}
|
2014-05-02 10:44:18 +07:00
|
|
|
if (intel_encoder) {
|
|
|
|
if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
|
|
|
|
intel_encoder->type == INTEL_OUTPUT_EDP)
|
|
|
|
intel_dp_info(m, intel_connector);
|
|
|
|
else if (intel_encoder->type == INTEL_OUTPUT_HDMI)
|
|
|
|
intel_hdmi_info(m, intel_connector);
|
|
|
|
else if (intel_encoder->type == INTEL_OUTPUT_LVDS)
|
|
|
|
intel_lvds_info(m, intel_connector);
|
|
|
|
}
|
2014-02-08 03:48:15 +07:00
|
|
|
|
2014-02-21 03:39:57 +07:00
|
|
|
seq_printf(m, "\tmodes:\n");
|
|
|
|
list_for_each_entry(mode, &connector->modes, head)
|
|
|
|
intel_seq_print_mode(m, 2, mode);
|
2014-02-08 03:48:15 +07:00
|
|
|
}
|
|
|
|
|
2014-03-12 16:13:13 +07:00
|
|
|
static bool cursor_active(struct drm_device *dev, int pipe)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 state;
|
|
|
|
|
|
|
|
if (IS_845G(dev) || IS_I865G(dev))
|
|
|
|
state = I915_READ(_CURACNTR) & CURSOR_ENABLE;
|
|
|
|
else
|
2014-04-09 17:28:53 +07:00
|
|
|
state = I915_READ(CURCNTR(pipe)) & CURSOR_MODE;
|
2014-03-12 16:13:13 +07:00
|
|
|
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cursor_position(struct drm_device *dev, int pipe, int *x, int *y)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 pos;
|
|
|
|
|
2014-04-09 17:28:53 +07:00
|
|
|
pos = I915_READ(CURPOS(pipe));
|
2014-03-12 16:13:13 +07:00
|
|
|
|
|
|
|
*x = (pos >> CURSOR_X_SHIFT) & CURSOR_POS_MASK;
|
|
|
|
if (pos & (CURSOR_POS_SIGN << CURSOR_X_SHIFT))
|
|
|
|
*x = -*x;
|
|
|
|
|
|
|
|
*y = (pos >> CURSOR_Y_SHIFT) & CURSOR_POS_MASK;
|
|
|
|
if (pos & (CURSOR_POS_SIGN << CURSOR_Y_SHIFT))
|
|
|
|
*y = -*y;
|
|
|
|
|
|
|
|
return cursor_active(dev, pipe);
|
|
|
|
}
|
|
|
|
|
2014-02-08 03:48:15 +07:00
|
|
|
static int i915_display_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
2014-05-13 21:30:28 +07:00
|
|
|
struct drm_info_node *node = m->private;
|
2014-02-08 03:48:15 +07:00
|
|
|
struct drm_device *dev = node->minor->dev;
|
2014-04-02 00:55:10 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2014-03-12 16:13:13 +07:00
|
|
|
struct intel_crtc *crtc;
|
2014-02-08 03:48:15 +07:00
|
|
|
struct drm_connector *connector;
|
|
|
|
|
2014-04-02 00:55:10 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2014-02-08 03:48:15 +07:00
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
seq_printf(m, "CRTC info\n");
|
|
|
|
seq_printf(m, "---------\n");
|
2014-05-14 05:32:22 +07:00
|
|
|
for_each_intel_crtc(dev, crtc) {
|
2014-03-12 16:13:13 +07:00
|
|
|
bool active;
|
|
|
|
int x, y;
|
2014-02-08 03:48:15 +07:00
|
|
|
|
2014-07-04 14:20:11 +07:00
|
|
|
seq_printf(m, "CRTC %d: pipe: %c, active=%s (size=%dx%d)\n",
|
2014-03-12 16:13:13 +07:00
|
|
|
crtc->base.base.id, pipe_name(crtc->pipe),
|
2015-01-15 19:55:25 +07:00
|
|
|
yesno(crtc->active), crtc->config->pipe_src_w,
|
|
|
|
crtc->config->pipe_src_h);
|
2014-04-02 00:55:11 +07:00
|
|
|
if (crtc->active) {
|
2014-03-12 16:13:13 +07:00
|
|
|
intel_crtc_info(m, crtc);
|
|
|
|
|
2014-04-02 00:55:11 +07:00
|
|
|
active = cursor_position(dev, crtc->pipe, &x, &y);
|
2014-07-04 14:20:11 +07:00
|
|
|
seq_printf(m, "\tcursor visible? %s, position (%d, %d), size %dx%d, addr 0x%08x, active? %s\n",
|
2014-05-30 20:35:26 +07:00
|
|
|
yesno(crtc->cursor_base),
|
2015-02-28 01:12:00 +07:00
|
|
|
x, y, crtc->base.cursor->state->crtc_w,
|
|
|
|
crtc->base.cursor->state->crtc_h,
|
2014-07-04 14:20:11 +07:00
|
|
|
crtc->cursor_addr, yesno(active));
|
2014-04-02 00:55:11 +07:00
|
|
|
}
|
2014-05-22 22:56:31 +07:00
|
|
|
|
|
|
|
seq_printf(m, "\tunderrun reporting: cpu=%s pch=%s \n",
|
|
|
|
yesno(!crtc->cpu_fifo_underrun_disabled),
|
|
|
|
yesno(!crtc->pch_fifo_underrun_disabled));
|
2014-02-08 03:48:15 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
seq_printf(m, "Connector info\n");
|
|
|
|
seq_printf(m, "--------------\n");
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
intel_connector_info(m, connector);
|
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
2014-04-02 00:55:10 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2014-02-08 03:48:15 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-30 23:53:42 +07:00
|
|
|
static int i915_semaphore_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_engine_cs *ring;
|
|
|
|
int num_rings = hweight32(INTEL_INFO(dev)->ring_mask);
|
|
|
|
int i, j, ret;
|
|
|
|
|
|
|
|
if (!i915_semaphore_is_enabled(dev)) {
|
|
|
|
seq_puts(m, "Semaphores are disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-07-10 00:31:57 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2014-06-30 23:53:42 +07:00
|
|
|
|
|
|
|
if (IS_BROADWELL(dev)) {
|
|
|
|
struct page *page;
|
|
|
|
uint64_t *seqno;
|
|
|
|
|
|
|
|
page = i915_gem_object_get_page(dev_priv->semaphore_obj, 0);
|
|
|
|
|
|
|
|
seqno = (uint64_t *)kmap_atomic(page);
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
uint64_t offset;
|
|
|
|
|
|
|
|
seq_printf(m, "%s\n", ring->name);
|
|
|
|
|
|
|
|
seq_puts(m, " Last signal:");
|
|
|
|
for (j = 0; j < num_rings; j++) {
|
|
|
|
offset = i * I915_NUM_RINGS + j;
|
|
|
|
seq_printf(m, "0x%08llx (0x%02llx) ",
|
|
|
|
seqno[offset], offset * 8);
|
|
|
|
}
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
|
|
|
|
seq_puts(m, " Last wait: ");
|
|
|
|
for (j = 0; j < num_rings; j++) {
|
|
|
|
offset = i + (j * I915_NUM_RINGS);
|
|
|
|
seq_printf(m, "0x%08llx (0x%02llx) ",
|
|
|
|
seqno[offset], offset * 8);
|
|
|
|
}
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
|
|
|
|
}
|
|
|
|
kunmap_atomic(seqno);
|
|
|
|
} else {
|
|
|
|
seq_puts(m, " Last signal:");
|
|
|
|
for_each_ring(ring, dev_priv, i)
|
|
|
|
for (j = 0; j < num_rings; j++)
|
|
|
|
seq_printf(m, "0x%08x\n",
|
|
|
|
I915_READ(ring->semaphore.mbox.signal[j]));
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_puts(m, "\nSync seqno:\n");
|
|
|
|
for_each_ring(ring, dev_priv, i) {
|
|
|
|
for (j = 0; j < num_rings; j++) {
|
|
|
|
seq_printf(m, " 0x%08x ", ring->semaphore.sync_seqno[j]);
|
|
|
|
}
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
}
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
|
2014-07-10 00:31:57 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2014-06-30 23:53:42 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-26 02:01:53 +07:00
|
|
|
static int i915_shared_dplls_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
for (i = 0; i < dev_priv->num_shared_dpll; i++) {
|
|
|
|
struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i];
|
|
|
|
|
|
|
|
seq_printf(m, "DPLL%i: %s, id: %i\n", i, pll->name, pll->id);
|
2014-10-29 16:32:31 +07:00
|
|
|
seq_printf(m, " crtc_mask: 0x%08x, active: %d, on: %s\n",
|
2014-10-29 16:32:32 +07:00
|
|
|
pll->config.crtc_mask, pll->active, yesno(pll->on));
|
2014-06-26 02:01:53 +07:00
|
|
|
seq_printf(m, " tracked hardware state:\n");
|
2014-10-29 16:32:32 +07:00
|
|
|
seq_printf(m, " dpll: 0x%08x\n", pll->config.hw_state.dpll);
|
|
|
|
seq_printf(m, " dpll_md: 0x%08x\n",
|
|
|
|
pll->config.hw_state.dpll_md);
|
|
|
|
seq_printf(m, " fp0: 0x%08x\n", pll->config.hw_state.fp0);
|
|
|
|
seq_printf(m, " fp1: 0x%08x\n", pll->config.hw_state.fp1);
|
|
|
|
seq_printf(m, " wrpll: 0x%08x\n", pll->config.hw_state.wrpll);
|
2014-06-26 02:01:53 +07:00
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-30 22:50:59 +07:00
|
|
|
static int i915_wa_registers(struct seq_file *m, void *unused)
|
2014-08-26 20:44:51 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-10-07 21:21:26 +07:00
|
|
|
seq_printf(m, "Workarounds applied: %d\n", dev_priv->workarounds.count);
|
|
|
|
for (i = 0; i < dev_priv->workarounds.count; ++i) {
|
2014-10-07 21:21:27 +07:00
|
|
|
u32 addr, mask, value, read;
|
|
|
|
bool ok;
|
2014-08-26 20:44:51 +07:00
|
|
|
|
2014-10-07 21:21:26 +07:00
|
|
|
addr = dev_priv->workarounds.reg[i].addr;
|
|
|
|
mask = dev_priv->workarounds.reg[i].mask;
|
2014-10-07 21:21:27 +07:00
|
|
|
value = dev_priv->workarounds.reg[i].value;
|
|
|
|
read = I915_READ(addr);
|
|
|
|
ok = (value & mask) == (read & mask);
|
|
|
|
seq_printf(m, "0x%X: 0x%08X, mask: 0x%08X, read: 0x%08x, status: %s\n",
|
|
|
|
addr, value, mask, read, ok ? "OK" : "FAIL");
|
2014-08-26 20:44:51 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-05 00:06:51 +07:00
|
|
|
static int i915_ddb_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct skl_ddb_allocation *ddb;
|
|
|
|
struct skl_ddb_entry *entry;
|
|
|
|
enum pipe pipe;
|
|
|
|
int plane;
|
|
|
|
|
2014-12-04 00:33:24 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 9)
|
|
|
|
return 0;
|
|
|
|
|
2014-11-05 00:06:51 +07:00
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
|
|
|
ddb = &dev_priv->wm.skl_hw.ddb;
|
|
|
|
|
|
|
|
seq_printf(m, "%-15s%8s%8s%8s\n", "", "Start", "End", "Size");
|
|
|
|
|
|
|
|
for_each_pipe(dev_priv, pipe) {
|
|
|
|
seq_printf(m, "Pipe %c\n", pipe_name(pipe));
|
|
|
|
|
2015-02-28 21:54:08 +07:00
|
|
|
for_each_plane(dev_priv, pipe, plane) {
|
2014-11-05 00:06:51 +07:00
|
|
|
entry = &ddb->plane[pipe][plane];
|
|
|
|
seq_printf(m, " Plane%-8d%8u%8u%8u\n", plane + 1,
|
|
|
|
entry->start, entry->end,
|
|
|
|
skl_ddb_entry_size(entry));
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = &ddb->cursor[pipe];
|
|
|
|
seq_printf(m, " %-13s%8u%8u%8u\n", "Cursor", entry->start,
|
|
|
|
entry->end, skl_ddb_entry_size(entry));
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm/i915: Add debugfs entry for DRRS
Adding a debugfs entry to determine if DRRS is supported or not
V2: [By Ram]: Following details about the active crtc will be filled
in seq-file of the debugfs
1. Encoder output type
2. DRRS Support on this CRTC
3. DRRS current state
4. Current Vrefresh
Format is as follows:
CRTC 1: Output: eDP, DRRS Supported: Yes (Seamless), DRRS_State: DRRS_HIGH_RR, Vrefresh: 60
CRTC 2: Output: HDMI, DRRS Supported : No, VBT DRRS_type: Seamless
CRTC 1: Output: eDP, DRRS Supported: Yes (Seamless), DRRS_State: DRRS_LOW_RR, Vrefresh: 40
CRTC 2: Output: HDMI, DRRS Supported : No, VBT DRRS_type: Seamless
V3: [By Ram]: Readability is improved.
Another error case is covered [Daniel]
V4: [By Ram]: Current status of the Idleness DRRS along with
the Front buffer bits are added to the debugfs. [Rodrigo]
V5: [By Ram]: Rephrased to make it easy to understand.
And format is modified. [Rodrigo]
V6: [By Ram]: Modeset mutex are acquired for each crtc along with
renaming the Idleness detection states [Daniel]
Signed-off-by: Vandana Kannan <vandana.kannan@intel.com>
Signed-off-by: Ramalingam C <ramalingam.c@intel.com>
Reviewed-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
[danvet: dump full busy_frontbuffer_bits and remove the dubios
computed logical state of DRRS - debugfs is about what is fact,
developers should reach their own conclusion when debugging issues.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-03-03 22:23:10 +07:00
|
|
|
static void drrs_status_per_crtc(struct seq_file *m,
|
|
|
|
struct drm_device *dev, struct intel_crtc *intel_crtc)
|
|
|
|
{
|
|
|
|
struct intel_encoder *intel_encoder;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct i915_drrs *drrs = &dev_priv->drrs;
|
|
|
|
int vrefresh = 0;
|
|
|
|
|
|
|
|
for_each_encoder_on_crtc(dev, &intel_crtc->base, intel_encoder) {
|
|
|
|
/* Encoder connected on this CRTC */
|
|
|
|
switch (intel_encoder->type) {
|
|
|
|
case INTEL_OUTPUT_EDP:
|
|
|
|
seq_puts(m, "eDP:\n");
|
|
|
|
break;
|
|
|
|
case INTEL_OUTPUT_DSI:
|
|
|
|
seq_puts(m, "DSI:\n");
|
|
|
|
break;
|
|
|
|
case INTEL_OUTPUT_HDMI:
|
|
|
|
seq_puts(m, "HDMI:\n");
|
|
|
|
break;
|
|
|
|
case INTEL_OUTPUT_DISPLAYPORT:
|
|
|
|
seq_puts(m, "DP:\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
seq_printf(m, "Other encoder (id=%d).\n",
|
|
|
|
intel_encoder->type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_priv->vbt.drrs_type == STATIC_DRRS_SUPPORT)
|
|
|
|
seq_puts(m, "\tVBT: DRRS_type: Static");
|
|
|
|
else if (dev_priv->vbt.drrs_type == SEAMLESS_DRRS_SUPPORT)
|
|
|
|
seq_puts(m, "\tVBT: DRRS_type: Seamless");
|
|
|
|
else if (dev_priv->vbt.drrs_type == DRRS_NOT_SUPPORTED)
|
|
|
|
seq_puts(m, "\tVBT: DRRS_type: None");
|
|
|
|
else
|
|
|
|
seq_puts(m, "\tVBT: DRRS_type: FIXME: Unrecognized Value");
|
|
|
|
|
|
|
|
seq_puts(m, "\n\n");
|
|
|
|
|
|
|
|
if (intel_crtc->config->has_drrs) {
|
|
|
|
struct intel_panel *panel;
|
|
|
|
|
|
|
|
mutex_lock(&drrs->mutex);
|
|
|
|
/* DRRS Supported */
|
|
|
|
seq_puts(m, "\tDRRS Supported: Yes\n");
|
|
|
|
|
|
|
|
/* disable_drrs() will make drrs->dp NULL */
|
|
|
|
if (!drrs->dp) {
|
|
|
|
seq_puts(m, "Idleness DRRS: Disabled");
|
|
|
|
mutex_unlock(&drrs->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
panel = &drrs->dp->attached_connector->panel;
|
|
|
|
seq_printf(m, "\t\tBusy_frontbuffer_bits: 0x%X",
|
|
|
|
drrs->busy_frontbuffer_bits);
|
|
|
|
|
|
|
|
seq_puts(m, "\n\t\t");
|
|
|
|
if (drrs->refresh_rate_type == DRRS_HIGH_RR) {
|
|
|
|
seq_puts(m, "DRRS_State: DRRS_HIGH_RR\n");
|
|
|
|
vrefresh = panel->fixed_mode->vrefresh;
|
|
|
|
} else if (drrs->refresh_rate_type == DRRS_LOW_RR) {
|
|
|
|
seq_puts(m, "DRRS_State: DRRS_LOW_RR\n");
|
|
|
|
vrefresh = panel->downclock_mode->vrefresh;
|
|
|
|
} else {
|
|
|
|
seq_printf(m, "DRRS_State: Unknown(%d)\n",
|
|
|
|
drrs->refresh_rate_type);
|
|
|
|
mutex_unlock(&drrs->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
seq_printf(m, "\t\tVrefresh: %d", vrefresh);
|
|
|
|
|
|
|
|
seq_puts(m, "\n\t\t");
|
|
|
|
mutex_unlock(&drrs->mutex);
|
|
|
|
} else {
|
|
|
|
/* DRRS not supported. Print the VBT parameter*/
|
|
|
|
seq_puts(m, "\tDRRS Supported : No");
|
|
|
|
}
|
|
|
|
seq_puts(m, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_drrs_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct intel_crtc *intel_crtc;
|
|
|
|
int active_crtc_cnt = 0;
|
|
|
|
|
|
|
|
for_each_intel_crtc(dev, intel_crtc) {
|
|
|
|
drm_modeset_lock(&intel_crtc->base.mutex, NULL);
|
|
|
|
|
|
|
|
if (intel_crtc->active) {
|
|
|
|
active_crtc_cnt++;
|
|
|
|
seq_printf(m, "\nCRTC %d: ", active_crtc_cnt);
|
|
|
|
|
|
|
|
drrs_status_per_crtc(m, dev, intel_crtc);
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_modeset_unlock(&intel_crtc->base.mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!active_crtc_cnt)
|
|
|
|
seq_puts(m, "No active crtc found\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
struct pipe_crc_info {
|
|
|
|
const char *name;
|
|
|
|
struct drm_device *dev;
|
|
|
|
enum pipe pipe;
|
|
|
|
};
|
|
|
|
|
2014-05-12 12:22:27 +07:00
|
|
|
static int i915_dp_mst_info(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct intel_encoder *intel_encoder;
|
|
|
|
struct intel_digital_port *intel_dig_port;
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
|
|
|
|
intel_encoder = to_intel_encoder(encoder);
|
|
|
|
if (intel_encoder->type != INTEL_OUTPUT_DISPLAYPORT)
|
|
|
|
continue;
|
|
|
|
intel_dig_port = enc_to_dig_port(encoder);
|
|
|
|
if (!intel_dig_port->dp.can_mst)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
drm_dp_mst_dump_topology(m, &intel_dig_port->dp.mst_mgr);
|
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
static int i915_pipe_crc_open(struct inode *inode, struct file *filep)
|
|
|
|
{
|
2013-10-16 00:55:41 +07:00
|
|
|
struct pipe_crc_info *info = inode->i_private;
|
|
|
|
struct drm_i915_private *dev_priv = info->dev->dev_private;
|
|
|
|
struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
|
|
|
|
|
2013-11-14 17:30:43 +07:00
|
|
|
if (info->pipe >= INTEL_INFO(info->dev)->num_pipes)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
|
|
|
|
|
|
|
if (pipe_crc->opened) {
|
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
2013-10-16 00:55:41 +07:00
|
|
|
return -EBUSY; /* already open */
|
|
|
|
}
|
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
pipe_crc->opened = true;
|
2013-10-16 00:55:40 +07:00
|
|
|
filep->private_data = inode->i_private;
|
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i915_pipe_crc_release(struct inode *inode, struct file *filep)
|
|
|
|
{
|
2013-10-16 00:55:41 +07:00
|
|
|
struct pipe_crc_info *info = inode->i_private;
|
|
|
|
struct drm_i915_private *dev_priv = info->dev->dev_private;
|
|
|
|
struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
|
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
|
|
|
pipe_crc->opened = false;
|
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
2013-10-16 00:55:41 +07:00
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* (6 fields, 8 chars each, space separated (5) + '\n') */
|
|
|
|
#define PIPE_CRC_LINE_LEN (6 * 8 + 5 + 1)
|
|
|
|
/* account for \'0' */
|
|
|
|
#define PIPE_CRC_BUFFER_LEN (PIPE_CRC_LINE_LEN + 1)
|
|
|
|
|
|
|
|
static int pipe_crc_data_count(struct intel_pipe_crc *pipe_crc)
|
2013-10-16 00:55:27 +07:00
|
|
|
{
|
2013-10-21 20:29:30 +07:00
|
|
|
assert_spin_locked(&pipe_crc->lock);
|
|
|
|
return CIRC_CNT(pipe_crc->head, pipe_crc->tail,
|
|
|
|
INTEL_PIPE_CRC_ENTRIES_NR);
|
2013-10-16 00:55:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
i915_pipe_crc_read(struct file *filep, char __user *user_buf, size_t count,
|
|
|
|
loff_t *pos)
|
|
|
|
{
|
|
|
|
struct pipe_crc_info *info = filep->private_data;
|
|
|
|
struct drm_device *dev = info->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
|
|
|
|
char buf[PIPE_CRC_BUFFER_LEN];
|
2014-12-10 02:28:32 +07:00
|
|
|
int n_entries;
|
2013-10-16 00:55:40 +07:00
|
|
|
ssize_t bytes_read;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow user space to provide buffers not big enough to hold
|
|
|
|
* a line of data.
|
|
|
|
*/
|
|
|
|
if (count < PIPE_CRC_LINE_LEN)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (pipe_crc->source == INTEL_PIPE_CRC_SOURCE_NONE)
|
2013-10-16 00:55:27 +07:00
|
|
|
return 0;
|
2013-10-16 00:55:40 +07:00
|
|
|
|
|
|
|
/* nothing to read */
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
2013-10-16 00:55:40 +07:00
|
|
|
while (pipe_crc_data_count(pipe_crc) == 0) {
|
2013-10-21 20:29:30 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (filep->f_flags & O_NONBLOCK) {
|
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
2013-10-16 00:55:40 +07:00
|
|
|
return -EAGAIN;
|
2013-10-21 20:29:30 +07:00
|
|
|
}
|
2013-10-16 00:55:40 +07:00
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
ret = wait_event_interruptible_lock_irq(pipe_crc->wq,
|
|
|
|
pipe_crc_data_count(pipe_crc), pipe_crc->lock);
|
|
|
|
if (ret) {
|
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2013-10-16 00:55:27 +07:00
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
/* We now have one or more entries to read */
|
2014-12-10 02:28:32 +07:00
|
|
|
n_entries = count / PIPE_CRC_LINE_LEN;
|
2013-10-21 20:29:30 +07:00
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
bytes_read = 0;
|
2014-12-10 02:28:32 +07:00
|
|
|
while (n_entries > 0) {
|
|
|
|
struct intel_pipe_crc_entry *entry =
|
|
|
|
&pipe_crc->entries[pipe_crc->tail];
|
2013-10-16 00:55:40 +07:00
|
|
|
int ret;
|
2013-10-16 00:55:27 +07:00
|
|
|
|
2014-12-10 02:28:32 +07:00
|
|
|
if (CIRC_CNT(pipe_crc->head, pipe_crc->tail,
|
|
|
|
INTEL_PIPE_CRC_ENTRIES_NR) < 1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
BUILD_BUG_ON_NOT_POWER_OF_2(INTEL_PIPE_CRC_ENTRIES_NR);
|
|
|
|
pipe_crc->tail = (pipe_crc->tail + 1) & (INTEL_PIPE_CRC_ENTRIES_NR - 1);
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
bytes_read += snprintf(buf, PIPE_CRC_BUFFER_LEN,
|
|
|
|
"%8u %8x %8x %8x %8x %8x\n",
|
|
|
|
entry->frame, entry->crc[0],
|
|
|
|
entry->crc[1], entry->crc[2],
|
|
|
|
entry->crc[3], entry->crc[4]);
|
|
|
|
|
2014-12-10 02:28:32 +07:00
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
|
|
|
|
|
|
|
ret = copy_to_user(user_buf, buf, PIPE_CRC_LINE_LEN);
|
2013-10-16 00:55:40 +07:00
|
|
|
if (ret == PIPE_CRC_LINE_LEN)
|
|
|
|
return -EFAULT;
|
2013-10-16 00:55:29 +07:00
|
|
|
|
2014-12-10 02:28:32 +07:00
|
|
|
user_buf += PIPE_CRC_LINE_LEN;
|
|
|
|
n_entries--;
|
|
|
|
|
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
|
|
|
}
|
2013-10-16 00:55:27 +07:00
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
return bytes_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations i915_pipe_crc_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = i915_pipe_crc_open,
|
|
|
|
.read = i915_pipe_crc_read,
|
|
|
|
.release = i915_pipe_crc_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct pipe_crc_info i915_pipe_crc_data[I915_MAX_PIPES] = {
|
|
|
|
{
|
|
|
|
.name = "i915_pipe_A_crc",
|
|
|
|
.pipe = PIPE_A,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "i915_pipe_B_crc",
|
|
|
|
.pipe = PIPE_B,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "i915_pipe_C_crc",
|
|
|
|
.pipe = PIPE_C,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int i915_pipe_crc_create(struct dentry *root, struct drm_minor *minor,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = minor->dev;
|
|
|
|
struct dentry *ent;
|
|
|
|
struct pipe_crc_info *info = &i915_pipe_crc_data[pipe];
|
|
|
|
|
|
|
|
info->dev = dev;
|
|
|
|
ent = debugfs_create_file(info->name, S_IRUGO, root, info,
|
|
|
|
&i915_pipe_crc_fops);
|
2013-12-16 13:13:25 +07:00
|
|
|
if (!ent)
|
|
|
|
return -ENOMEM;
|
2013-10-16 00:55:40 +07:00
|
|
|
|
|
|
|
return drm_add_fake_info_node(minor, ent, info);
|
2013-10-16 00:55:27 +07:00
|
|
|
}
|
|
|
|
|
2013-10-16 16:51:54 +07:00
|
|
|
static const char * const pipe_crc_sources[] = {
|
2013-10-16 18:30:34 +07:00
|
|
|
"none",
|
|
|
|
"plane1",
|
|
|
|
"plane2",
|
|
|
|
"pf",
|
2013-10-17 03:55:48 +07:00
|
|
|
"pipe",
|
2013-10-17 03:55:58 +07:00
|
|
|
"TV",
|
|
|
|
"DP-B",
|
|
|
|
"DP-C",
|
|
|
|
"DP-D",
|
2013-11-01 16:50:20 +07:00
|
|
|
"auto",
|
2013-10-16 18:30:34 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static const char *pipe_crc_source_name(enum intel_pipe_crc_source source)
|
|
|
|
{
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(pipe_crc_sources) != INTEL_PIPE_CRC_SOURCE_MAX);
|
|
|
|
return pipe_crc_sources[source];
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static int display_crc_ctl_show(struct seq_file *m, void *data)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = m->private;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < I915_MAX_PIPES; i++)
|
|
|
|
seq_printf(m, "%c %s\n", pipe_name(i),
|
|
|
|
pipe_crc_source_name(dev_priv->pipe_crc[i].source));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static int display_crc_ctl_open(struct inode *inode, struct file *file)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
return single_open(file, display_crc_ctl_show, dev);
|
2013-10-16 18:30:34 +07:00
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:20 +07:00
|
|
|
static int i8xx_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
|
2013-10-21 22:26:38 +07:00
|
|
|
uint32_t *val)
|
|
|
|
{
|
2013-11-01 16:50:20 +07:00
|
|
|
if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_PIPE;
|
|
|
|
|
|
|
|
switch (*source) {
|
2013-10-21 22:26:38 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_PIPE:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_INCLUDE_BORDER_I8XX;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_NONE:
|
|
|
|
*val = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:20 +07:00
|
|
|
static int i9xx_pipe_crc_auto_source(struct drm_device *dev, enum pipe pipe,
|
|
|
|
enum intel_pipe_crc_source *source)
|
|
|
|
{
|
|
|
|
struct intel_encoder *encoder;
|
|
|
|
struct intel_crtc *crtc;
|
2013-11-01 16:50:23 +07:00
|
|
|
struct intel_digital_port *dig_port;
|
2013-11-01 16:50:20 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_PIPE;
|
|
|
|
|
drm: Split connection_mutex out of mode_config.mutex (v3)
After the split-out of crtc locks from the big mode_config.mutex
there's still two major areas it protects:
- Various connector probe states, like connector->status, EDID
properties, probed mode lists and similar information.
- The links from connector->encoder and encoder->crtc and other
modeset-relevant connector state (e.g. properties which control the
panel fitter).
The later is used by modeset operations. But they don't really care
about the former since it's allowed to e.g. enable a disconnected VGA
output or with a mode not in the probed list.
Thus far this hasn't been a problem, but for the atomic modeset
conversion Rob Clark needs to convert all modeset relevant locks into
w/w locks. This is required because the order of acquisition is
determined by how userspace supplies the atomic modeset data. This has
run into troubles in the detect path since the i915 load detect code
needs _both_ protections offered by the mode_config.mutex: It updates
probe state and it needs to change the modeset configuration to enable
the temporary load detect pipe.
The big deal here is that for the probe/detect users of this lock a
plain mutex fits best, but for atomic modesets we really want a w/w
mutex. To fix this lets split out a new connection_mutex lock for the
modeset relevant parts.
For simplicity I've decided to only add one additional lock for all
connector/encoder links and modeset configuration states. We have
piles of different modeset objects in addition to those (like bridges
or panels), so adding per-object locks would be much more effort.
Also, we're guaranteed (at least for now) to do a full modeset if we
need to acquire this lock. Which means that fine-grained locking is
fairly irrelevant compared to the amount of time the full modeset will
take.
I've done a full audit, and there's just a few things that justify
special focus:
- Locking in drm_sysfs.c is almost completely absent. We should
sprinkle mode_config.connection_mutex over this file a bit, but
since it already lacks mode_config.mutex this patch wont make the
situation any worse. This is material for a follow-up patch.
- omap has a omap_framebuffer_flush function which walks the
connector->encoder->crtc links and is called from many contexts.
Some look like they don't acquire mode_config.mutex, so this is
already racy. Again fixing this is material for a separate patch.
- The radeon hot_plug function to retrain DP links looks at
connector->dpms. Currently this happens without any locking, so is
already racy. I think radeon_hotplug_work_func should gain
mutex_lock/unlock calls for the mode_config.connection_mutex.
- Same applies to i915's intel_dp_hot_plug. But again, this is already
racy.
- i915 load_detect code needs to acquire this lock. Which means the
w/w dance due to Rob's work will be nicely contained to _just_ this
function.
I've added fixme comments everywhere where it looks suspicious but in
the sysfs code. After a quick irc discussion with Dave Airlie it
sounds like the lack of locking in there is due to sysfs cleanup fun
at module unload.
v1: original (only compile tested)
v2: missing mutex_init(), etc (from Rob Clark)
v3: i915 needs more care in the conversion:
- Protect the edp pp logic with the connection_mutex.
- Use connection_mutex in the backlight code due to
get_pipe_from_connector.
- Use drm_modeset_lock_all in suspend/resume paths.
- Update lock checks in the overlay code.
Cc: Alex Deucher <alexdeucher@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Rob Clark <robdclark@gmail.com>
2014-05-30 04:54:47 +07:00
|
|
|
drm_modeset_lock_all(dev);
|
2014-08-05 17:29:37 +07:00
|
|
|
for_each_intel_encoder(dev, encoder) {
|
2013-11-01 16:50:20 +07:00
|
|
|
if (!encoder->base.crtc)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
crtc = to_intel_crtc(encoder->base.crtc);
|
|
|
|
|
|
|
|
if (crtc->pipe != pipe)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (encoder->type) {
|
|
|
|
case INTEL_OUTPUT_TVOUT:
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_TV;
|
|
|
|
break;
|
|
|
|
case INTEL_OUTPUT_DISPLAYPORT:
|
|
|
|
case INTEL_OUTPUT_EDP:
|
2013-11-01 16:50:23 +07:00
|
|
|
dig_port = enc_to_dig_port(&encoder->base);
|
|
|
|
switch (dig_port->port) {
|
|
|
|
case PORT_B:
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_DP_B;
|
|
|
|
break;
|
|
|
|
case PORT_C:
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_DP_C;
|
|
|
|
break;
|
|
|
|
case PORT_D:
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_DP_D;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN(1, "nonexisting DP port %c\n",
|
|
|
|
port_name(dig_port->port));
|
|
|
|
break;
|
|
|
|
}
|
2013-11-01 16:50:20 +07:00
|
|
|
break;
|
2014-10-28 02:47:52 +07:00
|
|
|
default:
|
|
|
|
break;
|
2013-11-01 16:50:20 +07:00
|
|
|
}
|
|
|
|
}
|
drm: Split connection_mutex out of mode_config.mutex (v3)
After the split-out of crtc locks from the big mode_config.mutex
there's still two major areas it protects:
- Various connector probe states, like connector->status, EDID
properties, probed mode lists and similar information.
- The links from connector->encoder and encoder->crtc and other
modeset-relevant connector state (e.g. properties which control the
panel fitter).
The later is used by modeset operations. But they don't really care
about the former since it's allowed to e.g. enable a disconnected VGA
output or with a mode not in the probed list.
Thus far this hasn't been a problem, but for the atomic modeset
conversion Rob Clark needs to convert all modeset relevant locks into
w/w locks. This is required because the order of acquisition is
determined by how userspace supplies the atomic modeset data. This has
run into troubles in the detect path since the i915 load detect code
needs _both_ protections offered by the mode_config.mutex: It updates
probe state and it needs to change the modeset configuration to enable
the temporary load detect pipe.
The big deal here is that for the probe/detect users of this lock a
plain mutex fits best, but for atomic modesets we really want a w/w
mutex. To fix this lets split out a new connection_mutex lock for the
modeset relevant parts.
For simplicity I've decided to only add one additional lock for all
connector/encoder links and modeset configuration states. We have
piles of different modeset objects in addition to those (like bridges
or panels), so adding per-object locks would be much more effort.
Also, we're guaranteed (at least for now) to do a full modeset if we
need to acquire this lock. Which means that fine-grained locking is
fairly irrelevant compared to the amount of time the full modeset will
take.
I've done a full audit, and there's just a few things that justify
special focus:
- Locking in drm_sysfs.c is almost completely absent. We should
sprinkle mode_config.connection_mutex over this file a bit, but
since it already lacks mode_config.mutex this patch wont make the
situation any worse. This is material for a follow-up patch.
- omap has a omap_framebuffer_flush function which walks the
connector->encoder->crtc links and is called from many contexts.
Some look like they don't acquire mode_config.mutex, so this is
already racy. Again fixing this is material for a separate patch.
- The radeon hot_plug function to retrain DP links looks at
connector->dpms. Currently this happens without any locking, so is
already racy. I think radeon_hotplug_work_func should gain
mutex_lock/unlock calls for the mode_config.connection_mutex.
- Same applies to i915's intel_dp_hot_plug. But again, this is already
racy.
- i915 load_detect code needs to acquire this lock. Which means the
w/w dance due to Rob's work will be nicely contained to _just_ this
function.
I've added fixme comments everywhere where it looks suspicious but in
the sysfs code. After a quick irc discussion with Dave Airlie it
sounds like the lack of locking in there is due to sysfs cleanup fun
at module unload.
v1: original (only compile tested)
v2: missing mutex_init(), etc (from Rob Clark)
v3: i915 needs more care in the conversion:
- Protect the edp pp logic with the connection_mutex.
- Use connection_mutex in the backlight code due to
get_pipe_from_connector.
- Use drm_modeset_lock_all in suspend/resume paths.
- Update lock checks in the overlay code.
Cc: Alex Deucher <alexdeucher@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Rob Clark <robdclark@gmail.com>
2014-05-30 04:54:47 +07:00
|
|
|
drm_modeset_unlock_all(dev);
|
2013-11-01 16:50:20 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vlv_pipe_crc_ctl_reg(struct drm_device *dev,
|
|
|
|
enum pipe pipe,
|
|
|
|
enum intel_pipe_crc_source *source,
|
2013-10-18 21:37:06 +07:00
|
|
|
uint32_t *val)
|
|
|
|
{
|
2013-11-01 16:50:22 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
bool need_stable_symbols = false;
|
|
|
|
|
2013-11-01 16:50:20 +07:00
|
|
|
if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
|
|
|
|
int ret = i9xx_pipe_crc_auto_source(dev, pipe, source);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (*source) {
|
2013-10-18 21:37:06 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_PIPE:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_VLV;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_B:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_VLV;
|
2013-11-01 16:50:22 +07:00
|
|
|
need_stable_symbols = true;
|
2013-10-18 21:37:06 +07:00
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_C:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_VLV;
|
2013-11-01 16:50:22 +07:00
|
|
|
need_stable_symbols = true;
|
2013-10-18 21:37:06 +07:00
|
|
|
break;
|
2014-12-10 02:28:29 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_D:
|
|
|
|
if (!IS_CHERRYVIEW(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_VLV;
|
|
|
|
need_stable_symbols = true;
|
|
|
|
break;
|
2013-10-18 21:37:06 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_NONE:
|
|
|
|
*val = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:22 +07:00
|
|
|
/*
|
|
|
|
* When the pipe CRC tap point is after the transcoders we need
|
|
|
|
* to tweak symbol-level features to produce a deterministic series of
|
|
|
|
* symbols for a given frame. We need to reset those features only once
|
|
|
|
* a frame (instead of every nth symbol):
|
|
|
|
* - DC-balance: used to ensure a better clock recovery from the data
|
|
|
|
* link (SDVO)
|
|
|
|
* - DisplayPort scrambling: used for EMI reduction
|
|
|
|
*/
|
|
|
|
if (need_stable_symbols) {
|
|
|
|
uint32_t tmp = I915_READ(PORT_DFT2_G4X);
|
|
|
|
|
|
|
|
tmp |= DC_BALANCE_RESET_VLV;
|
2014-12-10 02:28:28 +07:00
|
|
|
switch (pipe) {
|
|
|
|
case PIPE_A:
|
2013-11-01 16:50:22 +07:00
|
|
|
tmp |= PIPE_A_SCRAMBLE_RESET;
|
2014-12-10 02:28:28 +07:00
|
|
|
break;
|
|
|
|
case PIPE_B:
|
2013-11-01 16:50:22 +07:00
|
|
|
tmp |= PIPE_B_SCRAMBLE_RESET;
|
2014-12-10 02:28:28 +07:00
|
|
|
break;
|
|
|
|
case PIPE_C:
|
|
|
|
tmp |= PIPE_C_SCRAMBLE_RESET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-11-01 16:50:22 +07:00
|
|
|
I915_WRITE(PORT_DFT2_G4X, tmp);
|
|
|
|
}
|
|
|
|
|
2013-10-18 21:37:06 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-17 03:55:59 +07:00
|
|
|
static int i9xx_pipe_crc_ctl_reg(struct drm_device *dev,
|
2013-11-01 16:50:20 +07:00
|
|
|
enum pipe pipe,
|
|
|
|
enum intel_pipe_crc_source *source,
|
2013-10-17 03:55:59 +07:00
|
|
|
uint32_t *val)
|
|
|
|
{
|
2013-11-01 16:50:21 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
bool need_stable_symbols = false;
|
|
|
|
|
2013-11-01 16:50:20 +07:00
|
|
|
if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
|
|
|
|
int ret = i9xx_pipe_crc_auto_source(dev, pipe, source);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (*source) {
|
2013-10-17 03:55:59 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_PIPE:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_I9XX;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_TV:
|
|
|
|
if (!SUPPORTS_TV(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_TV_PRE;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_B:
|
|
|
|
if (!IS_G4X(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_G4X;
|
2013-11-01 16:50:21 +07:00
|
|
|
need_stable_symbols = true;
|
2013-10-17 03:55:59 +07:00
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_C:
|
|
|
|
if (!IS_G4X(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_G4X;
|
2013-11-01 16:50:21 +07:00
|
|
|
need_stable_symbols = true;
|
2013-10-17 03:55:59 +07:00
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_DP_D:
|
|
|
|
if (!IS_G4X(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_G4X;
|
2013-11-01 16:50:21 +07:00
|
|
|
need_stable_symbols = true;
|
2013-10-17 03:55:59 +07:00
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_NONE:
|
|
|
|
*val = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:21 +07:00
|
|
|
/*
|
|
|
|
* When the pipe CRC tap point is after the transcoders we need
|
|
|
|
* to tweak symbol-level features to produce a deterministic series of
|
|
|
|
* symbols for a given frame. We need to reset those features only once
|
|
|
|
* a frame (instead of every nth symbol):
|
|
|
|
* - DC-balance: used to ensure a better clock recovery from the data
|
|
|
|
* link (SDVO)
|
|
|
|
* - DisplayPort scrambling: used for EMI reduction
|
|
|
|
*/
|
|
|
|
if (need_stable_symbols) {
|
|
|
|
uint32_t tmp = I915_READ(PORT_DFT2_G4X);
|
|
|
|
|
|
|
|
WARN_ON(!IS_G4X(dev));
|
|
|
|
|
|
|
|
I915_WRITE(PORT_DFT_I9XX,
|
|
|
|
I915_READ(PORT_DFT_I9XX) | DC_BALANCE_RESET);
|
|
|
|
|
|
|
|
if (pipe == PIPE_A)
|
|
|
|
tmp |= PIPE_A_SCRAMBLE_RESET;
|
|
|
|
else
|
|
|
|
tmp |= PIPE_B_SCRAMBLE_RESET;
|
|
|
|
|
|
|
|
I915_WRITE(PORT_DFT2_G4X, tmp);
|
|
|
|
}
|
|
|
|
|
2013-10-17 03:55:59 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:22 +07:00
|
|
|
static void vlv_undo_pipe_scramble_reset(struct drm_device *dev,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
uint32_t tmp = I915_READ(PORT_DFT2_G4X);
|
|
|
|
|
2014-12-10 02:28:28 +07:00
|
|
|
switch (pipe) {
|
|
|
|
case PIPE_A:
|
2013-11-01 16:50:22 +07:00
|
|
|
tmp &= ~PIPE_A_SCRAMBLE_RESET;
|
2014-12-10 02:28:28 +07:00
|
|
|
break;
|
|
|
|
case PIPE_B:
|
2013-11-01 16:50:22 +07:00
|
|
|
tmp &= ~PIPE_B_SCRAMBLE_RESET;
|
2014-12-10 02:28:28 +07:00
|
|
|
break;
|
|
|
|
case PIPE_C:
|
|
|
|
tmp &= ~PIPE_C_SCRAMBLE_RESET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
2013-11-01 16:50:22 +07:00
|
|
|
if (!(tmp & PIPE_SCRAMBLE_RESET_MASK))
|
|
|
|
tmp &= ~DC_BALANCE_RESET_VLV;
|
|
|
|
I915_WRITE(PORT_DFT2_G4X, tmp);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:21 +07:00
|
|
|
static void g4x_undo_pipe_scramble_reset(struct drm_device *dev,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
uint32_t tmp = I915_READ(PORT_DFT2_G4X);
|
|
|
|
|
|
|
|
if (pipe == PIPE_A)
|
|
|
|
tmp &= ~PIPE_A_SCRAMBLE_RESET;
|
|
|
|
else
|
|
|
|
tmp &= ~PIPE_B_SCRAMBLE_RESET;
|
|
|
|
I915_WRITE(PORT_DFT2_G4X, tmp);
|
|
|
|
|
|
|
|
if (!(tmp & PIPE_SCRAMBLE_RESET_MASK)) {
|
|
|
|
I915_WRITE(PORT_DFT_I9XX,
|
|
|
|
I915_READ(PORT_DFT_I9XX) & ~DC_BALANCE_RESET);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:50:20 +07:00
|
|
|
static int ilk_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
|
2013-10-17 03:55:48 +07:00
|
|
|
uint32_t *val)
|
|
|
|
{
|
2013-11-01 16:50:20 +07:00
|
|
|
if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_PIPE;
|
|
|
|
|
|
|
|
switch (*source) {
|
2013-10-17 03:55:48 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_PLANE1:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_ILK;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_PLANE2:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_ILK;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_PIPE:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_ILK;
|
|
|
|
break;
|
2013-10-17 03:55:58 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_NONE:
|
2013-10-17 03:55:48 +07:00
|
|
|
*val = 0;
|
|
|
|
break;
|
2013-10-17 03:55:58 +07:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2013-10-17 03:55:48 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 19:10:22 +07:00
|
|
|
static void hsw_trans_edp_pipe_A_crc_wa(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_crtc *crtc =
|
|
|
|
to_intel_crtc(dev_priv->pipe_to_crtc_mapping[PIPE_A]);
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
/*
|
|
|
|
* If we use the eDP transcoder we need to make sure that we don't
|
|
|
|
* bypass the pfit, since otherwise the pipe CRC source won't work. Only
|
|
|
|
* relevant on hsw with pipe A when using the always-on power well
|
|
|
|
* routing.
|
|
|
|
*/
|
2015-01-15 19:55:25 +07:00
|
|
|
if (crtc->config->cpu_transcoder == TRANSCODER_EDP &&
|
|
|
|
!crtc->config->pch_pfit.enabled) {
|
|
|
|
crtc->config->pch_pfit.force_thru = true;
|
2014-05-29 19:10:22 +07:00
|
|
|
|
|
|
|
intel_display_power_get(dev_priv,
|
|
|
|
POWER_DOMAIN_PIPE_PANEL_FITTER(PIPE_A));
|
|
|
|
|
|
|
|
dev_priv->display.crtc_disable(&crtc->base);
|
|
|
|
dev_priv->display.crtc_enable(&crtc->base);
|
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hsw_undo_trans_edp_pipe_A_crc_wa(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_crtc *crtc =
|
|
|
|
to_intel_crtc(dev_priv->pipe_to_crtc_mapping[PIPE_A]);
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
/*
|
|
|
|
* If we use the eDP transcoder we need to make sure that we don't
|
|
|
|
* bypass the pfit, since otherwise the pipe CRC source won't work. Only
|
|
|
|
* relevant on hsw with pipe A when using the always-on power well
|
|
|
|
* routing.
|
|
|
|
*/
|
2015-01-15 19:55:25 +07:00
|
|
|
if (crtc->config->pch_pfit.force_thru) {
|
|
|
|
crtc->config->pch_pfit.force_thru = false;
|
2014-05-29 19:10:22 +07:00
|
|
|
|
|
|
|
dev_priv->display.crtc_disable(&crtc->base);
|
|
|
|
dev_priv->display.crtc_enable(&crtc->base);
|
|
|
|
|
|
|
|
intel_display_power_put(dev_priv,
|
|
|
|
POWER_DOMAIN_PIPE_PANEL_FITTER(PIPE_A));
|
|
|
|
}
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ivb_pipe_crc_ctl_reg(struct drm_device *dev,
|
|
|
|
enum pipe pipe,
|
|
|
|
enum intel_pipe_crc_source *source,
|
2013-10-17 03:55:48 +07:00
|
|
|
uint32_t *val)
|
|
|
|
{
|
2013-11-01 16:50:20 +07:00
|
|
|
if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
|
|
|
|
*source = INTEL_PIPE_CRC_SOURCE_PF;
|
|
|
|
|
|
|
|
switch (*source) {
|
2013-10-17 03:55:48 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_PLANE1:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_IVB;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_PLANE2:
|
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_IVB;
|
|
|
|
break;
|
|
|
|
case INTEL_PIPE_CRC_SOURCE_PF:
|
2014-05-29 19:10:22 +07:00
|
|
|
if (IS_HASWELL(dev) && pipe == PIPE_A)
|
|
|
|
hsw_trans_edp_pipe_A_crc_wa(dev);
|
|
|
|
|
2013-10-17 03:55:48 +07:00
|
|
|
*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PF_IVB;
|
|
|
|
break;
|
2013-10-17 03:55:58 +07:00
|
|
|
case INTEL_PIPE_CRC_SOURCE_NONE:
|
2013-10-17 03:55:48 +07:00
|
|
|
*val = 0;
|
|
|
|
break;
|
2013-10-17 03:55:58 +07:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2013-10-17 03:55:48 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-16 18:30:34 +07:00
|
|
|
static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe,
|
|
|
|
enum intel_pipe_crc_source source)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-10-16 00:55:31 +07:00
|
|
|
struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
|
2014-10-18 04:42:03 +07:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(intel_get_crtc_for_pipe(dev,
|
|
|
|
pipe));
|
2013-11-21 22:49:46 +07:00
|
|
|
u32 val = 0; /* shut up gcc */
|
2013-10-17 03:55:48 +07:00
|
|
|
int ret;
|
2013-10-16 18:30:34 +07:00
|
|
|
|
2013-10-16 00:55:31 +07:00
|
|
|
if (pipe_crc->source == source)
|
|
|
|
return 0;
|
|
|
|
|
2013-10-16 00:55:32 +07:00
|
|
|
/* forbid changing the source without going back to 'none' */
|
|
|
|
if (pipe_crc->source && source)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-11-25 20:00:40 +07:00
|
|
|
if (!intel_display_power_is_enabled(dev_priv, POWER_DOMAIN_PIPE(pipe))) {
|
|
|
|
DRM_DEBUG_KMS("Trying to capture CRC while pipe is off\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2013-10-21 22:26:38 +07:00
|
|
|
if (IS_GEN2(dev))
|
2013-11-01 16:50:20 +07:00
|
|
|
ret = i8xx_pipe_crc_ctl_reg(&source, &val);
|
2013-10-21 22:26:38 +07:00
|
|
|
else if (INTEL_INFO(dev)->gen < 5)
|
2013-11-01 16:50:20 +07:00
|
|
|
ret = i9xx_pipe_crc_ctl_reg(dev, pipe, &source, &val);
|
2013-10-18 21:37:06 +07:00
|
|
|
else if (IS_VALLEYVIEW(dev))
|
2014-05-29 19:10:22 +07:00
|
|
|
ret = vlv_pipe_crc_ctl_reg(dev, pipe, &source, &val);
|
2013-10-17 03:55:59 +07:00
|
|
|
else if (IS_GEN5(dev) || IS_GEN6(dev))
|
2013-11-01 16:50:20 +07:00
|
|
|
ret = ilk_pipe_crc_ctl_reg(&source, &val);
|
2013-10-17 03:55:48 +07:00
|
|
|
else
|
2014-05-29 19:10:22 +07:00
|
|
|
ret = ivb_pipe_crc_ctl_reg(dev, pipe, &source, &val);
|
2013-10-17 03:55:48 +07:00
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
|
2013-10-16 00:55:33 +07:00
|
|
|
/* none -> real source transition */
|
|
|
|
if (source) {
|
2014-12-10 02:28:30 +07:00
|
|
|
struct intel_pipe_crc_entry *entries;
|
|
|
|
|
2013-10-16 00:55:38 +07:00
|
|
|
DRM_DEBUG_DRIVER("collecting CRCs for pipe %c, %s\n",
|
|
|
|
pipe_name(pipe), pipe_crc_source_name(source));
|
|
|
|
|
2014-12-10 02:28:31 +07:00
|
|
|
entries = kcalloc(INTEL_PIPE_CRC_ENTRIES_NR,
|
|
|
|
sizeof(pipe_crc->entries[0]),
|
2014-12-10 02:28:30 +07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!entries)
|
2013-10-16 00:55:34 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-10-18 04:42:03 +07:00
|
|
|
/*
|
|
|
|
* When IPS gets enabled, the pipe CRC changes. Since IPS gets
|
|
|
|
* enabled and disabled dynamically based on package C states,
|
|
|
|
* user space can't make reliable use of the CRCs, so let's just
|
|
|
|
* completely disable it.
|
|
|
|
*/
|
|
|
|
hsw_disable_ips(crtc);
|
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
2014-12-10 17:00:29 +07:00
|
|
|
kfree(pipe_crc->entries);
|
2014-12-10 02:28:30 +07:00
|
|
|
pipe_crc->entries = entries;
|
2013-10-21 20:29:30 +07:00
|
|
|
pipe_crc->head = 0;
|
|
|
|
pipe_crc->tail = 0;
|
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
2013-10-16 00:55:33 +07:00
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:31 +07:00
|
|
|
pipe_crc->source = source;
|
2013-10-16 18:30:34 +07:00
|
|
|
|
|
|
|
I915_WRITE(PIPE_CRC_CTL(pipe), val);
|
|
|
|
POSTING_READ(PIPE_CRC_CTL(pipe));
|
|
|
|
|
2013-10-16 00:55:34 +07:00
|
|
|
/* real source -> none transition */
|
|
|
|
if (source == INTEL_PIPE_CRC_SOURCE_NONE) {
|
2013-10-21 20:29:30 +07:00
|
|
|
struct intel_pipe_crc_entry *entries;
|
2014-06-06 13:22:08 +07:00
|
|
|
struct intel_crtc *crtc =
|
|
|
|
to_intel_crtc(dev_priv->pipe_to_crtc_mapping[pipe]);
|
2013-10-21 20:29:30 +07:00
|
|
|
|
2013-10-16 00:55:38 +07:00
|
|
|
DRM_DEBUG_DRIVER("stopping CRCs for pipe %c\n",
|
|
|
|
pipe_name(pipe));
|
|
|
|
|
2014-06-06 13:22:08 +07:00
|
|
|
drm_modeset_lock(&crtc->base.mutex, NULL);
|
|
|
|
if (crtc->active)
|
|
|
|
intel_wait_for_vblank(dev, pipe);
|
|
|
|
drm_modeset_unlock(&crtc->base.mutex);
|
2013-10-17 03:55:50 +07:00
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_lock_irq(&pipe_crc->lock);
|
|
|
|
entries = pipe_crc->entries;
|
2013-10-16 00:55:34 +07:00
|
|
|
pipe_crc->entries = NULL;
|
2014-12-10 02:28:32 +07:00
|
|
|
pipe_crc->head = 0;
|
|
|
|
pipe_crc->tail = 0;
|
2013-10-21 20:29:30 +07:00
|
|
|
spin_unlock_irq(&pipe_crc->lock);
|
|
|
|
|
|
|
|
kfree(entries);
|
2013-11-01 16:50:21 +07:00
|
|
|
|
|
|
|
if (IS_G4X(dev))
|
|
|
|
g4x_undo_pipe_scramble_reset(dev, pipe);
|
2013-11-01 16:50:22 +07:00
|
|
|
else if (IS_VALLEYVIEW(dev))
|
|
|
|
vlv_undo_pipe_scramble_reset(dev, pipe);
|
2014-05-29 19:10:22 +07:00
|
|
|
else if (IS_HASWELL(dev) && pipe == PIPE_A)
|
|
|
|
hsw_undo_trans_edp_pipe_A_crc_wa(dev);
|
2014-10-18 04:42:03 +07:00
|
|
|
|
|
|
|
hsw_enable_ips(crtc);
|
2013-10-16 00:55:34 +07:00
|
|
|
}
|
|
|
|
|
2013-10-16 18:30:34 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse pipe CRC command strings:
|
2013-10-16 00:55:35 +07:00
|
|
|
* command: wsp* object wsp+ name wsp+ source wsp*
|
|
|
|
* object: 'pipe'
|
|
|
|
* name: (A | B | C)
|
2013-10-16 18:30:34 +07:00
|
|
|
* source: (none | plane1 | plane2 | pf)
|
|
|
|
* wsp: (#0x20 | #0x9 | #0xA)+
|
|
|
|
*
|
|
|
|
* eg.:
|
2013-10-16 00:55:35 +07:00
|
|
|
* "pipe A plane1" -> Start CRC computations on plane1 of pipe A
|
|
|
|
* "pipe A none" -> Stop CRC
|
2013-10-16 18:30:34 +07:00
|
|
|
*/
|
2013-10-16 00:55:36 +07:00
|
|
|
static int display_crc_ctl_tokenize(char *buf, char *words[], int max_words)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
int n_words = 0;
|
|
|
|
|
|
|
|
while (*buf) {
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
/* skip leading white space */
|
|
|
|
buf = skip_spaces(buf);
|
|
|
|
if (!*buf)
|
|
|
|
break; /* end of buffer */
|
|
|
|
|
|
|
|
/* find end of word */
|
|
|
|
for (end = buf; *end && !isspace(*end); end++)
|
|
|
|
;
|
|
|
|
|
|
|
|
if (n_words == max_words) {
|
|
|
|
DRM_DEBUG_DRIVER("too many words, allowed <= %d\n",
|
|
|
|
max_words);
|
|
|
|
return -EINVAL; /* ran out of words[] before bytes */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*end)
|
|
|
|
*end++ = '\0';
|
|
|
|
words[n_words++] = buf;
|
|
|
|
buf = end;
|
|
|
|
}
|
|
|
|
|
|
|
|
return n_words;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:35 +07:00
|
|
|
enum intel_pipe_crc_object {
|
|
|
|
PIPE_CRC_OBJECT_PIPE,
|
|
|
|
};
|
|
|
|
|
2013-10-16 16:51:54 +07:00
|
|
|
static const char * const pipe_crc_objects[] = {
|
2013-10-16 00:55:35 +07:00
|
|
|
"pipe",
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2013-10-16 00:55:36 +07:00
|
|
|
display_crc_ctl_parse_object(const char *buf, enum intel_pipe_crc_object *o)
|
2013-10-16 00:55:35 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pipe_crc_objects); i++)
|
|
|
|
if (!strcmp(buf, pipe_crc_objects[i])) {
|
2013-10-16 00:55:36 +07:00
|
|
|
*o = i;
|
2013-10-16 00:55:35 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static int display_crc_ctl_parse_pipe(const char *buf, enum pipe *pipe)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
const char name = buf[0];
|
|
|
|
|
|
|
|
if (name < 'A' || name >= pipe_name(I915_MAX_PIPES))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
*pipe = name - 'A';
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2013-10-16 00:55:36 +07:00
|
|
|
display_crc_ctl_parse_source(const char *buf, enum intel_pipe_crc_source *s)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pipe_crc_sources); i++)
|
|
|
|
if (!strcmp(buf, pipe_crc_sources[i])) {
|
2013-10-16 00:55:36 +07:00
|
|
|
*s = i;
|
2013-10-16 18:30:34 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static int display_crc_ctl_parse(struct drm_device *dev, char *buf, size_t len)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
2013-10-16 00:55:35 +07:00
|
|
|
#define N_WORDS 3
|
2013-10-16 18:30:34 +07:00
|
|
|
int n_words;
|
2013-10-16 00:55:35 +07:00
|
|
|
char *words[N_WORDS];
|
2013-10-16 18:30:34 +07:00
|
|
|
enum pipe pipe;
|
2013-10-16 00:55:35 +07:00
|
|
|
enum intel_pipe_crc_object object;
|
2013-10-16 18:30:34 +07:00
|
|
|
enum intel_pipe_crc_source source;
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
n_words = display_crc_ctl_tokenize(buf, words, N_WORDS);
|
2013-10-16 00:55:35 +07:00
|
|
|
if (n_words != N_WORDS) {
|
|
|
|
DRM_DEBUG_DRIVER("tokenize failed, a command is %d words\n",
|
|
|
|
N_WORDS);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
if (display_crc_ctl_parse_object(words[0], &object) < 0) {
|
2013-10-16 00:55:35 +07:00
|
|
|
DRM_DEBUG_DRIVER("unknown object %s\n", words[0]);
|
2013-10-16 18:30:34 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
if (display_crc_ctl_parse_pipe(words[1], &pipe) < 0) {
|
2013-10-16 00:55:35 +07:00
|
|
|
DRM_DEBUG_DRIVER("unknown pipe %s\n", words[1]);
|
2013-10-16 18:30:34 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
if (display_crc_ctl_parse_source(words[2], &source) < 0) {
|
2013-10-16 00:55:35 +07:00
|
|
|
DRM_DEBUG_DRIVER("unknown source %s\n", words[2]);
|
2013-10-16 18:30:34 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pipe_crc_set_source(dev, pipe, source);
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static ssize_t display_crc_ctl_write(struct file *file, const char __user *ubuf,
|
|
|
|
size_t len, loff_t *offp)
|
2013-10-16 18:30:34 +07:00
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct drm_device *dev = m->private;
|
|
|
|
char *tmpbuf;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (len == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (len > PAGE_SIZE - 1) {
|
|
|
|
DRM_DEBUG_DRIVER("expected <%lu bytes into pipe crc control\n",
|
|
|
|
PAGE_SIZE);
|
|
|
|
return -E2BIG;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmpbuf = kmalloc(len + 1, GFP_KERNEL);
|
|
|
|
if (!tmpbuf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (copy_from_user(tmpbuf, ubuf, len)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
tmpbuf[len] = '\0';
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
ret = display_crc_ctl_parse(dev, tmpbuf, len);
|
2013-10-16 18:30:34 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(tmpbuf);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
*offp += len;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2013-10-16 00:55:36 +07:00
|
|
|
static const struct file_operations i915_display_crc_ctl_fops = {
|
2013-10-16 18:30:34 +07:00
|
|
|
.owner = THIS_MODULE,
|
2013-10-16 00:55:36 +07:00
|
|
|
.open = display_crc_ctl_open,
|
2013-10-16 18:30:34 +07:00
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2013-10-16 00:55:36 +07:00
|
|
|
.write = display_crc_ctl_write
|
2013-10-16 18:30:34 +07:00
|
|
|
};
|
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
static void wm_latency_show(struct seq_file *m, const uint16_t wm[8])
|
2014-01-22 19:36:08 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = m->private;
|
2014-05-13 21:30:26 +07:00
|
|
|
int num_levels = ilk_wm_max_level(dev) + 1;
|
2014-01-22 19:36:08 +07:00
|
|
|
int level;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
|
|
|
for (level = 0; level < num_levels; level++) {
|
|
|
|
unsigned int latency = wm[level];
|
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
/*
|
|
|
|
* - WM1+ latency values in 0.5us units
|
|
|
|
* - latencies are in us on gen9
|
|
|
|
*/
|
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latency *= 10;
|
|
|
|
else if (level > 0)
|
2014-01-22 19:36:08 +07:00
|
|
|
latency *= 5;
|
|
|
|
|
|
|
|
seq_printf(m, "WM%d %u (%u.%u usec)\n",
|
2014-11-05 00:06:50 +07:00
|
|
|
level, wm[level], latency / 10, latency % 10);
|
2014-01-22 19:36:08 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pri_wm_latency_show(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
const uint16_t *latencies;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.pri_latency;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
wm_latency_show(m, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spr_wm_latency_show(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
const uint16_t *latencies;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.spr_latency;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
wm_latency_show(m, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cur_wm_latency_show(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
const uint16_t *latencies;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.cur_latency;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
wm_latency_show(m, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pri_wm_latency_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
|
2014-07-21 16:53:39 +07:00
|
|
|
if (HAS_GMCH_DISPLAY(dev))
|
2014-01-22 19:36:08 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return single_open(file, pri_wm_latency_show, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spr_wm_latency_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
|
2014-07-21 16:53:39 +07:00
|
|
|
if (HAS_GMCH_DISPLAY(dev))
|
2014-01-22 19:36:08 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return single_open(file, spr_wm_latency_show, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cur_wm_latency_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
|
2014-07-21 16:53:39 +07:00
|
|
|
if (HAS_GMCH_DISPLAY(dev))
|
2014-01-22 19:36:08 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return single_open(file, cur_wm_latency_show, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t wm_latency_write(struct file *file, const char __user *ubuf,
|
2014-11-05 00:06:50 +07:00
|
|
|
size_t len, loff_t *offp, uint16_t wm[8])
|
2014-01-22 19:36:08 +07:00
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
uint16_t new[8] = { 0 };
|
2014-05-13 21:30:26 +07:00
|
|
|
int num_levels = ilk_wm_max_level(dev) + 1;
|
2014-01-22 19:36:08 +07:00
|
|
|
int level;
|
|
|
|
int ret;
|
|
|
|
char tmp[32];
|
|
|
|
|
|
|
|
if (len >= sizeof(tmp))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (copy_from_user(tmp, ubuf, len))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
tmp[len] = '\0';
|
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
ret = sscanf(tmp, "%hu %hu %hu %hu %hu %hu %hu %hu",
|
|
|
|
&new[0], &new[1], &new[2], &new[3],
|
|
|
|
&new[4], &new[5], &new[6], &new[7]);
|
2014-01-22 19:36:08 +07:00
|
|
|
if (ret != num_levels)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
|
|
|
for (level = 0; level < num_levels; level++)
|
|
|
|
wm[level] = new[level];
|
|
|
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t pri_wm_latency_write(struct file *file, const char __user *ubuf,
|
|
|
|
size_t len, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
uint16_t *latencies;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.pri_latency;
|
|
|
|
|
|
|
|
return wm_latency_write(file, ubuf, len, offp, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t spr_wm_latency_write(struct file *file, const char __user *ubuf,
|
|
|
|
size_t len, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
uint16_t *latencies;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.spr_latency;
|
|
|
|
|
|
|
|
return wm_latency_write(file, ubuf, len, offp, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t cur_wm_latency_write(struct file *file, const char __user *ubuf,
|
|
|
|
size_t len, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct drm_device *dev = m->private;
|
2014-11-05 00:06:50 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
uint16_t *latencies;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 9)
|
|
|
|
latencies = dev_priv->wm.skl_latency;
|
|
|
|
else
|
|
|
|
latencies = to_i915(dev)->wm.cur_latency;
|
2014-01-22 19:36:08 +07:00
|
|
|
|
2014-11-05 00:06:50 +07:00
|
|
|
return wm_latency_write(file, ubuf, len, offp, latencies);
|
2014-01-22 19:36:08 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations i915_pri_wm_latency_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = pri_wm_latency_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
.write = pri_wm_latency_write
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct file_operations i915_spr_wm_latency_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = spr_wm_latency_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
.write = spr_wm_latency_write
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct file_operations i915_cur_wm_latency_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = cur_wm_latency_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
.write = cur_wm_latency_write
|
|
|
|
};
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_wedged_get(void *data, u64 *val)
|
2009-10-14 04:20:20 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2009-10-14 04:20:20 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
*val = atomic_read(&dev_priv->gpu_error.reset_counter);
|
2009-10-14 04:20:20 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2009-10-14 04:20:20 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_wedged_set(void *data, u64 val)
|
2009-10-14 04:20:20 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-04-15 00:24:27 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2015-01-28 22:03:14 +07:00
|
|
|
/*
|
|
|
|
* There is no safeguard against this debugfs entry colliding
|
|
|
|
* with the hangcheck calling same i915_handle_error() in
|
|
|
|
* parallel, causing an explosion. For now we assume that the
|
|
|
|
* test harness is responsible enough not to inject gpu hangs
|
|
|
|
* while it is writing to 'i915_wedged'
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (i915_reset_in_progress(&dev_priv->gpu_error))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2014-04-15 00:24:27 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2009-10-14 04:20:20 +07:00
|
|
|
|
2014-02-25 22:11:26 +07:00
|
|
|
i915_handle_error(dev, val,
|
|
|
|
"Manually setting wedged to %llu", val);
|
2014-04-15 00:24:27 +07:00
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2009-10-14 04:20:20 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_wedged_fops,
|
|
|
|
i915_wedged_get, i915_wedged_set,
|
2013-04-12 16:10:05 +07:00
|
|
|
"%llu\n");
|
2009-10-14 04:20:20 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_ring_stop_get(void *data, u64 *val)
|
2012-05-03 19:48:16 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-05-03 19:48:16 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
*val = dev_priv->gpu_error.stop_rings;
|
2012-05-03 19:48:16 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2012-05-03 19:48:16 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_ring_stop_set(void *data, u64 val)
|
2012-05-03 19:48:16 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2012-05-03 19:48:16 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2012-05-03 19:48:16 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DRM_DEBUG_DRIVER("Stopping rings 0x%08llx\n", val);
|
2012-05-03 19:48:16 +07:00
|
|
|
|
2012-08-09 20:07:02 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-11-14 23:14:04 +07:00
|
|
|
dev_priv->gpu_error.stop_rings = val;
|
2012-05-03 19:48:16 +07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2012-05-03 19:48:16 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_ring_stop_fops,
|
|
|
|
i915_ring_stop_get, i915_ring_stop_set,
|
|
|
|
"0x%08llx\n");
|
2012-04-27 20:17:40 +07:00
|
|
|
|
2013-09-25 23:34:55 +07:00
|
|
|
static int
|
|
|
|
i915_ring_missed_irq_get(void *data, u64 *val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
*val = dev_priv->gpu_error.missed_irq_rings;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
i915_ring_missed_irq_set(void *data, u64 val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Lock against concurrent debugfs callers */
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
dev_priv->gpu_error.missed_irq_rings = val;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_ring_missed_irq_fops,
|
|
|
|
i915_ring_missed_irq_get, i915_ring_missed_irq_set,
|
|
|
|
"0x%08llx\n");
|
|
|
|
|
|
|
|
static int
|
|
|
|
i915_ring_test_irq_get(void *data, u64 *val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
*val = dev_priv->gpu_error.test_irq_rings;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
i915_ring_test_irq_set(void *data, u64 val)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = data;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
DRM_DEBUG_DRIVER("Masking interrupts on rings 0x%08llx\n", val);
|
|
|
|
|
|
|
|
/* Lock against concurrent debugfs callers */
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
dev_priv->gpu_error.test_irq_rings = val;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_ring_test_irq_fops,
|
|
|
|
i915_ring_test_irq_get, i915_ring_test_irq_set,
|
|
|
|
"0x%08llx\n");
|
|
|
|
|
2013-01-15 19:39:35 +07:00
|
|
|
#define DROP_UNBOUND 0x1
|
|
|
|
#define DROP_BOUND 0x2
|
|
|
|
#define DROP_RETIRE 0x4
|
|
|
|
#define DROP_ACTIVE 0x8
|
|
|
|
#define DROP_ALL (DROP_UNBOUND | \
|
|
|
|
DROP_BOUND | \
|
|
|
|
DROP_RETIRE | \
|
|
|
|
DROP_ACTIVE)
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_drop_caches_get(void *data, u64 *val)
|
2013-01-15 19:39:35 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
*val = DROP_ALL;
|
2013-01-15 19:39:35 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2013-01-15 19:39:35 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_drop_caches_set(void *data, u64 val)
|
2013-01-15 19:39:35 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2013-01-15 19:39:35 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2013-01-15 19:39:35 +07:00
|
|
|
|
2013-11-26 00:54:37 +07:00
|
|
|
DRM_DEBUG("Dropping caches: 0x%08llx\n", val);
|
2013-01-15 19:39:35 +07:00
|
|
|
|
|
|
|
/* No need to check and wait for gpu resets, only libdrm auto-restarts
|
|
|
|
* on ioctls on -EAGAIN. */
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (val & DROP_ACTIVE) {
|
|
|
|
ret = i915_gpu_idle(dev);
|
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val & (DROP_RETIRE | DROP_ACTIVE))
|
|
|
|
i915_gem_retire_requests(dev);
|
|
|
|
|
2014-09-09 17:16:08 +07:00
|
|
|
if (val & DROP_BOUND)
|
|
|
|
i915_gem_shrink(dev_priv, LONG_MAX, I915_SHRINK_BOUND);
|
2014-09-04 01:23:37 +07:00
|
|
|
|
2014-09-09 17:16:08 +07:00
|
|
|
if (val & DROP_UNBOUND)
|
|
|
|
i915_gem_shrink(dev_priv, LONG_MAX, I915_SHRINK_UNBOUND);
|
2013-01-15 19:39:35 +07:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return ret;
|
2013-01-15 19:39:35 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_drop_caches_fops,
|
|
|
|
i915_drop_caches_get, i915_drop_caches_set,
|
|
|
|
"0x%08llx\n");
|
2013-01-15 19:39:35 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_max_freq_get(void *data, u64 *val)
|
2011-07-28 01:53:01 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2012-08-09 20:07:01 +07:00
|
|
|
|
2014-05-31 06:22:10 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2012-08-09 20:07:01 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
|
2012-08-09 20:07:01 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-07-28 01:53:01 +07:00
|
|
|
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
*val = intel_gpu_freq(dev_priv, dev_priv->rps.max_freq_softlimit);
|
2012-11-03 01:14:01 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2011-07-28 01:53:01 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2011-07-28 01:53:01 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_max_freq_set(void *data, u64 val)
|
2011-07-28 01:53:01 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2011-07-28 01:53:01 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
u32 hw_max, hw_min;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2012-08-09 20:07:01 +07:00
|
|
|
|
2014-05-31 06:22:10 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2012-08-09 20:07:01 +07:00
|
|
|
return -ENODEV;
|
2011-07-28 01:53:01 +07:00
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DRM_DEBUG_DRIVER("Manually setting max freq to %llu\n", val);
|
2011-07-28 01:53:01 +07:00
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
|
2012-08-09 20:07:01 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-07-28 01:53:01 +07:00
|
|
|
/*
|
|
|
|
* Turbo will still be enabled, but won't go above the set value.
|
|
|
|
*/
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
val = intel_freq_opcode(dev_priv, val);
|
2014-02-05 00:32:31 +07:00
|
|
|
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
hw_max = dev_priv->rps.max_freq;
|
|
|
|
hw_min = dev_priv->rps.min_freq;
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2014-03-20 08:31:11 +07:00
|
|
|
if (val < hw_min || val > hw_max || val < dev_priv->rps.min_freq_softlimit) {
|
2014-02-05 00:32:31 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
|
|
|
return -EINVAL;
|
2013-04-18 05:54:58 +07:00
|
|
|
}
|
|
|
|
|
2014-03-20 08:31:11 +07:00
|
|
|
dev_priv->rps.max_freq_softlimit = val;
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2015-02-03 00:09:50 +07:00
|
|
|
intel_set_rps(dev, val);
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2011-07-28 01:53:01 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2011-07-28 01:53:01 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_max_freq_fops,
|
|
|
|
i915_max_freq_get, i915_max_freq_set,
|
2013-04-12 16:10:05 +07:00
|
|
|
"%llu\n");
|
2011-07-28 01:53:01 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_min_freq_get(void *data, u64 *val)
|
2012-05-26 02:34:54 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2012-08-09 20:07:01 +07:00
|
|
|
|
2014-05-31 06:22:10 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2012-08-09 20:07:01 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
|
2012-08-09 20:07:01 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-05-26 02:34:54 +07:00
|
|
|
|
drm/i915: Use intel_gpu_freq() and intel_freq_opcode()
Replace all the vlv_gpu_freq(), vlv_freq_opcode(),
*GT_FREQUENCY_MULTIPLIER, and /GT_FREQUENCY_MULTIPLIER instances
with intel_gpu_freq() and intel_freq_opcode() calls.
Most of the change was performed with the following semantic patch:
@@
expression E;
@@
(
- E * GT_FREQUENCY_MULTIPLIER
+ intel_gpu_freq(dev_priv, E)
|
- E *= GT_FREQUENCY_MULTIPLIER
+ E = intel_gpu_freq(dev_priv, E)
|
- E /= GT_FREQUENCY_MULTIPLIER
+ E = intel_freq_opcode(dev_priv, E)
|
- do_div(E, GT_FREQUENCY_MULTIPLIER)
+ E = intel_freq_opcode(dev_priv, E)
)
@@
expression E1, E2;
@@
(
- vlv_gpu_freq(E1, E2)
+ intel_gpu_freq(E1, E2)
|
- vlv_freq_opcode(E1, E2)
+ intel_freq_opcode(E1, E2)
)
@@
expression E1, E2, E3, E4;
@@
(
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_gpu_freq(E3, E4);
- } else {
- E2 = intel_gpu_freq(E3, E4);
- }
+ E2 = intel_gpu_freq(E3, E4);
|
- if (IS_VALLEYVIEW(E1)) {
- E2 = intel_freq_opcode(E3, E4);
- } else {
- E2 = intel_freq_opcode(E3, E4);
- }
+ E2 = intel_freq_opcode(E3, E4);
)
One hunk was manually undone as intel_gpu_freq() ended up
calling itself. Supposedly it would be possible to exclude
certain functions via !=~, but I couldn't get that to work.
Also the removal of vlv_gpu_freq() and vlv_opcode_freq() compat
wrappers was done manually.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-01-24 02:04:26 +07:00
|
|
|
*val = intel_gpu_freq(dev_priv, dev_priv->rps.min_freq_softlimit);
|
2012-11-03 01:14:01 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2012-05-26 02:34:54 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2012-05-26 02:34:54 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_min_freq_set(void *data, u64 val)
|
2012-05-26 02:34:54 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2012-05-26 02:34:54 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
u32 hw_max, hw_min;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2012-08-09 20:07:01 +07:00
|
|
|
|
2014-05-31 06:22:10 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2012-08-09 20:07:01 +07:00
|
|
|
return -ENODEV;
|
2012-05-26 02:34:54 +07:00
|
|
|
|
2013-09-17 04:56:43 +07:00
|
|
|
flush_delayed_work(&dev_priv->rps.delayed_resume_work);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DRM_DEBUG_DRIVER("Manually setting min freq to %llu\n", val);
|
2012-05-26 02:34:54 +07:00
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev_priv->rps.hw_lock);
|
2012-08-09 20:07:01 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-05-26 02:34:54 +07:00
|
|
|
/*
|
|
|
|
* Turbo will still be enabled, but won't go below the set value.
|
|
|
|
*/
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
val = intel_freq_opcode(dev_priv, val);
|
2014-02-05 00:32:31 +07:00
|
|
|
|
drm/i915: Removed the read of RP_STATE_CAP from sysfs/debugfs functions
The frequency values(Rp0, Rp1, Rpn) reported by RP_STATE_CAP register
are stored, initially by the Driver, inside the dev_priv->rps structure.
Since these values are expected to remain same throughout, there is no real
need to read this register, on dynamic basis, from certain debugfs/sysfs
functions and the values can be instead retrieved from the dev_priv->rps
structure when needed.
For the i915_frequency_info debugfs interface, the frequency values from the
RP_STATE_CAP register only should be used, to indicate the actual Hw state,
since it is principally used for the debugging purpose.
v2: Reverted the changes in i915_frequency_info function, to continue report
back the frequency values, as per the actual Hw state (Chris)
Signed-off-by: Akash Goel <akash.goel@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-02-26 17:39:47 +07:00
|
|
|
hw_max = dev_priv->rps.max_freq;
|
|
|
|
hw_min = dev_priv->rps.min_freq;
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2014-03-20 08:31:11 +07:00
|
|
|
if (val < hw_min || val > hw_max || val > dev_priv->rps.max_freq_softlimit) {
|
2014-02-05 00:32:31 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
|
|
|
return -EINVAL;
|
2013-04-18 05:54:58 +07:00
|
|
|
}
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2014-03-20 08:31:11 +07:00
|
|
|
dev_priv->rps.min_freq_softlimit = val;
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2015-02-03 00:09:50 +07:00
|
|
|
intel_set_rps(dev, val);
|
2014-02-05 00:32:31 +07:00
|
|
|
|
2012-11-03 01:14:01 +07:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2012-05-26 02:34:54 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2012-05-26 02:34:54 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_min_freq_fops,
|
|
|
|
i915_min_freq_get, i915_min_freq_set,
|
2013-04-12 16:10:05 +07:00
|
|
|
"%llu\n");
|
2012-05-26 02:34:54 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_cache_sharing_get(void *data, u64 *val)
|
2011-08-04 01:28:44 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2014-03-31 18:27:14 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2011-08-04 01:28:44 +07:00
|
|
|
u32 snpcr;
|
2013-03-11 04:10:06 +07:00
|
|
|
int ret;
|
2011-08-04 01:28:44 +07:00
|
|
|
|
2012-08-09 20:07:01 +07:00
|
|
|
if (!(IS_GEN6(dev) || IS_GEN7(dev)))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2012-08-09 20:07:02 +07:00
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2012-08-09 20:07:02 +07:00
|
|
|
|
2011-08-04 01:28:44 +07:00
|
|
|
snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
|
2013-11-28 03:21:54 +07:00
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
2011-08-04 01:28:44 +07:00
|
|
|
mutex_unlock(&dev_priv->dev->struct_mutex);
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
*val = (snpcr & GEN6_MBC_SNPCR_MASK) >> GEN6_MBC_SNPCR_SHIFT;
|
2011-08-04 01:28:44 +07:00
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2011-08-04 01:28:44 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
static int
|
|
|
|
i915_cache_sharing_set(void *data, u64 val)
|
2011-08-04 01:28:44 +07:00
|
|
|
{
|
2013-03-11 04:10:06 +07:00
|
|
|
struct drm_device *dev = data;
|
2011-08-04 01:28:44 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 snpcr;
|
|
|
|
|
2012-08-09 20:07:01 +07:00
|
|
|
if (!(IS_GEN6(dev) || IS_GEN7(dev)))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
if (val > 3)
|
2011-08-04 01:28:44 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2013-03-11 04:10:06 +07:00
|
|
|
DRM_DEBUG_DRIVER("Manually setting uncore sharing to %llu\n", val);
|
2011-08-04 01:28:44 +07:00
|
|
|
|
|
|
|
/* Update the cache sharing policy here as well */
|
|
|
|
snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
|
|
|
|
snpcr &= ~GEN6_MBC_SNPCR_MASK;
|
|
|
|
snpcr |= (val << GEN6_MBC_SNPCR_SHIFT);
|
|
|
|
I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
|
|
|
|
|
2013-11-28 03:21:54 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2013-03-11 04:10:06 +07:00
|
|
|
return 0;
|
2011-08-04 01:28:44 +07:00
|
|
|
}
|
|
|
|
|
2013-03-11 04:10:06 +07:00
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(i915_cache_sharing_fops,
|
|
|
|
i915_cache_sharing_get, i915_cache_sharing_set,
|
|
|
|
"%llu\n");
|
2011-08-04 01:28:44 +07:00
|
|
|
|
2015-02-13 23:27:54 +07:00
|
|
|
static int i915_sseu_status(struct seq_file *m, void *unused)
|
|
|
|
{
|
|
|
|
struct drm_info_node *node = (struct drm_info_node *) m->private;
|
|
|
|
struct drm_device *dev = node->minor->dev;
|
2015-02-13 23:27:55 +07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
unsigned int s_tot = 0, ss_tot = 0, ss_per = 0, eu_tot = 0, eu_per = 0;
|
2015-02-13 23:27:54 +07:00
|
|
|
|
2015-02-28 01:22:32 +07:00
|
|
|
if ((INTEL_INFO(dev)->gen < 8) || IS_BROADWELL(dev))
|
2015-02-13 23:27:54 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
seq_puts(m, "SSEU Device Info\n");
|
|
|
|
seq_printf(m, " Available Slice Total: %u\n",
|
|
|
|
INTEL_INFO(dev)->slice_total);
|
|
|
|
seq_printf(m, " Available Subslice Total: %u\n",
|
|
|
|
INTEL_INFO(dev)->subslice_total);
|
|
|
|
seq_printf(m, " Available Subslice Per Slice: %u\n",
|
|
|
|
INTEL_INFO(dev)->subslice_per_slice);
|
|
|
|
seq_printf(m, " Available EU Total: %u\n",
|
|
|
|
INTEL_INFO(dev)->eu_total);
|
|
|
|
seq_printf(m, " Available EU Per Subslice: %u\n",
|
|
|
|
INTEL_INFO(dev)->eu_per_subslice);
|
|
|
|
seq_printf(m, " Has Slice Power Gating: %s\n",
|
|
|
|
yesno(INTEL_INFO(dev)->has_slice_pg));
|
|
|
|
seq_printf(m, " Has Subslice Power Gating: %s\n",
|
|
|
|
yesno(INTEL_INFO(dev)->has_subslice_pg));
|
|
|
|
seq_printf(m, " Has EU Power Gating: %s\n",
|
|
|
|
yesno(INTEL_INFO(dev)->has_eu_pg));
|
|
|
|
|
2015-02-13 23:27:55 +07:00
|
|
|
seq_puts(m, "SSEU Device Status\n");
|
2015-02-28 01:22:32 +07:00
|
|
|
if (IS_CHERRYVIEW(dev)) {
|
|
|
|
const int ss_max = 2;
|
|
|
|
int ss;
|
|
|
|
u32 sig1[ss_max], sig2[ss_max];
|
|
|
|
|
|
|
|
sig1[0] = I915_READ(CHV_POWER_SS0_SIG1);
|
|
|
|
sig1[1] = I915_READ(CHV_POWER_SS1_SIG1);
|
|
|
|
sig2[0] = I915_READ(CHV_POWER_SS0_SIG2);
|
|
|
|
sig2[1] = I915_READ(CHV_POWER_SS1_SIG2);
|
|
|
|
|
|
|
|
for (ss = 0; ss < ss_max; ss++) {
|
|
|
|
unsigned int eu_cnt;
|
|
|
|
|
|
|
|
if (sig1[ss] & CHV_SS_PG_ENABLE)
|
|
|
|
/* skip disabled subslice */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
s_tot = 1;
|
|
|
|
ss_per++;
|
|
|
|
eu_cnt = ((sig1[ss] & CHV_EU08_PG_ENABLE) ? 0 : 2) +
|
|
|
|
((sig1[ss] & CHV_EU19_PG_ENABLE) ? 0 : 2) +
|
|
|
|
((sig1[ss] & CHV_EU210_PG_ENABLE) ? 0 : 2) +
|
|
|
|
((sig2[ss] & CHV_EU311_PG_ENABLE) ? 0 : 2);
|
|
|
|
eu_tot += eu_cnt;
|
|
|
|
eu_per = max(eu_per, eu_cnt);
|
|
|
|
}
|
|
|
|
ss_tot = ss_per;
|
|
|
|
} else if (IS_SKYLAKE(dev)) {
|
2015-02-13 23:27:55 +07:00
|
|
|
const int s_max = 3, ss_max = 4;
|
|
|
|
int s, ss;
|
|
|
|
u32 s_reg[s_max], eu_reg[2*s_max], eu_mask[2];
|
|
|
|
|
|
|
|
s_reg[0] = I915_READ(GEN9_SLICE0_PGCTL_ACK);
|
|
|
|
s_reg[1] = I915_READ(GEN9_SLICE1_PGCTL_ACK);
|
|
|
|
s_reg[2] = I915_READ(GEN9_SLICE2_PGCTL_ACK);
|
|
|
|
eu_reg[0] = I915_READ(GEN9_SLICE0_SS01_EU_PGCTL_ACK);
|
|
|
|
eu_reg[1] = I915_READ(GEN9_SLICE0_SS23_EU_PGCTL_ACK);
|
|
|
|
eu_reg[2] = I915_READ(GEN9_SLICE1_SS01_EU_PGCTL_ACK);
|
|
|
|
eu_reg[3] = I915_READ(GEN9_SLICE1_SS23_EU_PGCTL_ACK);
|
|
|
|
eu_reg[4] = I915_READ(GEN9_SLICE2_SS01_EU_PGCTL_ACK);
|
|
|
|
eu_reg[5] = I915_READ(GEN9_SLICE2_SS23_EU_PGCTL_ACK);
|
|
|
|
eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK |
|
|
|
|
GEN9_PGCTL_SSA_EU19_ACK |
|
|
|
|
GEN9_PGCTL_SSA_EU210_ACK |
|
|
|
|
GEN9_PGCTL_SSA_EU311_ACK;
|
|
|
|
eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK |
|
|
|
|
GEN9_PGCTL_SSB_EU19_ACK |
|
|
|
|
GEN9_PGCTL_SSB_EU210_ACK |
|
|
|
|
GEN9_PGCTL_SSB_EU311_ACK;
|
|
|
|
|
|
|
|
for (s = 0; s < s_max; s++) {
|
|
|
|
if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0)
|
|
|
|
/* skip disabled slice */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
s_tot++;
|
|
|
|
ss_per = INTEL_INFO(dev)->subslice_per_slice;
|
|
|
|
ss_tot += ss_per;
|
|
|
|
for (ss = 0; ss < ss_max; ss++) {
|
|
|
|
unsigned int eu_cnt;
|
|
|
|
|
|
|
|
eu_cnt = 2 * hweight32(eu_reg[2*s + ss/2] &
|
|
|
|
eu_mask[ss%2]);
|
|
|
|
eu_tot += eu_cnt;
|
|
|
|
eu_per = max(eu_per, eu_cnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
seq_printf(m, " Enabled Slice Total: %u\n", s_tot);
|
|
|
|
seq_printf(m, " Enabled Subslice Total: %u\n", ss_tot);
|
|
|
|
seq_printf(m, " Enabled Subslice Per Slice: %u\n", ss_per);
|
|
|
|
seq_printf(m, " Enabled EU Total: %u\n", eu_tot);
|
|
|
|
seq_printf(m, " Enabled EU Per Subslice: %u\n", eu_per);
|
|
|
|
|
2015-02-13 23:27:54 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-26 01:25:56 +07:00
|
|
|
static int i915_forcewake_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2012-01-24 15:44:28 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2011-04-26 01:25:56 +07:00
|
|
|
return 0;
|
|
|
|
|
2015-01-16 16:34:35 +07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2015-01-16 16:34:40 +07:00
|
|
|
intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
|
2011-04-26 01:25:56 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-17 04:07:40 +07:00
|
|
|
static int i915_forcewake_release(struct inode *inode, struct file *file)
|
2011-04-26 01:25:56 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = inode->i_private;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2012-01-24 15:44:28 +07:00
|
|
|
if (INTEL_INFO(dev)->gen < 6)
|
2011-04-26 01:25:56 +07:00
|
|
|
return 0;
|
|
|
|
|
2015-01-16 16:34:40 +07:00
|
|
|
intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
|
2015-01-16 16:34:35 +07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2011-04-26 01:25:56 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations i915_forcewake_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = i915_forcewake_open,
|
|
|
|
.release = i915_forcewake_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int i915_forcewake_create(struct dentry *root, struct drm_minor *minor)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = minor->dev;
|
|
|
|
struct dentry *ent;
|
|
|
|
|
|
|
|
ent = debugfs_create_file("i915_forcewake_user",
|
2011-05-12 05:10:58 +07:00
|
|
|
S_IRUSR,
|
2011-04-26 01:25:56 +07:00
|
|
|
root, dev,
|
|
|
|
&i915_forcewake_fops);
|
2013-12-16 13:13:25 +07:00
|
|
|
if (!ent)
|
|
|
|
return -ENOMEM;
|
2011-04-26 01:25:56 +07:00
|
|
|
|
2011-05-12 05:10:58 +07:00
|
|
|
return drm_add_fake_info_node(minor, ent, &i915_forcewake_fops);
|
2011-04-26 01:25:56 +07:00
|
|
|
}
|
|
|
|
|
2011-12-14 19:57:11 +07:00
|
|
|
static int i915_debugfs_create(struct dentry *root,
|
|
|
|
struct drm_minor *minor,
|
|
|
|
const char *name,
|
|
|
|
const struct file_operations *fops)
|
2011-08-04 01:28:44 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = minor->dev;
|
|
|
|
struct dentry *ent;
|
|
|
|
|
2011-12-14 19:57:11 +07:00
|
|
|
ent = debugfs_create_file(name,
|
2011-08-04 01:28:44 +07:00
|
|
|
S_IRUGO | S_IWUSR,
|
|
|
|
root, dev,
|
2011-12-14 19:57:11 +07:00
|
|
|
fops);
|
2013-12-16 13:13:25 +07:00
|
|
|
if (!ent)
|
|
|
|
return -ENOMEM;
|
2011-08-04 01:28:44 +07:00
|
|
|
|
2011-12-14 19:57:11 +07:00
|
|
|
return drm_add_fake_info_node(minor, ent, fops);
|
2011-08-04 01:28:44 +07:00
|
|
|
}
|
|
|
|
|
2013-10-18 01:09:56 +07:00
|
|
|
static const struct drm_info_list i915_debugfs_list[] = {
|
2011-01-14 02:06:50 +07:00
|
|
|
{"i915_capabilities", i915_capabilities, 0},
|
2010-09-30 17:46:12 +07:00
|
|
|
{"i915_gem_objects", i915_gem_object_info, 0},
|
2011-01-10 07:00:24 +07:00
|
|
|
{"i915_gem_gtt", i915_gem_gtt_info, 0},
|
2012-04-24 21:47:30 +07:00
|
|
|
{"i915_gem_pinned", i915_gem_gtt_info, 0, (void *) PINNED_LIST},
|
2009-02-18 08:08:51 +07:00
|
|
|
{"i915_gem_active", i915_gem_object_list_info, 0, (void *) ACTIVE_LIST},
|
|
|
|
{"i915_gem_inactive", i915_gem_object_list_info, 0, (void *) INACTIVE_LIST},
|
2013-08-08 00:30:54 +07:00
|
|
|
{"i915_gem_stolen", i915_gem_stolen_list_info },
|
2010-09-01 23:47:52 +07:00
|
|
|
{"i915_gem_pageflip", i915_gem_pageflip_info, 0},
|
2009-02-18 08:08:50 +07:00
|
|
|
{"i915_gem_request", i915_gem_request_info, 0},
|
|
|
|
{"i915_gem_seqno", i915_gem_seqno_info, 0},
|
2009-02-11 21:26:38 +07:00
|
|
|
{"i915_gem_fence_regs", i915_gem_fence_regs_info, 0},
|
2009-02-18 08:08:50 +07:00
|
|
|
{"i915_gem_interrupt", i915_interrupt_info, 0},
|
2010-12-04 18:30:53 +07:00
|
|
|
{"i915_gem_hws", i915_hws_info, 0, (void *)RCS},
|
|
|
|
{"i915_gem_hws_blt", i915_hws_info, 0, (void *)BCS},
|
|
|
|
{"i915_gem_hws_bsd", i915_hws_info, 0, (void *)VCS},
|
2013-05-29 23:22:36 +07:00
|
|
|
{"i915_gem_hws_vebox", i915_hws_info, 0, (void *)VECS},
|
2014-12-12 03:13:08 +07:00
|
|
|
{"i915_gem_batch_pool", i915_gem_batch_pool_info, 0},
|
2014-03-31 13:00:02 +07:00
|
|
|
{"i915_frequency_info", i915_frequency_info, 0},
|
2015-01-26 23:03:04 +07:00
|
|
|
{"i915_hangcheck_info", i915_hangcheck_info, 0},
|
2010-01-30 02:27:07 +07:00
|
|
|
{"i915_drpc_info", i915_drpc_info, 0},
|
2010-05-21 04:28:11 +07:00
|
|
|
{"i915_emon_status", i915_emon_status, 0},
|
2011-06-29 03:04:16 +07:00
|
|
|
{"i915_ring_freq_table", i915_ring_freq_table, 0},
|
2010-02-06 03:42:41 +07:00
|
|
|
{"i915_fbc_status", i915_fbc_status, 0},
|
2013-06-01 02:33:24 +07:00
|
|
|
{"i915_ips_status", i915_ips_status, 0},
|
2010-02-06 03:47:35 +07:00
|
|
|
{"i915_sr_status", i915_sr_status, 0},
|
2010-08-19 22:09:23 +07:00
|
|
|
{"i915_opregion", i915_opregion, 0},
|
2010-08-26 04:45:57 +07:00
|
|
|
{"i915_gem_framebuffer", i915_gem_framebuffer_info, 0},
|
2011-03-20 08:14:29 +07:00
|
|
|
{"i915_context_status", i915_context_status, 0},
|
2014-08-07 19:24:26 +07:00
|
|
|
{"i915_dump_lrc", i915_dump_lrc, 0},
|
2014-08-07 19:23:20 +07:00
|
|
|
{"i915_execlists", i915_execlists, 0},
|
2015-01-16 16:34:42 +07:00
|
|
|
{"i915_forcewake_domains", i915_forcewake_domains, 0},
|
2011-12-14 19:57:16 +07:00
|
|
|
{"i915_swizzle_info", i915_swizzle_info, 0},
|
2012-02-09 23:15:49 +07:00
|
|
|
{"i915_ppgtt_info", i915_ppgtt_info, 0},
|
2013-07-05 01:02:07 +07:00
|
|
|
{"i915_llc", i915_llc, 0},
|
2013-07-12 04:44:59 +07:00
|
|
|
{"i915_edp_psr_status", i915_edp_psr_status, 0},
|
2014-01-24 22:36:17 +07:00
|
|
|
{"i915_sink_crc_eDP1", i915_sink_crc, 0},
|
2013-08-20 16:29:23 +07:00
|
|
|
{"i915_energy_uJ", i915_energy_uJ, 0},
|
2013-08-19 23:18:10 +07:00
|
|
|
{"i915_pc8_status", i915_pc8_status, 0},
|
2013-11-25 22:15:35 +07:00
|
|
|
{"i915_power_domain_info", i915_power_domain_info, 0},
|
2014-02-08 03:48:15 +07:00
|
|
|
{"i915_display_info", i915_display_info, 0},
|
2014-06-30 23:53:42 +07:00
|
|
|
{"i915_semaphore_status", i915_semaphore_status, 0},
|
2014-06-26 02:01:53 +07:00
|
|
|
{"i915_shared_dplls_info", i915_shared_dplls_info, 0},
|
2014-05-12 12:22:27 +07:00
|
|
|
{"i915_dp_mst_info", i915_dp_mst_info, 0},
|
2014-08-30 22:50:59 +07:00
|
|
|
{"i915_wa_registers", i915_wa_registers, 0},
|
2014-11-05 00:06:51 +07:00
|
|
|
{"i915_ddb_info", i915_ddb_info, 0},
|
2015-02-13 23:27:54 +07:00
|
|
|
{"i915_sseu_status", i915_sseu_status, 0},
|
drm/i915: Add debugfs entry for DRRS
Adding a debugfs entry to determine if DRRS is supported or not
V2: [By Ram]: Following details about the active crtc will be filled
in seq-file of the debugfs
1. Encoder output type
2. DRRS Support on this CRTC
3. DRRS current state
4. Current Vrefresh
Format is as follows:
CRTC 1: Output: eDP, DRRS Supported: Yes (Seamless), DRRS_State: DRRS_HIGH_RR, Vrefresh: 60
CRTC 2: Output: HDMI, DRRS Supported : No, VBT DRRS_type: Seamless
CRTC 1: Output: eDP, DRRS Supported: Yes (Seamless), DRRS_State: DRRS_LOW_RR, Vrefresh: 40
CRTC 2: Output: HDMI, DRRS Supported : No, VBT DRRS_type: Seamless
V3: [By Ram]: Readability is improved.
Another error case is covered [Daniel]
V4: [By Ram]: Current status of the Idleness DRRS along with
the Front buffer bits are added to the debugfs. [Rodrigo]
V5: [By Ram]: Rephrased to make it easy to understand.
And format is modified. [Rodrigo]
V6: [By Ram]: Modeset mutex are acquired for each crtc along with
renaming the Idleness detection states [Daniel]
Signed-off-by: Vandana Kannan <vandana.kannan@intel.com>
Signed-off-by: Ramalingam C <ramalingam.c@intel.com>
Reviewed-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
[danvet: dump full busy_frontbuffer_bits and remove the dubios
computed logical state of DRRS - debugfs is about what is fact,
developers should reach their own conclusion when debugging issues.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-03-03 22:23:10 +07:00
|
|
|
{"i915_drrs_status", i915_drrs_status, 0},
|
2009-02-18 08:08:50 +07:00
|
|
|
};
|
2009-07-02 09:26:52 +07:00
|
|
|
#define I915_DEBUGFS_ENTRIES ARRAY_SIZE(i915_debugfs_list)
|
2009-02-18 08:08:50 +07:00
|
|
|
|
2013-10-18 01:09:56 +07:00
|
|
|
static const struct i915_debugfs_files {
|
2013-07-05 01:49:44 +07:00
|
|
|
const char *name;
|
|
|
|
const struct file_operations *fops;
|
|
|
|
} i915_debugfs_files[] = {
|
|
|
|
{"i915_wedged", &i915_wedged_fops},
|
|
|
|
{"i915_max_freq", &i915_max_freq_fops},
|
|
|
|
{"i915_min_freq", &i915_min_freq_fops},
|
|
|
|
{"i915_cache_sharing", &i915_cache_sharing_fops},
|
|
|
|
{"i915_ring_stop", &i915_ring_stop_fops},
|
2013-09-25 23:34:55 +07:00
|
|
|
{"i915_ring_missed_irq", &i915_ring_missed_irq_fops},
|
|
|
|
{"i915_ring_test_irq", &i915_ring_test_irq_fops},
|
2013-07-05 01:49:44 +07:00
|
|
|
{"i915_gem_drop_caches", &i915_drop_caches_fops},
|
|
|
|
{"i915_error_state", &i915_error_state_fops},
|
|
|
|
{"i915_next_seqno", &i915_next_seqno_fops},
|
2013-10-16 00:55:36 +07:00
|
|
|
{"i915_display_crc_ctl", &i915_display_crc_ctl_fops},
|
2014-01-22 19:36:08 +07:00
|
|
|
{"i915_pri_wm_latency", &i915_pri_wm_latency_fops},
|
|
|
|
{"i915_spr_wm_latency", &i915_spr_wm_latency_fops},
|
|
|
|
{"i915_cur_wm_latency", &i915_cur_wm_latency_fops},
|
2014-08-01 16:04:45 +07:00
|
|
|
{"i915_fbc_false_color", &i915_fbc_fc_fops},
|
2013-07-05 01:49:44 +07:00
|
|
|
};
|
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
void intel_display_crc_init(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-14 17:30:42 +07:00
|
|
|
enum pipe pipe;
|
2013-10-16 00:55:40 +07:00
|
|
|
|
2014-08-18 19:49:10 +07:00
|
|
|
for_each_pipe(dev_priv, pipe) {
|
2013-11-14 17:30:42 +07:00
|
|
|
struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
|
2013-10-16 00:55:40 +07:00
|
|
|
|
2013-10-21 20:29:30 +07:00
|
|
|
pipe_crc->opened = false;
|
|
|
|
spin_lock_init(&pipe_crc->lock);
|
2013-10-16 00:55:40 +07:00
|
|
|
init_waitqueue_head(&pipe_crc->wq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-02 09:26:52 +07:00
|
|
|
int i915_debugfs_init(struct drm_minor *minor)
|
2009-02-18 08:08:50 +07:00
|
|
|
{
|
2013-07-05 01:49:44 +07:00
|
|
|
int ret, i;
|
2009-10-14 04:20:20 +07:00
|
|
|
|
2011-04-26 01:25:56 +07:00
|
|
|
ret = i915_forcewake_create(minor->debugfs_root, minor);
|
2011-07-28 01:53:01 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-12-14 19:57:11 +07:00
|
|
|
|
2013-10-16 00:55:40 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
|
|
|
|
ret = i915_pipe_crc_create(minor->debugfs_root, minor, i);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-05 01:49:44 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
|
|
|
|
ret = i915_debugfs_create(minor->debugfs_root, minor,
|
|
|
|
i915_debugfs_files[i].name,
|
|
|
|
i915_debugfs_files[i].fops);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-12-04 20:12:00 +07:00
|
|
|
|
2009-07-02 09:26:52 +07:00
|
|
|
return drm_debugfs_create_files(i915_debugfs_list,
|
|
|
|
I915_DEBUGFS_ENTRIES,
|
2009-02-18 08:08:50 +07:00
|
|
|
minor->debugfs_root, minor);
|
|
|
|
}
|
|
|
|
|
2009-07-02 09:26:52 +07:00
|
|
|
void i915_debugfs_cleanup(struct drm_minor *minor)
|
2009-02-18 08:08:50 +07:00
|
|
|
{
|
2013-07-05 01:49:44 +07:00
|
|
|
int i;
|
|
|
|
|
2009-07-02 09:26:52 +07:00
|
|
|
drm_debugfs_remove_files(i915_debugfs_list,
|
|
|
|
I915_DEBUGFS_ENTRIES, minor);
|
2013-10-16 00:55:40 +07:00
|
|
|
|
2011-04-26 01:25:56 +07:00
|
|
|
drm_debugfs_remove_files((struct drm_info_list *) &i915_forcewake_fops,
|
|
|
|
1, minor);
|
2013-10-16 00:55:40 +07:00
|
|
|
|
2013-10-17 03:55:51 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
|
2013-10-16 00:55:40 +07:00
|
|
|
struct drm_info_list *info_list =
|
|
|
|
(struct drm_info_list *)&i915_pipe_crc_data[i];
|
|
|
|
|
|
|
|
drm_debugfs_remove_files(info_list, 1, minor);
|
|
|
|
}
|
|
|
|
|
2013-07-05 01:49:44 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
|
|
|
|
struct drm_info_list *info_list =
|
|
|
|
(struct drm_info_list *) i915_debugfs_files[i].fops;
|
|
|
|
|
|
|
|
drm_debugfs_remove_files(info_list, 1, minor);
|
|
|
|
}
|
2009-02-18 08:08:50 +07:00
|
|
|
}
|