github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-09-22 12:44:03 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

drm/xe/guc: distinguish wedged from recoverable cancellation

Browse Source 
The CT layer returns -ECANCELED regardless of whether cancellation
is due to a GT reset or a wedged device. Return -ENOTRECOVERABLE
on wedge so callers don't need xe_device_wedged() checks
to suppress spurious error logs.
Also document the return codes of xe_guc_ct_send() in kernel-doc form.

v2: Fix -ECANCELED description (Matt)

Signed-off-by: Sk Anirban <sk.anirban@intel.com>
Reviewed-by: Matthew Brost <matthew.brost@intel.com>
Signed-off-by: Matthew Brost <matthew.brost@intel.com>
Link: https://patch.msgid.link/20260624194618.2793571-5-sk.anirban@intel.com
This commit is contained in:
Sk Anirban 2026-06-25 01:16:20 +05:30 committed by Matthew Brost
parent 3359422bf0
commit 50fa9acac2
1 changed files with 39 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
drivers/gpu/drm/xe/xe_guc_ct.c
View File

@ -1065,6 +1065,11 @@ static int __guc_ct_send_locked(struct xe_guc_ct *ct, const u32 *action,
xe_gt_assert(gt, g2h_len || !num_g2h);
lockdep_assert_held(&ct->lock);
if (xe_device_wedged(ct_to_xe(ct))) {
ret = -ENOTRECOVERABLE;
goto out;
}
if (unlikely(ct->ctbs.h2g.info.broken)) {
ret = -EPIPE;
goto out;
@ -1236,6 +1241,36 @@ static int guc_ct_send(struct xe_guc_ct *ct, const u32 *action, u32 len,
return ret;
}
/**
* xe_guc_ct_send - Send an HXG message to the GuC over CT
* @ct: the &xe_guc_ct
* @action: dword array with the HXG message (can't be NULL)
* @len: length of the HXG message in dwords (can't be 0)
* @g2h_len: G2H response space to reserve in dwords, or 0
* @num_g2h: number of G2H messages expected, or 0
*
* Return codes from the non-blocking send helpers are:
*
* * -ENOTRECOVERABLE: the xe device is wedged. Stop submitting new GuC work; the
* request cannot make progress until the device is recovered.
* * -EPIPE: the H2G CTB is marked broken. The channel stays unusable until the
* CT is restarted, which clears the broken flag.
* * -ENODEV: the CT channel is disabled, messages not expected in this state.
* Don't retry until it is enabled again.
* * -ECANCELED: the CT channel is stopped or a GT recovery is pending; the
* message was dropped. Often benign. Cancel-tolerant callers (e.g. TLB
* invalidations, GuC submission) rely on the stop/start flow to recover;
* others should retry once the CT is re-enabled or the reset/recovery
* completes.
* * -EDEADLK: no CTB room and the wait for space timed out. The send helpers
* have already requested an async GT reset before returning this error.
*
* -ENOMEM may also be returned if an internal allocation fails; the blocking
* xe_guc_ct_send_recv() path retries that allocation. -EBUSY and
* -EAGAIN are internal flow-control results handled by the send helpers.
*
* Return: 0 on success, or a negative error code on failure.
*/
int xe_guc_ct_send(struct xe_guc_ct *ct, const u32 *action, u32 len,
u32 g2h_len, u32 num_g2h)
{
@ -1388,7 +1423,7 @@ static int guc_ct_send_recv(struct xe_guc_ct *ct, const u32 *action, u32 len,
if (g2h_fence.fail) {
if (g2h_fence.cancel) {
xe_gt_dbg(gt, "H2G request %#x canceled!\n", action[0]);
ret = -ECANCELED;
ret = xe_device_wedged(ct_to_xe(ct)) ? -ENOTRECOVERABLE : -ECANCELED;
goto unlock;
}
xe_gt_err(gt, "H2G request %#x failed: error %#x hint %#x\n",
@ -1724,6 +1759,9 @@ static int g2h_read(struct xe_guc_ct *ct, u32 *msg, bool fast_path)
xe_gt_assert(gt, xe_guc_ct_initialized(ct));
lockdep_assert_held(&ct->fast_lock);
if (xe_device_wedged(xe))
return -ENOTRECOVERABLE;
if (ct->state == XE_GUC_CT_STATE_DISABLED)
return -ENODEV;