* [PATCH v5 2/2] drm/xe: Add sysfs to disable RPe
2026-11-20 2:16 [PATCH v5 1/2] drm/xe: Disallow freq changes while mert cap is active Vinay Belgaumkar
@ 2026-11-20 2:16 ` Vinay Belgaumkar
2026-11-20 2:35 ` sashiko-bot
2026-11-20 2:29 ` [PATCH v5 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-20 2:16 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)
v5: Restore use_rpe while under pc->freq_lock(Sashiko)
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 | 81 ++++++++++++++++++++++++----
drivers/gpu/drm/xe/xe_guc_pc.h | 1 +
drivers/gpu/drm/xe/xe_guc_pc_types.h | 2 +
4 files changed, 110 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 7e9700f16bfb..68e54e0b756d 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);
@@ -943,6 +951,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;
@@ -1099,12 +1116,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.
*/
@@ -1117,7 +1145,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)));
@@ -1144,9 +1174,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);
@@ -1178,6 +1210,11 @@ static int pc_init_freqs(struct xe_guc_pc *pc)
pc_init_pcode_freq(pc);
+ /* Restore use_rpe */
+ ret = pc_set_ignore_eff_freq(pc, !pc->use_rpe);
+ if (unlikely(ret))
+ return ret;
+
/*
* The frequencies are really ready for use only after the user
* requested ones got restored.
@@ -1200,6 +1237,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) {
@@ -1434,6 +1496,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 v5 1/2] drm/xe: Disallow freq changes while mert cap is active
2026-11-20 2:16 [PATCH v5 1/2] drm/xe: Disallow freq changes while mert cap is active Vinay Belgaumkar
2026-11-20 2:16 ` [PATCH v5 2/2] drm/xe: Add sysfs to disable RPe Vinay Belgaumkar
@ 2026-11-20 2:29 ` sashiko-bot
1 sibling, 0 replies; 4+ messages in thread
From: sashiko-bot @ 2026-11-20 2:29 UTC (permalink / raw)
To: Vinay Belgaumkar, intel-xe
Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [High] drm/xe: xe_guc_pc_get_min/max_freq_locked() return freq instead
of 0
- [Medium] drm/xe: mert_freq_cap_active is not cleared on GuC PC stop or
restart
--
commit a5ffc89a51c9df2129a3327ea1a0076ff70c2a90
Author: Vinay Belgaumkar <vinay.belgaumkar@intel.com>
drm/xe: Disallow freq changes while mert cap is active
This commit tracks when the Wa_22019338487 MERT frequency cap is active,
defers user min/max frequency changes until the cap is lifted, and lifts
the cap even if GSC firmware load fails.
> diff --git a/drivers/gpu/drm/xe/xe_guc_pc.c b/drivers/gpu/drm/xe/xe_guc_pc.c
> index 9558d7196a51a..7e9700f16bfb6 100644
> --- a/drivers/gpu/drm/xe/xe_guc_pc.c
> +++ b/drivers/gpu/drm/xe/xe_guc_pc.c
[ ... ]
> @@ -612,6 +613,10 @@ static int xe_guc_pc_get_min_freq_locked(struct xe_guc_pc *pc, u32 *freq)
> if (!pc->freq_ready)
> return -EAGAIN;
>
> + /* In the middle of a temporary freq cap, return stashed value */
> + if (XE_GT_WA(pc_to_gt(pc), 22019338487) && pc->mert_freq_cap_active)
> + return pc->stashed_min_freq;
> +
> ret = pc_action_query_task_state(pc);
> if (ret)
> return ret;
[ ... ]
> @@ -681,6 +695,10 @@ static int xe_guc_pc_get_max_freq_locked(struct xe_guc_pc *pc, u32 *freq)
> if (!pc->freq_ready)
> return -EAGAIN;
>
> + /* In the middle of a temporary freq cap, return stashed value */
> + if (XE_GT_WA(pc_to_gt(pc), 22019338487) && pc->mert_freq_cap_active)
> + return pc->stashed_max_freq;
> +
> ret = pc_action_query_task_state(pc);
> if (ret)
> return ret;
[Severity: High]
Should xe_guc_pc_get_min_freq_locked() and xe_guc_pc_get_max_freq_locked()
write the frequency into *freq and return 0 here instead of returning the
positive frequency value as the status code?
Callers such as min_freq_show() and max_freq_show() check if (ret) return
ret;, so returning a positive MHz value leaves *freq unassigned and causes
the sysfs show callbacks to return that positive integer as the byte count
without writing to buf. In addition, if a user sets a new min or max
frequency while the cap is active, it is saved in pc->user_requested_min /
pc->user_requested_max rather than pc->stashed_min_freq /
pc->stashed_max_freq, so *freq should probably be assigned
pc->user_requested_min ?: pc->stashed_min_freq (and similarly for max) to
match xe_guc_pc_restore_stashed_freq().
[ ... ]
> @@ -1094,6 +1121,9 @@ static int pc_set_mert_freq_cap(struct xe_guc_pc *pc)
> if (!ret)
> ret = pc_set_max_freq(pc, min(pc->rp0_freq, pc_max_freq_cap(pc)));
>
> + if (!ret)
> + pc->mert_freq_cap_active = true;
> +
> return ret;
> }
[Severity: Medium]
What happens if GuC PC is stopped and restarted (for example during a GT
reset) while pc->mert_freq_cap_active is still true?
Neither xe_guc_pc_stop() nor pc_set_mert_freq_cap() clears
pc->mert_freq_cap_active. When xe_guc_pc_start() calls
pc_set_mert_freq_cap() after pc_init_freqs(), its calls to
xe_guc_pc_get_min_freq_locked() and xe_guc_pc_get_max_freq_locked() will
hit the pc->mert_freq_cap_active early return instead of querying the
newly initialized SLPC state from GuC.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261120021606.1360244-3-vinay.belgaumkar@intel.com?part=1
^ permalink raw reply [flat|nested] 4+ messages in thread