* [PATCH v4 2/2] drm/xe: Add sysfs to disable RPe
2026-11-19 22:29 [PATCH v4 1/2] drm/xe: Disallow freq changes while mert cap is active Vinay Belgaumkar
@ 2026-11-19 22:30 ` Vinay Belgaumkar
2026-11-19 22:50 ` sashiko-bot
2026-11-19 22:57 ` [PATCH v4 1/2] drm/xe: Disallow freq changes while mert cap is active sashiko-bot
1 sibling, 1 reply; 4+ messages in thread
From: Vinay Belgaumkar @ 2026-11-19 22:30 UTC (permalink / raw)
To: intel-xe; +Cc: Vinay Belgaumkar, Sk Anirban
When SLPC is initialized, GuC sets the GT min freq to RPe(efficient) by
default. This frequency is desgined for optimal perf/power ratio. However,
certain use cases may want to run at lower frequencies. This sysfs allows
user to disable use of default RPe behavior.
Efficient frequency will now be controlled by this interface alone. Setting
min_freq < efficient will not disable RPe. When RPe is enabled, GuC raises
min to RPe and lowers it back when disabled.
Update pc_set_mert_freq_cap() to now disable RPe before stashing min freq.
This ensures we are saving the real min freq instead of the elevated one.
$ cat /sys/class/drm/card0/device/tile0/gt1/freq0/use_rpe
1
v2: Address Sashiko comments.
v3: Disable RPe before stashing freq before mert cap (Sashiko)
v4: Disable RPe inside pc_adjust_freq_bounds (Sashiko), make use_rpe a
bool (Anirban)
Cc: Sk Anirban <sk.anirban@intel.com>
Signed-off-by: Vinay Belgaumkar <vinay.belgaumkar@intel.com>
---
drivers/gpu/drm/xe/xe_gt_freq.c | 35 ++++++++++++
drivers/gpu/drm/xe/xe_guc_pc.c | 80 ++++++++++++++++++++++++----
drivers/gpu/drm/xe/xe_guc_pc.h | 1 +
drivers/gpu/drm/xe/xe_guc_pc_types.h | 2 +
4 files changed, 109 insertions(+), 9 deletions(-)
diff --git a/drivers/gpu/drm/xe/xe_gt_freq.c b/drivers/gpu/drm/xe/xe_gt_freq.c
index a40dd074106f..38c4f17ba99c 100644
--- a/drivers/gpu/drm/xe/xe_gt_freq.c
+++ b/drivers/gpu/drm/xe/xe_gt_freq.c
@@ -242,6 +242,40 @@ static ssize_t power_profile_store(struct kobject *kobj,
}
static struct kobj_attribute attr_power_profile = __ATTR_RW(power_profile);
+static ssize_t use_rpe_show(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ char *buff)
+{
+ struct device *dev = kobj_to_dev(kobj);
+ struct xe_guc_pc *pc = dev_to_pc(dev);
+
+ return sysfs_emit(buff, "%u\n", pc->use_rpe);
+}
+
+static ssize_t use_rpe_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buff, size_t count)
+{
+ struct device *dev = kobj_to_dev(kobj);
+ struct xe_guc_pc *pc = dev_to_pc(dev);
+ int err;
+ u32 val;
+
+ err = kstrtou32(buff, 0, &val);
+ if (err)
+ return err;
+
+ if (val > 1)
+ return -EINVAL;
+
+ guard(xe_pm_runtime)(dev_to_xe(dev));
+ err = xe_guc_pc_set_use_rpe(pc, val);
+
+ return err ?: count;
+}
+
+static struct kobj_attribute attr_use_rpe = __ATTR_RW(use_rpe);
+
static const struct attribute *freq_attrs[] = {
&attr_act_freq.attr,
&attr_cur_freq.attr,
@@ -252,6 +286,7 @@ static const struct attribute *freq_attrs[] = {
&attr_min_freq.attr,
&attr_max_freq.attr,
&attr_power_profile.attr,
+ &attr_use_rpe.attr,
NULL
};
diff --git a/drivers/gpu/drm/xe/xe_guc_pc.c b/drivers/gpu/drm/xe/xe_guc_pc.c
index ea47b0ded83a..0f98e8e48c57 100644
--- a/drivers/gpu/drm/xe/xe_guc_pc.c
+++ b/drivers/gpu/drm/xe/xe_guc_pc.c
@@ -344,6 +344,21 @@ static void pc_set_cur_freq(struct xe_guc_pc *pc, u32 freq)
pc_set_manual_rp_ctrl(pc, false);
}
+static int pc_set_ignore_eff_freq(struct xe_guc_pc *pc, u32 val)
+{
+ struct xe_gt *gt = pc_to_gt(pc);
+ int ret;
+
+ xe_device_assert_mem_access(pc_to_xe(pc));
+
+ ret = pc_action_set_param(pc, SLPC_PARAM_IGNORE_EFFICIENT_FREQUENCY, val);
+ if (ret)
+ xe_gt_err_once(gt, "Failed to set ignore_eff_freq to %u, %pe\n",
+ val, ERR_PTR(ret));
+
+ return ret;
+}
+
static bool pc_freq_in_range(struct xe_guc_pc *pc, u32 freq)
{
/*
@@ -358,13 +373,6 @@ static int pc_set_min_freq(struct xe_guc_pc *pc, u32 freq)
if (!pc_freq_in_range(pc, freq))
return -EINVAL;
- /*
- * GuC policy is to elevate minimum frequency to the efficient levels
- * Our goal is to have the admin choices respected.
- */
- pc_action_set_param(pc, SLPC_PARAM_IGNORE_EFFICIENT_FREQUENCY,
- freq < xe_guc_pc_get_rpe_freq(pc));
-
return pc_action_set_param(pc,
SLPC_PARAM_GLOBAL_MIN_GT_UNSLICE_FREQ_MHZ,
freq);
@@ -935,6 +943,15 @@ static int pc_adjust_freq_bounds(struct xe_guc_pc *pc)
lockdep_assert_held(&pc->freq_lock);
+ /*
+ * GuC enables RPe by default during SLPC reset, regardless of
+ * use_rpe. Disable it so min_freq below reflects the true GT min
+ * freq.
+ */
+ ret = pc_set_ignore_eff_freq(pc, 1);
+ if (ret)
+ goto out;
+
ret = pc_action_query_task_state(pc);
if (ret)
goto out;
@@ -1091,12 +1108,23 @@ void xe_guc_pc_remove_flush_freq_limit(struct xe_guc_pc *pc)
static int pc_set_mert_freq_cap(struct xe_guc_pc *pc)
{
int ret;
+ u32 mert_freq_cap;
if (!XE_GT_WA(pc_to_gt(pc), 22019338487))
return 0;
guard(mutex)(&pc->freq_lock);
+ /*
+ * Disable the RPe floor so the min queried below reflects the real
+ * underlying minimum (RPn or user_requested_min) instead of a value
+ * GuC may have elevated to RPe. This stays disabled until
+ * xe_guc_pc_restore_stashed_freq() reinstates it.
+ */
+ ret = pc_set_ignore_eff_freq(pc, 1);
+ if (ret)
+ return ret;
+
/*
* Get updated min/max and stash them.
*/
@@ -1109,7 +1137,9 @@ static int pc_set_mert_freq_cap(struct xe_guc_pc *pc)
/*
* Ensure min and max are bound by MERT_FREQ_CAP until driver loads.
*/
- ret = pc_set_min_freq(pc, min(xe_guc_pc_get_rpe_freq(pc), pc_max_freq_cap(pc)));
+ mert_freq_cap = min(xe_guc_pc_get_rpe_freq(pc), pc_max_freq_cap(pc));
+
+ ret = pc_set_min_freq(pc, mert_freq_cap);
if (!ret)
ret = pc_set_max_freq(pc, min(pc->rp0_freq, pc_max_freq_cap(pc)));
@@ -1136,9 +1166,11 @@ int xe_guc_pc_restore_stashed_freq(struct xe_guc_pc *pc)
mutex_lock(&pc->freq_lock);
/* Apply any user min/max request made while the cap was active, else the stash. */
ret = pc_set_max_freq(pc, pc->user_requested_max ?: pc->stashed_max_freq);
-
if (!ret)
ret = pc_set_min_freq(pc, pc->user_requested_min ?: pc->stashed_min_freq);
+ /* Restore ignore_eff_freq override from pc_set_mert_freq_cap(). */
+ if (!ret)
+ ret = pc_set_ignore_eff_freq(pc, !pc->use_rpe);
if (!ret)
pc->mert_freq_cap_active = false;
mutex_unlock(&pc->freq_lock);
@@ -1192,6 +1224,31 @@ static int pc_action_set_strategy(struct xe_guc_pc *pc, u32 val)
return ret;
}
+int xe_guc_pc_set_use_rpe(struct xe_guc_pc *pc, u32 val)
+{
+ int ret = 0;
+
+ guard(mutex)(&pc->freq_lock);
+
+ /* Might be in the middle of a gt reset */
+ if (!pc->freq_ready)
+ return -EAGAIN;
+
+ if (!pc->mert_freq_cap_active) {
+ /*
+ * If use_rpe == 1, ignore_eff_freq = false. GuC elevates min_freq to
+ * RPe when enabled, and resets it back to the previously set min
+ * when disabled, so no explicit set_min_freq request is needed here.
+ */
+ ret = pc_set_ignore_eff_freq(pc, !val);
+ }
+
+ if (!ret)
+ pc->use_rpe = val;
+
+ return ret;
+}
+
static const char *power_profile_to_string(struct xe_guc_pc *pc)
{
switch (pc->power_profile) {
@@ -1344,6 +1401,10 @@ int xe_guc_pc_start(struct xe_guc_pc *pc)
if (ret)
return ret;
+ ret = pc_set_ignore_eff_freq(pc, !pc->use_rpe);
+ if (unlikely(ret))
+ return ret;
+
ret = pc_set_mert_freq_cap(pc);
if (ret)
return ret;
@@ -1426,6 +1487,7 @@ int xe_guc_pc_init(struct xe_guc_pc *pc)
pc->bo = bo;
pc->power_profile = SLPC_POWER_PROFILE_BASE;
+ pc->use_rpe = true;
return devm_add_action_or_reset(xe->drm.dev, xe_guc_pc_fini_hw, pc);
}
diff --git a/drivers/gpu/drm/xe/xe_guc_pc.h b/drivers/gpu/drm/xe/xe_guc_pc.h
index 1025a2b15f5f..dc52f349a6a2 100644
--- a/drivers/gpu/drm/xe/xe_guc_pc.h
+++ b/drivers/gpu/drm/xe/xe_guc_pc.h
@@ -31,6 +31,7 @@ int xe_guc_pc_get_max_freq(struct xe_guc_pc *pc, u32 *freq);
int xe_guc_pc_set_max_freq(struct xe_guc_pc *pc, u32 freq);
int xe_guc_pc_set_power_profile(struct xe_guc_pc *pc, const char *buf);
void xe_guc_pc_get_power_profile(struct xe_guc_pc *pc, char *profile);
+int xe_guc_pc_set_use_rpe(struct xe_guc_pc *pc, u32 val);
enum xe_gt_idle_state xe_guc_pc_c_status(struct xe_guc_pc *pc);
u64 xe_guc_pc_rc6_residency(struct xe_guc_pc *pc);
diff --git a/drivers/gpu/drm/xe/xe_guc_pc_types.h b/drivers/gpu/drm/xe/xe_guc_pc_types.h
index 9a6ea2904e33..d59e7c935738 100644
--- a/drivers/gpu/drm/xe/xe_guc_pc_types.h
+++ b/drivers/gpu/drm/xe/xe_guc_pc_types.h
@@ -37,6 +37,8 @@ struct xe_guc_pc {
u32 power_profile;
/** @mert_freq_cap_active: Wa_22019338487 min/max cap is currently in force */
bool mert_freq_cap_active;
+ /** @use_rpe: Toggle use of efficient frequency */
+ bool use_rpe;
};
#endif /* _XE_GUC_PC_TYPES_H_ */
--
2.53.0
^ permalink raw reply related [flat|nested] 4+ messages in thread* Re: [PATCH v4 1/2] drm/xe: Disallow freq changes while mert cap is active
2026-11-19 22:29 [PATCH v4 1/2] drm/xe: Disallow freq changes while mert cap is active Vinay Belgaumkar
2026-11-19 22:30 ` [PATCH v4 2/2] drm/xe: Add sysfs to disable RPe Vinay Belgaumkar
@ 2026-11-19 22:57 ` sashiko-bot
1 sibling, 0 replies; 4+ messages in thread
From: sashiko-bot @ 2026-11-19 22:57 UTC (permalink / raw)
To: Vinay Belgaumkar, intel-xe
Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [Medium] drm/xe: permanent mert cap lockout in
xe_guc_pc_restore_stashed_freq()
- [Medium] drm/xe: stale MERT cap returned by
xe_guc_pc_get_min/max_freq() when capped
--
commit 46a723833f6fec7f60471a2ef5a3e851858c10f2
Author: Vinay Belgaumkar <vinay.belgaumkar@intel.com>
drm/xe: Disallow freq changes while mert cap is active
This commit tracks whether the Wa_22019338487 MERT frequency cap is active,
defers user min/max frequency requests until the cap is lifted, and ensures
frequencies are restored even if GSC firmware loading fails.
> diff --git a/drivers/gpu/drm/xe/xe_guc_pc.c b/drivers/gpu/drm/xe/xe_guc_pc.c
> index 9558d7196a51a..ea47b0ded83a4 100644
> --- a/drivers/gpu/drm/xe/xe_guc_pc.c
> +++ b/drivers/gpu/drm/xe/xe_guc_pc.c
[ ... ]
> @@ -638,17 +639,26 @@ int xe_guc_pc_get_min_freq(struct xe_guc_pc *pc, u32 *freq)
>
> static int xe_guc_pc_set_min_freq_locked(struct xe_guc_pc *pc, u32 freq)
> {
> - int ret;
> -
> lockdep_assert_held(&pc->freq_lock);
>
> /* Might be in the middle of a gt reset */
> if (!pc->freq_ready)
> return -EAGAIN;
>
> - ret = pc_set_min_freq(pc, freq);
> - if (ret)
> - return ret;
> + /*
> + * While the Wa_22019338487 cap is active, defer applying the new min
> + * to GuC; xe_guc_pc_restore_stashed_freq() will apply it once the
> + * cap is removed.
> + */
> + if (pc->mert_freq_cap_active) {
> + if (!pc_freq_in_range(pc, freq))
> + return -EINVAL;
> + } else {
> + int ret = pc_set_min_freq(pc, freq);
> +
> + if (ret)
> + return ret;
> + }
>
> pc->user_requested_min = freq;
>
> @@ -707,17 +717,26 @@ int xe_guc_pc_get_max_freq(struct xe_guc_pc *pc, u32 *freq)
>
> static int xe_guc_pc_set_max_freq_locked(struct xe_guc_pc *pc, u32 freq)
> {
> - int ret;
> -
> lockdep_assert_held(&pc->freq_lock);
>
> /* Might be in the middle of a gt reset */
> if (!pc->freq_ready)
> return -EAGAIN;
>
> - ret = pc_set_max_freq(pc, freq);
> - if (ret)
> - return ret;
> + /*
> + * While the Wa_22019338487 cap is active, defer applying the new max
> + * to GuC; xe_guc_pc_restore_stashed_freq() will apply it once the
> + * cap is lifted.
> + */
> + if (pc->mert_freq_cap_active) {
> + if (!pc_freq_in_range(pc, freq))
> + return -EINVAL;
> + } else {
> + int ret = pc_set_max_freq(pc, freq);
> +
> + if (ret)
> + return ret;
> + }
>
> pc->user_requested_max = freq;
[Severity: Medium]
Should xe_guc_pc_get_min_freq_locked() and xe_guc_pc_get_max_freq_locked()
return the deferred or stashed frequencies when pc->mert_freq_cap_active is
true?
Right now, both getters still query GuC SLPC directly and return the
temporary MERT cap (such as 800 MHz on Lunar Lake). Aside from reading
back 800 MHz right after a sysfs write succeeds, if a userspace tool or
test reads min_freq and max_freq to save the initial limits while the cap
is active and writes those values back to restore them,
pc->user_requested_max becomes 800 MHz and
xe_guc_pc_restore_stashed_freq() will prefer it over pc->stashed_max_freq,
leaving the GT permanently capped.
[ ... ]
> @@ -1112,9 +1134,13 @@ int xe_guc_pc_restore_stashed_freq(struct xe_guc_pc *pc)
> return 0;
>
> mutex_lock(&pc->freq_lock);
> - ret = pc_set_max_freq(pc, pc->user_requested_max ?: pc->stashed_max_freq);
> + /* Apply any user min/max request made while the cap was active, else the stash. */
> + ret = pc_set_max_freq(pc, pc->user_requested_max ?: pc->stashed_max_freq);
> +
> + if (!ret)
> + ret = pc_set_min_freq(pc, pc->user_requested_min ?: pc->stashed_min_freq);
> if (!ret)
> - ret = pc_set_min_freq(pc, pc->stashed_min_freq);
> + pc->mert_freq_cap_active = false;
> mutex_unlock(&pc->freq_lock);
>
> return ret;
[Severity: Medium]
Can a failure in pc_set_max_freq() or pc_set_min_freq() here leave
pc->mert_freq_cap_active stuck true forever?
All callers of xe_gt_sanitize_freq() ignore its return value without
retrying, so if either SLPC H2G request fails (for example if gsc_work()
races with a GT reset while pc->freq_ready is false), every future sysfs
write in xe_guc_pc_set_min_freq_locked() and
xe_guc_pc_set_max_freq_locked() will defer applying frequencies
indefinitely.
Also, since xe_guc_pc_restore_stashed_freq() does not check
pc->mert_freq_cap_active or pc->freq_ready before sending H2G requests,
redundant calls to xe_gt_sanitize_freq() (such as when xe_device_probe()
and gsc_work() both call it) will unconditionally re-send SLPC commands
even after the cap has already been lifted.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119222958.1239889-3-vinay.belgaumkar@intel.com?part=1
^ permalink raw reply [flat|nested] 4+ messages in thread