2012-04-11 04:17:01 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2012 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:
|
|
|
|
* Ben Widawsky <ben@bwidawsk.net>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/sysfs.h>
|
2012-05-25 23:56:25 +00:00
|
|
|
#include "intel_drv.h"
|
2012-04-11 04:17:01 +00:00
|
|
|
#include "i915_drv.h"
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
static inline struct drm_i915_private *kdev_minor_to_i915(struct device *kdev)
|
2016-08-22 10:32:42 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_minor *minor = dev_get_drvdata(kdev);
|
|
|
|
return to_i915(minor->dev);
|
2016-08-22 10:32:42 +00:00
|
|
|
}
|
2013-10-11 04:45:30 +00:00
|
|
|
|
2012-07-01 03:45:07 +00:00
|
|
|
#ifdef CONFIG_PM
|
2016-08-22 10:32:43 +00:00
|
|
|
static u32 calc_residency(struct drm_i915_private *dev_priv,
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 13:33:26 +00:00
|
|
|
i915_reg_t reg)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
|
|
|
u64 raw_time; /* 32b value may overflow during fixed point math */
|
2015-09-28 20:43:43 +00:00
|
|
|
u64 units = 128ULL, div = 100000ULL;
|
2013-11-27 20:21:54 +00:00
|
|
|
u32 ret;
|
2012-04-11 04:17:01 +00:00
|
|
|
|
2016-05-10 13:10:04 +00:00
|
|
|
if (!intel_enable_rc6())
|
2012-04-11 04:17:01 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-11-27 20:21:54 +00:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2014-07-09 11:55:56 +00:00
|
|
|
/* On VLV and CHV, residency time is in CZ units rather than 1.28us */
|
2016-08-22 10:32:43 +00:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2015-09-28 20:43:43 +00:00
|
|
|
units = 1;
|
|
|
|
div = dev_priv->czclk_freq;
|
2014-07-09 11:55:56 +00:00
|
|
|
|
2013-09-27 00:55:58 +00:00
|
|
|
if (I915_READ(VLV_COUNTER_CONTROL) & VLV_COUNT_RANGE_HIGH)
|
|
|
|
units <<= 8;
|
2017-01-09 14:51:35 +00:00
|
|
|
} else if (IS_GEN9_LP(dev_priv)) {
|
2015-09-29 13:28:46 +00:00
|
|
|
units = 1;
|
|
|
|
div = 1200; /* 833.33ns */
|
2013-09-27 00:55:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
raw_time = I915_READ(reg) * units;
|
2013-11-27 20:21:54 +00:00
|
|
|
ret = DIV_ROUND_UP_ULL(raw_time, div);
|
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
return ret;
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2012-09-08 02:43:38 +00:00
|
|
|
show_rc6_mask(struct device *kdev, struct device_attribute *attr, char *buf)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-05-10 13:10:04 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%x\n", intel_enable_rc6());
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2012-09-08 02:43:38 +00:00
|
|
|
show_rc6_ms(struct device *kdev, struct device_attribute *attr, char *buf)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
u32 rc6_residency = calc_residency(dev_priv, GEN6_GT_GFX_RC6);
|
2013-02-14 08:42:11 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", rc6_residency);
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2012-09-08 02:43:38 +00:00
|
|
|
show_rc6p_ms(struct device *kdev, struct device_attribute *attr, char *buf)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
u32 rc6p_residency = calc_residency(dev_priv, GEN6_GT_GFX_RC6p);
|
2013-02-14 08:42:11 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", rc6p_residency);
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2012-09-08 02:43:38 +00:00
|
|
|
show_rc6pp_ms(struct device *kdev, struct device_attribute *attr, char *buf)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
u32 rc6pp_residency = calc_residency(dev_priv, GEN6_GT_GFX_RC6pp);
|
2013-02-14 08:42:11 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", rc6pp_residency);
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
2015-02-26 15:40:27 +00:00
|
|
|
static ssize_t
|
|
|
|
show_media_rc6_ms(struct device *kdev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
u32 rc6_residency = calc_residency(dev_priv, VLV_GT_MEDIA_RC6);
|
2015-02-26 15:40:27 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", rc6_residency);
|
|
|
|
}
|
|
|
|
|
2012-04-11 04:17:01 +00:00
|
|
|
static DEVICE_ATTR(rc6_enable, S_IRUGO, show_rc6_mask, NULL);
|
|
|
|
static DEVICE_ATTR(rc6_residency_ms, S_IRUGO, show_rc6_ms, NULL);
|
|
|
|
static DEVICE_ATTR(rc6p_residency_ms, S_IRUGO, show_rc6p_ms, NULL);
|
|
|
|
static DEVICE_ATTR(rc6pp_residency_ms, S_IRUGO, show_rc6pp_ms, NULL);
|
2015-02-26 15:40:27 +00:00
|
|
|
static DEVICE_ATTR(media_rc6_residency_ms, S_IRUGO, show_media_rc6_ms, NULL);
|
2012-04-11 04:17:01 +00:00
|
|
|
|
|
|
|
static struct attribute *rc6_attrs[] = {
|
|
|
|
&dev_attr_rc6_enable.attr,
|
|
|
|
&dev_attr_rc6_residency_ms.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group rc6_attr_group = {
|
|
|
|
.name = power_group_name,
|
|
|
|
.attrs = rc6_attrs
|
|
|
|
};
|
2014-10-07 14:06:50 +00:00
|
|
|
|
|
|
|
static struct attribute *rc6p_attrs[] = {
|
|
|
|
&dev_attr_rc6p_residency_ms.attr,
|
|
|
|
&dev_attr_rc6pp_residency_ms.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group rc6p_attr_group = {
|
|
|
|
.name = power_group_name,
|
|
|
|
.attrs = rc6p_attrs
|
|
|
|
};
|
2015-02-26 15:40:27 +00:00
|
|
|
|
|
|
|
static struct attribute *media_rc6_attrs[] = {
|
|
|
|
&dev_attr_media_rc6_residency_ms.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group media_rc6_attr_group = {
|
|
|
|
.name = power_group_name,
|
|
|
|
.attrs = media_rc6_attrs
|
|
|
|
};
|
2012-09-02 07:24:40 +00:00
|
|
|
#endif
|
2012-04-11 04:17:01 +00:00
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
static int l3_access_valid(struct drm_i915_private *dev_priv, loff_t offset)
|
2012-05-25 23:56:25 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
if (!HAS_L3_DPF(dev_priv))
|
2012-05-25 23:56:25 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (offset % 4 != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (offset >= GEN7_L3LOG_SIZE)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
i915_l3_read(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf,
|
|
|
|
loff_t offset, size_t count)
|
|
|
|
{
|
2016-08-22 10:32:42 +00:00
|
|
|
struct device *kdev = kobj_to_dev(kobj);
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
struct drm_device *dev = &dev_priv->drm;
|
2013-09-19 18:13:41 +00:00
|
|
|
int slice = (int)(uintptr_t)attr->private;
|
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 02:03:18 +00:00
|
|
|
int ret;
|
2012-05-25 23:56:25 +00:00
|
|
|
|
2013-09-13 05:28:28 +00:00
|
|
|
count = round_down(count, 4);
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
ret = l3_access_valid(dev_priv, offset);
|
2012-05-25 23:56:25 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-09-20 11:20:18 +00:00
|
|
|
count = min_t(size_t, GEN7_L3LOG_SIZE - offset, count);
|
2013-09-13 05:28:29 +00:00
|
|
|
|
2016-08-22 10:32:42 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2012-05-25 23:56:25 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
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 02:03:18 +00:00
|
|
|
if (dev_priv->l3_parity.remap_info[slice])
|
|
|
|
memcpy(buf,
|
|
|
|
dev_priv->l3_parity.remap_info[slice] + (offset/4),
|
|
|
|
count);
|
|
|
|
else
|
|
|
|
memset(buf, 0, count);
|
2012-05-25 23:56:25 +00:00
|
|
|
|
2016-08-22 10:32:42 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2012-05-25 23:56:25 +00:00
|
|
|
|
2013-09-18 04:12:42 +00:00
|
|
|
return count;
|
2012-05-25 23:56:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
i915_l3_write(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf,
|
|
|
|
loff_t offset, size_t count)
|
|
|
|
{
|
2016-08-22 10:32:42 +00:00
|
|
|
struct device *kdev = kobj_to_dev(kobj);
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
struct drm_device *dev = &dev_priv->drm;
|
2016-05-24 13:53:34 +00:00
|
|
|
struct i915_gem_context *ctx;
|
2012-05-25 23:56:25 +00:00
|
|
|
u32 *temp = NULL; /* Just here to make handling failures easy */
|
2013-09-19 18:13:41 +00:00
|
|
|
int slice = (int)(uintptr_t)attr->private;
|
2012-05-25 23:56:25 +00:00
|
|
|
int ret;
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
if (!HAS_HW_CONTEXTS(dev_priv))
|
2013-11-06 15:56:29 +00:00
|
|
|
return -ENXIO;
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
ret = l3_access_valid(dev_priv, offset);
|
2012-05-25 23:56:25 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-08-22 10:32:42 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2012-05-25 23:56:25 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-09-19 18:13:41 +00:00
|
|
|
if (!dev_priv->l3_parity.remap_info[slice]) {
|
2012-05-25 23:56:25 +00:00
|
|
|
temp = kzalloc(GEN7_L3LOG_SIZE, GFP_KERNEL);
|
|
|
|
if (!temp) {
|
2016-08-22 10:32:42 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2012-05-25 23:56:25 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: Ideally we really want a GPU reset here to make sure errors
|
|
|
|
* aren't propagated. Since I cannot find a stable way to reset the GPU
|
|
|
|
* at this point it is left as a TODO.
|
|
|
|
*/
|
|
|
|
if (temp)
|
2013-09-19 18:13:41 +00:00
|
|
|
dev_priv->l3_parity.remap_info[slice] = temp;
|
2012-05-25 23:56:25 +00:00
|
|
|
|
2013-09-19 18:13:41 +00:00
|
|
|
memcpy(dev_priv->l3_parity.remap_info[slice] + (offset/4), buf, count);
|
2012-05-25 23:56:25 +00:00
|
|
|
|
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 02:03:18 +00:00
|
|
|
/* NB: We defer the remapping until we switch to the context */
|
|
|
|
list_for_each_entry(ctx, &dev_priv->context_list, link)
|
|
|
|
ctx->remap_slice |= (1<<slice);
|
2012-05-25 23:56:25 +00:00
|
|
|
|
2016-08-22 10:32:42 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2012-05-25 23:56:25 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute dpf_attrs = {
|
|
|
|
.attr = {.name = "l3_parity", .mode = (S_IRUSR | S_IWUSR)},
|
|
|
|
.size = GEN7_L3LOG_SIZE,
|
|
|
|
.read = i915_l3_read,
|
|
|
|
.write = i915_l3_write,
|
2013-09-19 18:13:41 +00:00
|
|
|
.mmap = NULL,
|
|
|
|
.private = (void *)0
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bin_attribute dpf_attrs_1 = {
|
|
|
|
.attr = {.name = "l3_parity_slice_1", .mode = (S_IRUSR | S_IWUSR)},
|
|
|
|
.size = GEN7_L3LOG_SIZE,
|
|
|
|
.read = i915_l3_read,
|
|
|
|
.write = i915_l3_write,
|
|
|
|
.mmap = NULL,
|
|
|
|
.private = (void *)1
|
2012-05-25 23:56:25 +00:00
|
|
|
};
|
|
|
|
|
2015-01-23 19:04:24 +00:00
|
|
|
static ssize_t gt_act_freq_mhz_show(struct device *kdev,
|
2012-09-08 02:43:40 +00:00
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2012-09-08 02:43:40 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-04-14 17:24:27 +00:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
2015-12-09 20:29:35 +00:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2013-05-02 17:48:07 +00:00
|
|
|
u32 freq;
|
2013-05-22 12:36:20 +00:00
|
|
|
freq = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS);
|
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-23 19:04:26 +00:00
|
|
|
ret = intel_gpu_freq(dev_priv, (freq >> 8) & 0xff);
|
2015-01-23 19:04:24 +00:00
|
|
|
} else {
|
|
|
|
u32 rpstat = I915_READ(GEN6_RPSTAT1);
|
2015-03-06 05:37:22 +00:00
|
|
|
if (IS_GEN9(dev_priv))
|
|
|
|
ret = (rpstat & GEN9_CAGF_MASK) >> GEN9_CAGF_SHIFT;
|
|
|
|
else if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv))
|
2015-01-23 19:04:24 +00:00
|
|
|
ret = (rpstat & HSW_CAGF_MASK) >> HSW_CAGF_SHIFT;
|
|
|
|
else
|
|
|
|
ret = (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-23 19:04:26 +00:00
|
|
|
ret = intel_gpu_freq(dev_priv, ret);
|
2015-01-23 19:04:24 +00:00
|
|
|
}
|
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
|
|
|
|
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2012-09-08 02:43:40 +00:00
|
|
|
|
2016-07-13 08:10:36 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
intel_gpu_freq(dev_priv,
|
|
|
|
dev_priv->rps.cur_freq));
|
2012-09-08 02:43:40 +00:00
|
|
|
}
|
|
|
|
|
2016-07-13 08:10:35 +00:00
|
|
|
static ssize_t gt_boost_freq_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2016-07-13 08:10:35 +00:00
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
2016-07-13 08:10:36 +00:00
|
|
|
intel_gpu_freq(dev_priv,
|
|
|
|
dev_priv->rps.boost_freq));
|
2016-07-13 08:10:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t gt_boost_freq_mhz_store(struct device *kdev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2016-07-13 08:10:35 +00:00
|
|
|
u32 val;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = kstrtou32(buf, 0, &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Validate against (static) hardware limits */
|
|
|
|
val = intel_freq_opcode(dev_priv, val);
|
|
|
|
if (val < dev_priv->rps.min_freq || val > dev_priv->rps.max_freq)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
|
|
|
dev_priv->rps.boost_freq = val;
|
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2013-08-26 15:18:54 +00:00
|
|
|
static ssize_t vlv_rpe_freq_mhz_show(struct device *kdev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2013-08-26 15:18:54 +00:00
|
|
|
|
2016-07-13 08:10:36 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
intel_gpu_freq(dev_priv,
|
|
|
|
dev_priv->rps.efficient_freq));
|
2013-08-26 15:18:54 +00:00
|
|
|
}
|
|
|
|
|
2012-09-08 02:43:40 +00:00
|
|
|
static ssize_t gt_max_freq_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2013-09-16 21:56:43 +00:00
|
|
|
|
2016-07-13 08:10:36 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
intel_gpu_freq(dev_priv,
|
|
|
|
dev_priv->rps.max_freq_softlimit));
|
2012-09-08 02:43:40 +00:00
|
|
|
}
|
|
|
|
|
2012-09-13 01:12:07 +00:00
|
|
|
static ssize_t gt_max_freq_mhz_store(struct device *kdev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2014-03-20 01:31:13 +00:00
|
|
|
u32 val;
|
2012-09-13 01:12:07 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = kstrtou32(buf, 0, &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
2012-09-13 01:12:07 +00: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-23 19:04:26 +00:00
|
|
|
val = intel_freq_opcode(dev_priv, val);
|
2012-09-13 01:12:07 +00:00
|
|
|
|
2014-03-20 01:31:13 +00:00
|
|
|
if (val < dev_priv->rps.min_freq ||
|
|
|
|
val > dev_priv->rps.max_freq ||
|
2014-03-20 01:31:11 +00:00
|
|
|
val < dev_priv->rps.min_freq_softlimit) {
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2012-09-13 01:12:07 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-03-20 01:31:13 +00:00
|
|
|
if (val > dev_priv->rps.rp0_freq)
|
2013-04-05 21:29:22 +00:00
|
|
|
DRM_DEBUG("User requested overclocking to %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-23 19:04:26 +00:00
|
|
|
intel_gpu_freq(dev_priv, val));
|
2013-04-05 21:29:22 +00:00
|
|
|
|
2014-03-20 01:31:11 +00:00
|
|
|
dev_priv->rps.max_freq_softlimit = val;
|
2013-11-06 15:56:26 +00:00
|
|
|
|
2015-01-23 19:04:23 +00:00
|
|
|
val = clamp_t(int, dev_priv->rps.cur_freq,
|
|
|
|
dev_priv->rps.min_freq_softlimit,
|
|
|
|
dev_priv->rps.max_freq_softlimit);
|
|
|
|
|
|
|
|
/* We still need *_set_rps to process the new max_delay and
|
|
|
|
* update the interrupt limits and PMINTRMSK even though
|
|
|
|
* frequency request may be unchanged. */
|
2017-01-26 10:19:19 +00:00
|
|
|
ret = intel_set_rps(dev_priv, val);
|
2012-09-13 01:12:07 +00:00
|
|
|
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2012-09-13 01:12:07 +00:00
|
|
|
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2017-01-26 10:19:19 +00:00
|
|
|
return ret ?: count;
|
2012-09-13 01:12:07 +00:00
|
|
|
}
|
|
|
|
|
2012-09-08 02:43:40 +00:00
|
|
|
static ssize_t gt_min_freq_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2012-09-08 02:43:40 +00:00
|
|
|
|
2016-07-13 08:10:36 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
intel_gpu_freq(dev_priv,
|
|
|
|
dev_priv->rps.min_freq_softlimit));
|
2012-09-08 02:43:40 +00:00
|
|
|
}
|
|
|
|
|
2012-09-13 01:12:07 +00:00
|
|
|
static ssize_t gt_min_freq_mhz_store(struct device *kdev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2014-03-20 01:31:13 +00:00
|
|
|
u32 val;
|
2012-09-13 01:12:07 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = kstrtou32(buf, 0, &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
|
|
|
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_lock(&dev_priv->rps.hw_lock);
|
2012-09-13 01:12:07 +00: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-23 19:04:26 +00:00
|
|
|
val = intel_freq_opcode(dev_priv, val);
|
2013-04-17 22:54:58 +00:00
|
|
|
|
2014-03-20 01:31:13 +00:00
|
|
|
if (val < dev_priv->rps.min_freq ||
|
|
|
|
val > dev_priv->rps.max_freq ||
|
|
|
|
val > dev_priv->rps.max_freq_softlimit) {
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2012-09-13 01:12:07 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-03-20 01:31:11 +00:00
|
|
|
dev_priv->rps.min_freq_softlimit = val;
|
2013-11-06 15:56:26 +00:00
|
|
|
|
2015-01-23 19:04:23 +00:00
|
|
|
val = clamp_t(int, dev_priv->rps.cur_freq,
|
|
|
|
dev_priv->rps.min_freq_softlimit,
|
|
|
|
dev_priv->rps.max_freq_softlimit);
|
|
|
|
|
|
|
|
/* We still need *_set_rps to process the new min_delay and
|
|
|
|
* update the interrupt limits and PMINTRMSK even though
|
|
|
|
* frequency request may be unchanged. */
|
2017-01-26 10:19:19 +00:00
|
|
|
ret = intel_set_rps(dev_priv, val);
|
2012-09-13 01:12:07 +00:00
|
|
|
|
2012-11-02 18:14:01 +00:00
|
|
|
mutex_unlock(&dev_priv->rps.hw_lock);
|
2012-09-13 01:12:07 +00:00
|
|
|
|
2016-02-08 17:17:11 +00:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
|
|
|
|
2017-01-26 10:19:19 +00:00
|
|
|
return ret ?: count;
|
2012-09-13 01:12:07 +00:00
|
|
|
}
|
|
|
|
|
2015-01-23 19:04:24 +00:00
|
|
|
static DEVICE_ATTR(gt_act_freq_mhz, S_IRUGO, gt_act_freq_mhz_show, NULL);
|
2012-09-08 02:43:40 +00:00
|
|
|
static DEVICE_ATTR(gt_cur_freq_mhz, S_IRUGO, gt_cur_freq_mhz_show, NULL);
|
2016-12-14 12:26:20 +00:00
|
|
|
static DEVICE_ATTR(gt_boost_freq_mhz, S_IRUGO | S_IWUSR, gt_boost_freq_mhz_show, gt_boost_freq_mhz_store);
|
2012-09-13 01:12:07 +00:00
|
|
|
static DEVICE_ATTR(gt_max_freq_mhz, S_IRUGO | S_IWUSR, gt_max_freq_mhz_show, gt_max_freq_mhz_store);
|
|
|
|
static DEVICE_ATTR(gt_min_freq_mhz, S_IRUGO | S_IWUSR, gt_min_freq_mhz_show, gt_min_freq_mhz_store);
|
2012-09-08 02:43:40 +00:00
|
|
|
|
2013-08-26 15:18:54 +00:00
|
|
|
static DEVICE_ATTR(vlv_rpe_freq_mhz, S_IRUGO, vlv_rpe_freq_mhz_show, NULL);
|
2012-09-08 02:43:44 +00:00
|
|
|
|
|
|
|
static ssize_t gt_rp_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf);
|
|
|
|
static DEVICE_ATTR(gt_RP0_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL);
|
|
|
|
static DEVICE_ATTR(gt_RP1_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL);
|
|
|
|
static DEVICE_ATTR(gt_RPn_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL);
|
|
|
|
|
|
|
|
/* For now we have a static number of RP states */
|
|
|
|
static ssize_t gt_rp_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
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 10:39:47 +00:00
|
|
|
u32 val;
|
2012-09-08 02:43:44 +00: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 10:39:47 +00:00
|
|
|
if (attr == &dev_attr_gt_RP0_freq_mhz)
|
|
|
|
val = intel_gpu_freq(dev_priv, dev_priv->rps.rp0_freq);
|
|
|
|
else if (attr == &dev_attr_gt_RP1_freq_mhz)
|
|
|
|
val = intel_gpu_freq(dev_priv, dev_priv->rps.rp1_freq);
|
|
|
|
else if (attr == &dev_attr_gt_RPn_freq_mhz)
|
|
|
|
val = intel_gpu_freq(dev_priv, dev_priv->rps.min_freq);
|
|
|
|
else
|
2012-09-08 02:43:44 +00:00
|
|
|
BUG();
|
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 10:39:47 +00:00
|
|
|
|
2013-02-14 08:42:11 +00:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", val);
|
2012-09-08 02:43:44 +00:00
|
|
|
}
|
|
|
|
|
2012-09-08 02:43:40 +00:00
|
|
|
static const struct attribute *gen6_attrs[] = {
|
2015-01-23 19:04:24 +00:00
|
|
|
&dev_attr_gt_act_freq_mhz.attr,
|
2012-09-08 02:43:40 +00:00
|
|
|
&dev_attr_gt_cur_freq_mhz.attr,
|
2016-07-13 08:10:35 +00:00
|
|
|
&dev_attr_gt_boost_freq_mhz.attr,
|
2012-09-08 02:43:40 +00:00
|
|
|
&dev_attr_gt_max_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_min_freq_mhz.attr,
|
2012-09-08 02:43:44 +00:00
|
|
|
&dev_attr_gt_RP0_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_RP1_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_RPn_freq_mhz.attr,
|
2012-09-08 02:43:40 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2013-08-26 15:18:54 +00:00
|
|
|
static const struct attribute *vlv_attrs[] = {
|
2015-01-23 19:04:24 +00:00
|
|
|
&dev_attr_gt_act_freq_mhz.attr,
|
2013-08-26 15:18:54 +00:00
|
|
|
&dev_attr_gt_cur_freq_mhz.attr,
|
2016-07-13 08:10:35 +00:00
|
|
|
&dev_attr_gt_boost_freq_mhz.attr,
|
2013-08-26 15:18:54 +00:00
|
|
|
&dev_attr_gt_max_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_min_freq_mhz.attr,
|
2014-07-10 07:46:22 +00:00
|
|
|
&dev_attr_gt_RP0_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_RP1_freq_mhz.attr,
|
|
|
|
&dev_attr_gt_RPn_freq_mhz.attr,
|
2013-08-26 15:18:54 +00:00
|
|
|
&dev_attr_vlv_rpe_freq_mhz.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2016-10-12 09:05:18 +00:00
|
|
|
#if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR)
|
|
|
|
|
2013-06-06 14:38:54 +00:00
|
|
|
static ssize_t error_state_read(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf,
|
|
|
|
loff_t off, size_t count)
|
|
|
|
{
|
|
|
|
|
2016-01-13 14:48:40 +00:00
|
|
|
struct device *kdev = kobj_to_dev(kobj);
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
|
|
|
struct drm_device *dev = &dev_priv->drm;
|
2013-06-06 14:38:54 +00:00
|
|
|
struct i915_error_state_file_priv error_priv;
|
|
|
|
struct drm_i915_error_state_buf error_str;
|
|
|
|
ssize_t ret_count = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(&error_priv, 0, sizeof(error_priv));
|
|
|
|
|
2014-08-22 13:41:39 +00:00
|
|
|
ret = i915_error_state_buf_init(&error_str, to_i915(dev), count, off);
|
2013-06-06 14:38:54 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-12-01 14:16:43 +00:00
|
|
|
error_priv.i915 = dev_priv;
|
2013-06-06 14:38:54 +00:00
|
|
|
i915_error_state_get(dev, &error_priv);
|
|
|
|
|
|
|
|
ret = i915_error_state_to_str(&error_str, &error_priv);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret_count = count < error_str.bytes ? count : error_str.bytes;
|
|
|
|
|
|
|
|
memcpy(buf, error_str.buf, ret_count);
|
|
|
|
out:
|
|
|
|
i915_error_state_put(&error_priv);
|
|
|
|
i915_error_state_buf_release(&error_str);
|
|
|
|
|
|
|
|
return ret ?: ret_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t error_state_write(struct file *file, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf,
|
|
|
|
loff_t off, size_t count)
|
|
|
|
{
|
2016-01-13 14:48:40 +00:00
|
|
|
struct device *kdev = kobj_to_dev(kobj);
|
2016-08-22 10:32:43 +00:00
|
|
|
struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev);
|
2013-06-06 14:38:54 +00:00
|
|
|
|
|
|
|
DRM_DEBUG_DRIVER("Resetting error state\n");
|
2016-12-01 14:16:43 +00:00
|
|
|
i915_destroy_error_state(dev_priv);
|
2013-06-06 14:38:54 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute error_state_attr = {
|
|
|
|
.attr.name = "error",
|
|
|
|
.attr.mode = S_IRUSR | S_IWUSR,
|
|
|
|
.size = 0,
|
|
|
|
.read = error_state_read,
|
|
|
|
.write = error_state_write,
|
|
|
|
};
|
|
|
|
|
2016-10-12 09:05:18 +00:00
|
|
|
static void i915_setup_error_capture(struct device *kdev)
|
|
|
|
{
|
|
|
|
if (sysfs_create_bin_file(&kdev->kobj, &error_state_attr))
|
|
|
|
DRM_ERROR("error_state sysfs setup failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_teardown_error_capture(struct device *kdev)
|
|
|
|
{
|
|
|
|
sysfs_remove_bin_file(&kdev->kobj, &error_state_attr);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void i915_setup_error_capture(struct device *kdev) {}
|
|
|
|
static void i915_teardown_error_capture(struct device *kdev) {}
|
|
|
|
#endif
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
void i915_setup_sysfs(struct drm_i915_private *dev_priv)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct device *kdev = dev_priv->drm.primary->kdev;
|
2012-04-11 04:17:01 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-09-02 07:24:40 +00:00
|
|
|
#ifdef CONFIG_PM
|
2016-08-22 10:32:43 +00:00
|
|
|
if (HAS_RC6(dev_priv)) {
|
|
|
|
ret = sysfs_merge_group(&kdev->kobj,
|
2012-05-31 12:57:43 +00:00
|
|
|
&rc6_attr_group);
|
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("RC6 residency sysfs setup failed\n");
|
|
|
|
}
|
2016-08-22 10:32:43 +00:00
|
|
|
if (HAS_RC6p(dev_priv)) {
|
|
|
|
ret = sysfs_merge_group(&kdev->kobj,
|
2014-10-07 14:06:50 +00:00
|
|
|
&rc6p_attr_group);
|
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("RC6p residency sysfs setup failed\n");
|
|
|
|
}
|
2016-08-22 10:32:43 +00:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
|
|
|
ret = sysfs_merge_group(&kdev->kobj,
|
2015-02-26 15:40:27 +00:00
|
|
|
&media_rc6_attr_group);
|
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("Media RC6 residency sysfs setup failed\n");
|
|
|
|
}
|
2012-09-02 07:24:40 +00:00
|
|
|
#endif
|
2016-08-22 10:32:43 +00:00
|
|
|
if (HAS_L3_DPF(dev_priv)) {
|
|
|
|
ret = device_create_bin_file(kdev, &dpf_attrs);
|
2012-05-31 12:57:43 +00:00
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("l3 parity sysfs setup failed\n");
|
2013-09-19 18:13:41 +00:00
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
if (NUM_L3_SLICES(dev_priv) > 1) {
|
|
|
|
ret = device_create_bin_file(kdev,
|
2013-09-19 18:13:41 +00:00
|
|
|
&dpf_attrs_1);
|
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("l3 parity slice 1 setup failed\n");
|
|
|
|
}
|
2012-05-31 12:57:43 +00:00
|
|
|
}
|
2012-09-08 02:43:40 +00:00
|
|
|
|
2013-08-26 15:18:54 +00:00
|
|
|
ret = 0;
|
2016-08-22 10:32:43 +00:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
|
|
|
ret = sysfs_create_files(&kdev->kobj, vlv_attrs);
|
|
|
|
else if (INTEL_GEN(dev_priv) >= 6)
|
|
|
|
ret = sysfs_create_files(&kdev->kobj, gen6_attrs);
|
2013-08-26 15:18:54 +00:00
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("RPS sysfs setup failed\n");
|
2013-06-06 14:38:54 +00:00
|
|
|
|
2016-10-12 09:05:18 +00:00
|
|
|
i915_setup_error_capture(kdev);
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
void i915_teardown_sysfs(struct drm_i915_private *dev_priv)
|
2012-04-11 04:17:01 +00:00
|
|
|
{
|
2016-08-22 10:32:43 +00:00
|
|
|
struct device *kdev = dev_priv->drm.primary->kdev;
|
|
|
|
|
2016-10-12 09:05:18 +00:00
|
|
|
i915_teardown_error_capture(kdev);
|
|
|
|
|
2016-08-22 10:32:43 +00:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
|
|
|
sysfs_remove_files(&kdev->kobj, vlv_attrs);
|
2013-08-26 15:18:54 +00:00
|
|
|
else
|
2016-08-22 10:32:43 +00:00
|
|
|
sysfs_remove_files(&kdev->kobj, gen6_attrs);
|
|
|
|
device_remove_bin_file(kdev, &dpf_attrs_1);
|
|
|
|
device_remove_bin_file(kdev, &dpf_attrs);
|
2012-09-19 17:50:19 +00:00
|
|
|
#ifdef CONFIG_PM
|
2016-08-22 10:32:43 +00:00
|
|
|
sysfs_unmerge_group(&kdev->kobj, &rc6_attr_group);
|
|
|
|
sysfs_unmerge_group(&kdev->kobj, &rc6p_attr_group);
|
2012-09-19 17:50:19 +00:00
|
|
|
#endif
|
2012-04-11 04:17:01 +00:00
|
|
|
}
|