Re: [PATCH v3 4/5] drm/xe: Introduce xe_wedge

[Raag Jadav <raag.jadav@intel.com>]

On Fri, Oct 09, 2026 at 09:23:43PM -0400, Rodrigo Vivi wrote:
> On Mon, Sep 07, 2026 at 02:04:39PM +0530, Raag Jadav wrote:
> > Consolidate wedging implementation into a dedicated xe_wedge component
> > for better maintainability. While at it, rename all wedge helpers
> > to match with component name.
> 
> `xe_pci_error.c` still sets `xe->wedged.flag` by hand, bypassing the
> component | Add a helper such as `xe_wedge_declare_silent()`.
> 
> Please check them all and create functions to touch xe_wedge variables

This is taken care in FLR series[1] where we introduce get/put helpers.

[1] https://patchwork.freedesktop.org/series/162055/

> > No functional impact.
> 
> there's one drm_ by xe_ log. but that is minor...

and not functional.

Raag

> > Signed-off-by: Raag Jadav <raag.jadav@intel.com>
> > ---
> > v2: Also move struct xe_wedge and wedged_mode debt to xe_wedge (Lukasz, Michal)
> >     Naming and aesthetic adjustments (Lukasz, Michal)
> > v3: Respect the component namespace (Rodrigo)
> >     Avoid chaining header includes (Rodrigo)
> >     Squash debugfs changes with xe_wedge patch (Lukasz)
> > ---
> >  Documentation/gpu/xe/xe_device.rst          |   2 +-
> >  drivers/gpu/drm/xe/Makefile                 |   1 +
> >  drivers/gpu/drm/xe/tests/xe_kunit_helpers.c |   3 +-
> >  drivers/gpu/drm/xe/xe_amc.c                 |   3 +-
> >  drivers/gpu/drm/xe/xe_bo.c                  |   3 +-
> >  drivers/gpu/drm/xe/xe_debugfs.c             |  66 +----
> >  drivers/gpu/drm/xe/xe_device.c              | 194 +------------
> >  drivers/gpu/drm/xe/xe_device.h              |  10 -
> >  drivers/gpu/drm/xe/xe_device_types.h        |  30 +-
> >  drivers/gpu/drm/xe/xe_gsc.c                 |   3 +-
> >  drivers/gpu/drm/xe/xe_gt.c                  |  11 +-
> >  drivers/gpu/drm/xe/xe_gt.h                  |   2 +-
> >  drivers/gpu/drm/xe/xe_gt_sriov_vf.c         |   3 +-
> >  drivers/gpu/drm/xe/xe_guc.c                 |   4 +-
> >  drivers/gpu/drm/xe/xe_guc.h                 |   2 +-
> >  drivers/gpu/drm/xe/xe_guc_ct.c              |   7 +-
> >  drivers/gpu/drm/xe/xe_guc_pc.c              |  11 +-
> >  drivers/gpu/drm/xe/xe_guc_rc.c              |   5 +-
> >  drivers/gpu/drm/xe/xe_guc_submit.c          |  13 +-
> >  drivers/gpu/drm/xe/xe_guc_tlb_inval.c       |   3 +-
> >  drivers/gpu/drm/xe/xe_mert.c                |   5 +-
> >  drivers/gpu/drm/xe/xe_pci_error.c           |   9 +-
> >  drivers/gpu/drm/xe/xe_ras.c                 |   5 +-
> >  drivers/gpu/drm/xe/xe_sriov_pf.c            |   3 +-
> >  drivers/gpu/drm/xe/xe_survivability_mode.c  |   5 +-
> >  drivers/gpu/drm/xe/xe_uc.c                  |   6 +-
> >  drivers/gpu/drm/xe/xe_uc.h                  |   2 +-
> >  drivers/gpu/drm/xe/xe_wedge.c               | 286 ++++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_wedge.h               |  20 ++
> >  drivers/gpu/drm/xe/xe_wedge_types.h         |  45 +++
> >  30 files changed, 425 insertions(+), 337 deletions(-)
> >  create mode 100644 drivers/gpu/drm/xe/xe_wedge.c
> >  create mode 100644 drivers/gpu/drm/xe/xe_wedge.h
> >  create mode 100644 drivers/gpu/drm/xe/xe_wedge_types.h
> > 
> > diff --git a/Documentation/gpu/xe/xe_device.rst b/Documentation/gpu/xe/xe_device.rst
> > index d3a022362ade..8baed81580c9 100644
> > --- a/Documentation/gpu/xe/xe_device.rst
> > +++ b/Documentation/gpu/xe/xe_device.rst
> > @@ -6,7 +6,7 @@
> >  Xe Device Wedging
> >  ==================
> >  
> > -.. kernel-doc:: drivers/gpu/drm/xe/xe_device.c
> > +.. kernel-doc:: drivers/gpu/drm/xe/xe_wedge.c
> >     :doc: Xe Device Wedging
> >  
> >  ====================
> > diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> > index adc2de37e768..c739a50b6896 100644
> > --- a/drivers/gpu/drm/xe/Makefile
> > +++ b/drivers/gpu/drm/xe/Makefile
> > @@ -152,6 +152,7 @@ xe-y += xe_bb.o \
> >  	xe_vsec.o \
> >  	xe_wa.o \
> >  	xe_wait_user_fence.o \
> > +	xe_wedge.o \
> >  	xe_wopcm.o
> >  
> >  xe-$(CONFIG_I2C)	+= xe_i2c.o \
> > diff --git a/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c b/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
> > index 27740b40c8ae..57ea88cce92d 100644
> > --- a/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
> > +++ b/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
> > @@ -15,6 +15,7 @@
> >  #include "xe_device.h"
> >  #include "xe_device_types.h"
> >  #include "xe_pm.h"
> > +#include "xe_wedge.h"
> >  
> >  /**
> >   * xe_kunit_helper_alloc_xe_device - Allocate a &xe_device for a KUnit test.
> > @@ -123,7 +124,7 @@ int xe_kunit_helper_xe_device_live_test_init(struct kunit *test)
> >  	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
> >  	kunit_info(test, "running on %s device\n", xe->info.platform_name);
> >  
> > -	KUNIT_ASSERT_FALSE(test, xe_device_wedged(xe));
> > +	KUNIT_ASSERT_FALSE(test, xe_wedged(xe));
> >  	xe_pm_runtime_get(xe);
> >  	KUNIT_ASSERT_EQ(test, 0, kunit_add_action_or_reset(test, put_xe_pm_runtime, xe));
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_amc.c b/drivers/gpu/drm/xe/xe_amc.c
> > index 8ecadee6eea3..ca8013d7f569 100644
> > --- a/drivers/gpu/drm/xe/xe_amc.c
> > +++ b/drivers/gpu/drm/xe/xe_amc.c
> > @@ -18,6 +18,7 @@
> >  #include "xe_device.h"
> >  #include "xe_i2c.h"
> >  #include "xe_mmio.h"
> > +#include "xe_wedge.h"
> >  
> >  /**
> >   * DOC: Add-In Management Controller (AMC)
> > @@ -160,7 +161,7 @@ static void xe_amc_work(struct work_struct *work)
> >  	case AMC_ALERT_OOB_RESET:
> >  	case AMC_ALERT_CATERR:
> >  		dev_warn(amc->i2c->drm_dev, "AMC Alert: %s\n", amc_alert[alert_reason]);
> > -		xe_device_declare_wedged(i2c_client_to_xe_device(client));
> > +		xe_wedge_declare(i2c_client_to_xe_device(client));
> >  		break;
> >  	default:
> >  		dev_warn(amc->i2c->drm_dev, "unknown AMC alert: %d\n", alert_reason);
> > diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c
> > index b162753cebb7..b5552845c57c 100644
> > --- a/drivers/gpu/drm/xe/xe_bo.c
> > +++ b/drivers/gpu/drm/xe/xe_bo.c
> > @@ -40,6 +40,7 @@
> >  #include "xe_ttm_stolen_mgr.h"
> >  #include "xe_vm.h"
> >  #include "xe_vram_types.h"
> > +#include "xe_wedge.h"
> >  
> >  const char *const xe_mem_type_to_name[TTM_NUM_MEM_TYPES]  = {
> >  	[XE_PL_SYSTEM] = "system",
> > @@ -2100,7 +2101,7 @@ static vm_fault_t xe_bo_cpu_fault(struct vm_fault *vmf)
> >  	int err = 0;
> >  	int idx;
> >  
> > -	if (xe_device_wedged(xe) || !drm_dev_enter(&xe->drm, &idx))
> > +	if (xe_wedged(xe) || !drm_dev_enter(&xe->drm, &idx))
> >  		return ttm_bo_vm_dummy_page(vmf, vmf->vma->vm_page_prot);
> >  
> >  	ret = xe_bo_cpu_fault_fastpath(vmf, xe, bo, needs_rpm);
> > diff --git a/drivers/gpu/drm/xe/xe_debugfs.c b/drivers/gpu/drm/xe/xe_debugfs.c
> > index 80f62634fae5..a01c057cb0b0 100644
> > --- a/drivers/gpu/drm/xe/xe_debugfs.c
> > +++ b/drivers/gpu/drm/xe/xe_debugfs.c
> > @@ -18,13 +18,12 @@
> >  #include "xe_force_wake.h"
> >  #include "xe_gt.h"
> >  #include "xe_gt_debugfs.h"
> > -#include "xe_gt_printk.h"
> > -#include "xe_guc_ads.h"
> >  #include "xe_hw_engine.h"
> >  #include "xe_mmio.h"
> >  #include "xe_pagefault.h"
> >  #include "xe_pcode.h"
> >  #include "xe_pm.h"
> > +#include "xe_printk.h"
> >  #include "xe_psmi.h"
> >  #include "xe_pxp_debugfs.h"
> >  #include "xe_sriov.h"
> > @@ -35,6 +34,7 @@
> >  #include "xe_ttm_vram_mgr.h"
> >  #include "xe_vsec.h"
> >  #include "xe_wa.h"
> > +#include "xe_wedge.h"
> >  
> >  #ifdef CONFIG_DRM_XE_DEBUG
> >  #include "xe_bo_evict.h"
> > @@ -423,58 +423,6 @@ static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,
> >  	return simple_read_from_buffer(ubuf, size, pos, buf, len);
> >  }
> >  
> > -static int __wedged_mode_set_reset_policy(struct xe_gt *gt, enum xe_wedged_mode mode)
> > -{
> > -	bool enable_engine_reset;
> > -	int ret;
> > -
> > -	enable_engine_reset = (mode != XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET);
> > -	ret = xe_guc_ads_scheduler_policy_toggle_reset(&gt->uc.guc.ads,
> > -						       enable_engine_reset);
> > -	if (ret)
> > -		xe_gt_err(gt, "Failed to update GuC ADS scheduler policy (%pe)\n", ERR_PTR(ret));
> > -
> > -	return ret;
> > -}
> > -
> > -static int wedged_mode_set_reset_policy(struct xe_device *xe, enum xe_wedged_mode mode)
> > -{
> > -	struct xe_gt *gt;
> > -	int ret;
> > -	u8 id;
> > -
> > -	guard(xe_pm_runtime)(xe);
> > -	for_each_gt(gt, xe, id) {
> > -		ret = __wedged_mode_set_reset_policy(gt, mode);
> > -		if (ret) {
> > -			if (id > 0) {
> > -				xe->wedged.inconsistent_reset = true;
> > -				drm_err(&xe->drm, "Inconsistent reset policy state between GTs\n");
> > -			}
> > -			return ret;
> > -		}
> > -	}
> > -
> > -	xe->wedged.inconsistent_reset = false;
> > -
> > -	return 0;
> > -}
> > -
> > -static bool wedged_mode_needs_policy_update(struct xe_device *xe, enum xe_wedged_mode mode)
> > -{
> > -	if (xe->wedged.inconsistent_reset)
> > -		return true;
> > -
> > -	if (xe->wedged.mode == mode)
> > -		return false;
> > -
> > -	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ||
> > -	    mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
> > -		return true;
> > -
> > -	return false;
> > -}
> > -
> >  static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,
> >  			       size_t size, loff_t *pos)
> >  {
> > @@ -486,18 +434,10 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,
> >  	if (ret)
> >  		return ret;
> >  
> > -	ret = xe_device_validate_wedged_mode(xe, wedged_mode);
> > +	ret = xe_wedge_set_mode(xe, wedged_mode);
> >  	if (ret)
> >  		return ret;
> >  
> > -	if (wedged_mode_needs_policy_update(xe, wedged_mode)) {
> > -		ret = wedged_mode_set_reset_policy(xe, wedged_mode);
> > -		if (ret)
> > -			return ret;
> > -	}
> > -
> > -	xe->wedged.mode = wedged_mode;
> > -
> >  	return size;
> >  }
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_device.c b/drivers/gpu/drm/xe/xe_device.c
> > index 1daa02d39f3a..12279ed27629 100644
> > --- a/drivers/gpu/drm/xe/xe_device.c
> > +++ b/drivers/gpu/drm/xe/xe_device.c
> > @@ -79,6 +79,7 @@
> >  #include "xe_vsec.h"
> >  #include "xe_wait_user_fence.h"
> >  #include "xe_wa.h"
> > +#include "xe_wedge.h"
> >  
> >  #include <generated/xe_device_wa_oob.h>
> >  #include <generated/xe_wa_oob.h>
> > @@ -225,7 +226,7 @@ static long xe_drm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
> >  	struct xe_device *xe = to_xe_device(file_priv->minor->dev);
> >  	long ret;
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return -ECANCELED;
> >  
> >  	ACQUIRE(xe_pm_runtime_ioctl, pm)(xe);
> > @@ -243,7 +244,7 @@ static long xe_drm_compat_ioctl(struct file *file, unsigned int cmd, unsigned lo
> >  	struct xe_device *xe = to_xe_device(file_priv->minor->dev);
> >  	long ret;
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return -ECANCELED;
> >  
> >  	ACQUIRE(xe_pm_runtime_ioctl, pm)(xe);
> > @@ -770,16 +771,6 @@ static int xe_device_vram_alloc(struct xe_device *xe)
> >  	return 0;
> >  }
> >  
> > -static void wedged_work(struct work_struct *work);
> > -static void xe_device_wedged_fini(struct drm_device *drm, void *arg);
> > -
> > -static int xe_device_wedged_init(struct xe_device *xe)
> > -{
> > -	INIT_WORK(&xe->wedged.work, wedged_work);
> > -
> > -	return drmm_add_action_or_reset(&xe->drm, xe_device_wedged_fini, xe);
> > -}
> > -
> >  /**
> >   * xe_device_probe_early: Device early probe
> >   * @xe: xe device instance
> > @@ -839,16 +830,11 @@ int xe_device_probe_early(struct xe_device *xe)
> >  	 */
> >  	assert_lmem_ready(xe);
> >  
> > -	xe->wedged.mode = xe_device_validate_wedged_mode(xe, xe_modparam.wedged_mode) ?
> > -			  XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;
> > -	drm_dbg(&xe->drm, "wedged_mode: setting mode (%u) %s\n",
> > -		xe->wedged.mode, xe_wedged_mode_to_string(xe->wedged.mode));
> > -
> >  	err = xe_device_vram_alloc(xe);
> >  	if (err)
> >  		return err;
> >  
> > -	err = xe_device_wedged_init(xe);
> > +	err = xe_wedge_init(xe);
> >  	if (err)
> >  		return err;
> >  
> > @@ -938,14 +924,6 @@ static void detect_preproduction_hw(struct xe_device *xe)
> >  	}
> >  }
> >  
> > -static void xe_device_wedged_fini(struct drm_device *drm, void *arg)
> > -{
> > -	struct xe_device *xe = arg;
> > -
> > -	if (atomic_read(&xe->wedged.flag))
> > -		xe_pm_runtime_put(xe);
> > -}
> > -
> >  #ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE
> >  static int xe_debug_page_size_alloc_ctrl_init(struct xe_device *xe)
> >  {
> > @@ -1173,7 +1151,7 @@ int xe_device_probe(struct xe_device *xe)
> >  	/*
> >  	 * Process and log any errors detected by hardware. Possible results can
> >  	 * include declaring the device as wedged, which must be done only after
> > -	 * xe_device_wedged_fini() is registered.
> > +	 * xe_wedge_fini() is registered.
> >  	 */
> >  	xe_ras_process_errors(xe);
> >  
> > @@ -1412,168 +1390,6 @@ u64 xe_device_uncanonicalize_addr(struct xe_device *xe, u64 address)
> >  	return address & GENMASK_ULL(xe->info.va_bits - 1, 0);
> >  }
> >  
> > -/**
> > - * DOC: Xe Device Wedging
> > - *
> > - * Xe driver uses drm device wedged uevent as documented in Documentation/gpu/drm-uapi.rst.
> > - * When device is in wedged state, every IOCTL will be blocked and GT cannot
> > - * be used. The conditions under which the driver declares the device wedged
> > - * depend on the wedged mode configuration (see &enum xe_wedged_mode). The
> > - * default recovery method for a wedged state is rebind/bus-reset.
> > - *
> > - * Another recovery method is vendor-specific. Below are the cases that send
> > - * ``WEDGED=vendor-specific`` recovery method in drm device wedged uevent.
> > - *
> > - * Case: Firmware Flash
> > - * --------------------
> > - *
> > - * Identification Hint
> > - * +++++++++++++++++++
> > - *
> > - * ``WEDGED=vendor-specific`` drm device wedged uevent with
> > - * :ref:`Runtime Survivability mode <xe-survivability-mode>` is used to notify
> > - * admin/userspace consumer about the need for a firmware flash.
> > - *
> > - * Recovery Procedure
> > - * ++++++++++++++++++
> > - *
> > - * Once ``WEDGED=vendor-specific`` drm device wedged uevent is received, follow
> > - * the below steps
> > - *
> > - * - Check Runtime Survivability mode sysfs.
> > - *   If enabled, firmware flash is required to recover the device.
> > - *
> > - *   /sys/bus/pci/devices/<device>/survivability_mode
> > - *
> > - * - Admin/userspace consumer can use firmware flashing tools like fwupd to flash
> > - *   firmware and restore device to normal operation.
> > - */
> > -
> > -/**
> > - * xe_device_set_wedged_method - Set wedged recovery method
> > - * @xe: xe device instance
> > - * @method: recovery method to set
> > - *
> > - * Set wedged recovery method to be sent in drm wedged uevent.
> > - */
> > -void xe_device_set_wedged_method(struct xe_device *xe, unsigned long method)
> > -{
> > -	xe->wedged.method = method;
> > -}
> > -
> > -static void wedged_work(struct work_struct *work)
> > -{
> > -	struct xe_device *xe = container_of(work, struct xe_device, wedged.work);
> > -
> > -	/*
> > -	 * XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging
> > -	 * hangs, so wedge the device with 'none' recovery method and have
> > -	 * it available to the user for debugging.
> > -	 */
> > -	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
> > -		xe_device_set_wedged_method(xe, DRM_WEDGE_RECOVERY_NONE);
> > -	/* If no wedge recovery method is set, use default */
> > -	else if (!xe->wedged.method)
> > -		xe_device_set_wedged_method(xe, DRM_WEDGE_RECOVERY_REBIND |
> > -					    DRM_WEDGE_RECOVERY_BUS_RESET);
> > -
> > -	/* Notify userspace of wedged device */
> > -	drm_dev_wedged_event(&xe->drm, xe->wedged.method, NULL);
> > -}
> > -
> > -#define WEDGED_URL	"https://docs.kernel.org/gpu/drm-uapi.html#device-wedging"
> > -#define XE_BUG_URL	"https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"
> > -
> > -/**
> > - * xe_device_declare_wedged - Declare device wedged
> > - * @xe: xe device instance
> > - *
> > - * This is a final state that can only be cleared with the recovery method
> > - * specified in the drm wedged uevent. The method can be set using
> > - * xe_device_set_wedged_method before declaring the device as wedged. If no method
> > - * is set, reprobe (unbind/re-bind) will be sent by default.
> > - *
> > - * In this state every IOCTL will be blocked so the GT cannot be used.
> > - * In general it will be called upon any critical error such as gt reset
> > - * failure or guc loading failure. Userspace will be notified of this state
> > - * through device wedged uevent.
> > - * If xe.wedged module parameter is set to 2, this function will be called
> > - * on every single execution timeout (a.k.a. GPU hang) right after devcoredump
> > - * snapshot capture. In this mode, GT reset won't be attempted so the state of
> > - * the issue is preserved for further debugging.
> > - */
> > -void xe_device_declare_wedged(struct xe_device *xe)
> > -{
> > -	struct xe_gt *gt;
> > -	u8 id;
> > -
> > -	if (xe->wedged.mode == XE_WEDGED_MODE_NEVER) {
> > -		drm_dbg(&xe->drm, "Wedged mode is forcibly disabled\n");
> > -		return;
> > -	}
> > -
> > -	if (!atomic_xchg(&xe->wedged.flag, 1)) {
> > -		xe->needs_flr_on_fini = true;
> > -		xe_pm_runtime_get_noresume(xe);
> > -
> > -		xe_log_err_fatal(xe, WEDGED, -EIO, "Device declared wedged!\n");
> > -		xe_err_once(xe, "IOCTLs and executions are now blocked!\n"
> > -			    "For recovery procedure, refer to %s\n"
> > -			    "Please file a _new_ bug report at %s\n",
> > -			    WEDGED_URL, XE_BUG_URL);
> > -
> > -		for_each_gt(gt, xe, id)
> > -			xe_gt_declare_wedged(gt);
> > -
> > -		schedule_work(&xe->wedged.work);
> > -	}
> > -}
> > -
> > -/**
> > - * xe_device_validate_wedged_mode - Check if given mode is supported
> > - * @xe: the &xe_device
> > - * @mode: requested mode to validate
> > - *
> > - * Check whether the provided wedged mode is supported.
> > - *
> > - * Return: 0 if mode is supported, error code otherwise.
> > - */
> > -int xe_device_validate_wedged_mode(struct xe_device *xe, unsigned int mode)
> > -{
> > -	if (mode > XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET) {
> > -		drm_dbg(&xe->drm, "wedged_mode: invalid value (%u)\n", mode);
> > -		return -EINVAL;
> > -	} else if (mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET && (IS_SRIOV_VF(xe) ||
> > -		   (IS_SRIOV_PF(xe) && !IS_ENABLED(CONFIG_DRM_XE_DEBUG)))) {
> > -		drm_dbg(&xe->drm, "wedged_mode: (%u) %s mode is not supported for %s\n",
> > -			mode, xe_wedged_mode_to_string(mode),
> > -			xe_sriov_mode_to_string(xe_device_sriov_mode(xe)));
> > -		return -EPERM;
> > -	}
> > -
> > -	return 0;
> > -}
> > -
> > -/**
> > - * xe_wedged_mode_to_string - Convert enum value to string.
> > - * @mode: the &xe_wedged_mode to convert
> > - *
> > - * Returns: wedged mode as a user friendly string.
> > - */
> > -const char *xe_wedged_mode_to_string(enum xe_wedged_mode mode)
> > -{
> > -	switch (mode) {
> > -	case XE_WEDGED_MODE_NEVER:
> > -		return "never";
> > -	case XE_WEDGED_MODE_UPON_CRITICAL_ERROR:
> > -		return "upon-critical-error";
> > -	case XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET:
> > -		return "upon-any-hang-no-reset";
> > -	default:
> > -		return "<invalid>";
> > -	}
> > -}
> > -
> >  /**
> >   * xe_device_asid_to_vm() - Find VM from ASID
> >   * @xe: the &xe_device
> > diff --git a/drivers/gpu/drm/xe/xe_device.h b/drivers/gpu/drm/xe/xe_device.h
> > index 6d3d6d5eba29..9c0be9e16f72 100644
> > --- a/drivers/gpu/drm/xe/xe_device.h
> > +++ b/drivers/gpu/drm/xe/xe_device.h
> > @@ -207,11 +207,6 @@ bool xe_device_is_l2_flush_optimized(struct xe_device *xe);
> >  void xe_device_td_flush(struct xe_device *xe);
> >  void xe_device_l2_flush(struct xe_device *xe, bool force);
> >  
> > -static inline bool xe_device_wedged(struct xe_device *xe)
> > -{
> > -	return atomic_read(&xe->wedged.flag);
> > -}
> > -
> >  #ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE
> >  static inline bool xe_debug_page_size_supported(struct xe_device *xe)
> >  {
> > @@ -260,11 +255,6 @@ static inline bool xe_debug_page_size_mode_is_mixed(struct xe_device *xe)
> >  }
> >  #endif
> >  
> > -void xe_device_set_wedged_method(struct xe_device *xe, unsigned long method);
> > -void xe_device_declare_wedged(struct xe_device *xe);
> > -int xe_device_validate_wedged_mode(struct xe_device *xe, unsigned int mode);
> > -const char *xe_wedged_mode_to_string(enum xe_wedged_mode mode);
> > -
> >  struct xe_file *xe_file_get(struct xe_file *xef);
> >  void xe_file_put(struct xe_file *xef);
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_device_types.h b/drivers/gpu/drm/xe/xe_device_types.h
> > index 7d83f79f27f4..2b7114e9fee1 100644
> > --- a/drivers/gpu/drm/xe/xe_device_types.h
> > +++ b/drivers/gpu/drm/xe/xe_device_types.h
> > @@ -30,6 +30,7 @@
> >  #include "xe_sysctrl_types.h"
> >  #include "xe_tile_types.h"
> >  #include "xe_validation.h"
> > +#include "xe_wedge_types.h"
> >  
> >  #if IS_ENABLED(CONFIG_DRM_XE_DEBUG)
> >  #define TEST_VM_OPS_ERROR
> > @@ -45,22 +46,6 @@ struct xe_pxp;
> >  struct xe_ttm_stolen_mgr;
> >  struct xe_vram_region;
> >  
> > -/**
> > - * enum xe_wedged_mode - possible wedged modes
> > - * @XE_WEDGED_MODE_NEVER: Device will never be declared wedged.
> > - * @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only
> > - *	when critical error occurs like GT reset failure or firmware failure.
> > - *	This is the default mode.
> > - * @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on
> > - *	any hang. In this mode, engine resets are disabled to avoid automatic
> > - *	recovery attempts. This mode is primarily intended for debugging hangs.
> > - */
> > -enum xe_wedged_mode {
> > -	XE_WEDGED_MODE_NEVER = 0,
> > -	XE_WEDGED_MODE_UPON_CRITICAL_ERROR = 1,
> > -	XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET = 2,
> > -};
> > -
> >  #ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE
> >  /**
> >   * enum xe_page_size_alloc_ctrl_mode - User BO page-size allocation control modes
> > @@ -525,18 +510,7 @@ struct xe_device {
> >  	atomic_t in_reset;
> >  
> >  	/** @wedged: Struct to control Wedged States and mode */
> > -	struct {
> > -		/** @wedged.flag: Xe device faced a critical error and is now blocked. */
> > -		atomic_t flag;
> > -		/** @wedged.mode: Mode controlled by kernel parameter and debugfs */
> > -		enum xe_wedged_mode mode;
> > -		/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */
> > -		unsigned long method;
> > -		/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */
> > -		bool inconsistent_reset;
> > -		/** @wedged.work: Worker for wedge handling */
> > -		struct work_struct work;
> > -	} wedged;
> > +	struct xe_wedge wedged;
> >  
> >  	/** @devres_group: devres group */
> >  	void *devres_group;
> > diff --git a/drivers/gpu/drm/xe/xe_gsc.c b/drivers/gpu/drm/xe/xe_gsc.c
> > index 524ac56bdcc7..cd333f2a6632 100644
> > --- a/drivers/gpu/drm/xe/xe_gsc.c
> > +++ b/drivers/gpu/drm/xe/xe_gsc.c
> > @@ -31,6 +31,7 @@
> >  #include "xe_sched_job.h"
> >  #include "xe_uc_fw.h"
> >  #include "xe_wa.h"
> > +#include "xe_wedge.h"
> >  #include "instructions/xe_gsc_commands.h"
> >  #include "regs/xe_gsc_regs.h"
> >  #include "regs/xe_gt_regs.h"
> > @@ -340,7 +341,7 @@ static int gsc_er_complete(struct xe_gt *gt)
> >  		 * declare the device as wedged.
> >  		 */
> >  		xe_gt_err(gt, "GSC ER timed out!\n");
> > -		xe_device_declare_wedged(gt_to_xe(gt));
> > +		xe_wedge_declare(gt_to_xe(gt));
> >  		return -EIO;
> >  	}
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_gt.c b/drivers/gpu/drm/xe/xe_gt.c
> > index 200e34331c19..e4e2b70ca0ca 100644
> > --- a/drivers/gpu/drm/xe/xe_gt.c
> > +++ b/drivers/gpu/drm/xe/xe_gt.c
> > @@ -68,6 +68,7 @@
> >  #include "xe_uc_fw.h"
> >  #include "xe_vm.h"
> >  #include "xe_wa.h"
> > +#include "xe_wedge.h"
> >  #include "xe_wopcm.h"
> >  
> >  struct xe_gt *xe_gt_alloc(struct xe_tile *tile)
> > @@ -926,7 +927,7 @@ static void gt_reset_worker(struct work_struct *w)
> >  	unsigned int fw_ref;
> >  	int err;
> >  
> > -	if (xe_device_wedged(gt_to_xe(gt)))
> > +	if (xe_wedged(gt_to_xe(gt)))
> >  		goto err_pm_put;
> >  
> >  	if (xe_device_is_in_reset(gt_to_xe(gt)))
> > @@ -985,7 +986,7 @@ static void gt_reset_worker(struct work_struct *w)
> >  
> >  err_fail:
> >  	xe_log_err_fatal(gt, GT, err, "reset failed\n");
> > -	xe_device_declare_wedged(gt_to_xe(gt));
> > +	xe_wedge_declare(gt_to_xe(gt));
> >  err_pm_put:
> >  	xe_pm_runtime_put(gt_to_xe(gt));
> >  }
> > @@ -1013,7 +1014,7 @@ static void gt_wedge_worker(struct work_struct *w)
> >  {
> >  	struct xe_gt *gt = container_of(w, typeof(*gt), wedge.worker);
> >  
> > -	xe_uc_declare_wedged(&gt->uc);
> > +	xe_uc_wedge_declare(&gt->uc);
> >  	xe_tlb_inval_reset(&gt->tlb_inval);
> >  }
> >  
> > @@ -1197,13 +1198,13 @@ struct xe_hw_engine *xe_gt_any_hw_engine(struct xe_gt *gt)
> >  }
> >  
> >  /**
> > - * xe_gt_declare_wedged() - Declare GT wedged
> > + * xe_gt_wedge_declare() - Declare GT wedged
> >   * @gt: the GT object
> >   *
> >   * Wedge the GT which stops all submission, saves desired debug state, and
> >   * cleans up anything which could timeout.
> >   */
> > -void xe_gt_declare_wedged(struct xe_gt *gt)
> > +void xe_gt_wedge_declare(struct xe_gt *gt)
> >  {
> >  	xe_gt_assert(gt, gt_to_xe(gt)->wedged.mode);
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_gt.h b/drivers/gpu/drm/xe/xe_gt.h
> > index 92d934d50244..7b6952fe804c 100644
> > --- a/drivers/gpu/drm/xe/xe_gt.h
> > +++ b/drivers/gpu/drm/xe/xe_gt.h
> > @@ -40,7 +40,7 @@ struct xe_gt *xe_gt_alloc(struct xe_tile *tile);
> >  int xe_gt_init_early(struct xe_gt *gt);
> >  int xe_gt_init(struct xe_gt *gt);
> >  void xe_gt_mmio_init(struct xe_gt *gt);
> > -void xe_gt_declare_wedged(struct xe_gt *gt);
> > +void xe_gt_wedge_declare(struct xe_gt *gt);
> >  int xe_gt_record_default_lrcs(struct xe_gt *gt);
> >  
> >  /**
> > diff --git a/drivers/gpu/drm/xe/xe_gt_sriov_vf.c b/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> > index 37899fcf5b22..0007fb21908f 100644
> > --- a/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> > +++ b/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> > @@ -37,6 +37,7 @@
> >  #include "xe_tile_sriov_vf.h"
> >  #include "xe_tlb_inval.h"
> >  #include "xe_uc_fw.h"
> > +#include "xe_wedge.h"
> >  #include "xe_wopcm.h"
> >  
> >  #define make_u64_from_u32(hi, lo) ((u64)((u64)(u32)(hi) << 32 | (u32)(lo)))
> > @@ -1462,7 +1463,7 @@ static void vf_post_migration_recovery(struct xe_gt *gt)
> >  fail:
> >  	vf_post_migration_abort(gt);
> >  	xe_gt_sriov_err(gt, "migration recovery failed (%pe)\n", ERR_PTR(err));
> > -	xe_device_declare_wedged(xe);
> > +	xe_wedge_declare(xe);
> >  	return;
> >  
> >  queue:
> > diff --git a/drivers/gpu/drm/xe/xe_guc.c b/drivers/gpu/drm/xe/xe_guc.c
> > index c7f8bbd4cb92..23a4f5064476 100644
> > --- a/drivers/gpu/drm/xe/xe_guc.c
> > +++ b/drivers/gpu/drm/xe/xe_guc.c
> > @@ -1813,13 +1813,13 @@ int xe_guc_print_info(struct xe_guc *guc, struct drm_printer *p)
> >  }
> >  
> >  /**
> > - * xe_guc_declare_wedged() - Declare GuC wedged
> > + * xe_guc_wedge_declare() - Declare GuC wedged
> >   * @guc: the GuC object
> >   *
> >   * Wedge the GuC which stops all submission, saves desired debug state, and
> >   * cleans up anything which could timeout.
> >   */
> > -void xe_guc_declare_wedged(struct xe_guc *guc)
> > +void xe_guc_wedge_declare(struct xe_guc *guc)
> >  {
> >  	xe_gt_assert(guc_to_gt(guc), guc_to_xe(guc)->wedged.mode);
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_guc.h b/drivers/gpu/drm/xe/xe_guc.h
> > index 61e3ee19a59b..8e2c0486f85a 100644
> > --- a/drivers/gpu/drm/xe/xe_guc.h
> > +++ b/drivers/gpu/drm/xe/xe_guc.h
> > @@ -60,7 +60,7 @@ void xe_guc_reset_wait(struct xe_guc *guc);
> >  void xe_guc_stop_prepare(struct xe_guc *guc);
> >  void xe_guc_stop(struct xe_guc *guc);
> >  int xe_guc_start(struct xe_guc *guc);
> > -void xe_guc_declare_wedged(struct xe_guc *guc);
> > +void xe_guc_wedge_declare(struct xe_guc *guc);
> >  bool xe_guc_using_main_gamctrl_queues(struct xe_guc *guc);
> >  bool xe_guc_has_paging_engine(struct xe_guc *guc);
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_guc_ct.c b/drivers/gpu/drm/xe/xe_guc_ct.c
> > index 5c4733da385c..ffa7902bb533 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_ct.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_ct.c
> > @@ -36,6 +36,7 @@
> >  #include "xe_sleep.h"
> >  #include "xe_sriov_vf.h"
> >  #include "xe_trace_guc.h"
> > +#include "xe_wedge.h"
> >  
> >  static void receive_g2h(struct xe_guc_ct *ct);
> >  static void g2h_worker_func(struct work_struct *w);
> > @@ -1062,7 +1063,7 @@ 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))) {
> > +	if (xe_wedged(ct_to_xe(ct))) {
> >  		ret = -ENOTRECOVERABLE;
> >  		goto out;
> >  	}
> > @@ -1474,7 +1475,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 = xe_device_wedged(ct_to_xe(ct)) ? -ENOTRECOVERABLE : -ECANCELED;
> > +			ret = xe_wedged(ct_to_xe(ct)) ? -ENOTRECOVERABLE : -ECANCELED;
> >  			goto unlock;
> >  		}
> >  		xe_gt_err(gt, "H2G request %#x failed: error %#x hint %#x\n",
> > @@ -1813,7 +1814,7 @@ 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))
> > +	if (xe_wedged(xe))
> >  		return -ENOTRECOVERABLE;
> >  
> >  	if (ct->state == XE_GUC_CT_STATE_DISABLED)
> > diff --git a/drivers/gpu/drm/xe/xe_guc_pc.c b/drivers/gpu/drm/xe/xe_guc_pc.c
> > index 097b075bd89a..88676469ea96 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_pc.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_pc.c
> > @@ -36,6 +36,7 @@
> >  #include "xe_pm.h"
> >  #include "xe_sriov.h"
> >  #include "xe_wa.h"
> > +#include "xe_wedge.h"
> >  
> >  #define MCHBAR_MIRROR_BASE_SNB	0x140000
> >  
> > @@ -188,7 +189,7 @@ static int pc_action_reset(struct xe_guc_pc *pc)
> >  	int ret;
> >  
> >  	ret = xe_guc_ct_send(ct, action, ARRAY_SIZE(action), 0, 0);
> > -	if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> > +	if (ret && !(xe_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> >  		xe_gt_err(pc_to_gt(pc), "GuC PC reset failed: %pe\n",
> >  			  ERR_PTR(ret));
> >  
> > @@ -212,7 +213,7 @@ static int pc_action_query_task_state(struct xe_guc_pc *pc)
> >  
> >  	/* Blocking here to ensure the results are ready before reading them */
> >  	ret = xe_guc_ct_send_block(ct, action, ARRAY_SIZE(action));
> > -	if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> > +	if (ret && !(xe_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> >  		xe_gt_err(pc_to_gt(pc), "GuC PC query task state failed: %pe\n",
> >  			  ERR_PTR(ret));
> >  
> > @@ -235,7 +236,7 @@ static int pc_action_set_param(struct xe_guc_pc *pc, u8 id, u32 value)
> >  		return -EAGAIN;
> >  
> >  	ret = xe_guc_ct_send(ct, action, ARRAY_SIZE(action), 0, 0);
> > -	if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> > +	if (ret && !(xe_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> >  		xe_gt_err(pc_to_gt(pc), "GuC PC set param[%u]=%u failed: %pe\n",
> >  			  id, value, ERR_PTR(ret));
> >  
> > @@ -257,7 +258,7 @@ static int pc_action_unset_param(struct xe_guc_pc *pc, u8 id)
> >  		return -EAGAIN;
> >  
> >  	ret = xe_guc_ct_send(ct, action, ARRAY_SIZE(action), 0, 0);
> > -	if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> > +	if (ret && !(xe_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
> >  		xe_gt_err(pc_to_gt(pc), "GuC PC unset param failed: %pe",
> >  			  ERR_PTR(ret));
> >  
> > @@ -1357,7 +1358,7 @@ static void xe_guc_pc_fini_hw(void *arg)
> >  	struct xe_guc_pc *pc = arg;
> >  	struct xe_device *xe = pc_to_xe(pc);
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return;
> >  
> >  	xe_guc_pc_stop(pc);
> > diff --git a/drivers/gpu/drm/xe/xe_guc_rc.c b/drivers/gpu/drm/xe/xe_guc_rc.c
> > index 99fa127b261f..fa3062ab134a 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_rc.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_rc.c
> > @@ -16,6 +16,7 @@
> >  #include "xe_guc_pc.h"
> >  #include "xe_guc_rc.h"
> >  #include "xe_pm.h"
> > +#include "xe_wedge.h"
> >  
> >  /**
> >   * DOC: GuC RC (Render C-states)
> > @@ -40,7 +41,7 @@ static int guc_action_setup_gucrc(struct xe_guc *guc, u32 control)
> >  	int ret;
> >  
> >  	ret = xe_guc_ct_send(&guc->ct, action, ARRAY_SIZE(action), 0, 0);
> > -	if (ret && !(xe_device_wedged(guc_to_xe(guc)) && ret == -ECANCELED))
> > +	if (ret && !(xe_wedged(guc_to_xe(guc)) && ret == -ECANCELED))
> >  		xe_gt_err(guc_to_gt(guc),
> >  			  "GuC RC setup %s(%u) failed (%pe)\n",
> >  			   control == GUCRC_HOST_CONTROL ? "HOST_CONTROL" :
> > @@ -73,7 +74,7 @@ static void xe_guc_rc_fini_hw(void *arg)
> >  	struct xe_device *xe = guc_to_xe(guc);
> >  	struct xe_gt *gt = guc_to_gt(guc);
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return;
> >  
> >  	CLASS(xe_force_wake, fw_ref)(gt_to_fw(gt), XE_FW_GT);
> > diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> > index 0a6e2b81b5a5..2fbb1eecd80c 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> > @@ -47,6 +47,7 @@
> >  #include "xe_trace.h"
> >  #include "xe_uc_fw.h"
> >  #include "xe_vm.h"
> > +#include "xe_wedge.h"
> >  
> >  #define XE_GUC_EXEC_QUEUE_CGP_CONTEXT_ERROR_LEN		6
> >  
> > @@ -1388,10 +1389,10 @@ static bool guc_submit_hint_wedged(struct xe_guc *guc)
> >  	if (xe->wedged.mode != XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
> >  		return false;
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return true;
> >  
> > -	xe_device_declare_wedged(xe);
> > +	xe_wedge_declare(xe);
> >  
> >  	return true;
> >  }
> > @@ -1598,7 +1599,7 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job)
> >  	if (!exec_queue_killed(q))
> >  		wedged = guc_submit_hint_wedged(exec_queue_to_guc(q));
> >  	else
> > -		wedged = xe_device_wedged(xe);
> > +		wedged = xe_wedged(xe);
> >  
> >  	/*
> >  	 * Only tag as GPU hang if this is the original timeout, not a
> > @@ -1718,7 +1719,7 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job)
> >  	}
> >  
> >  	if (wedge_device)
> > -		xe_device_declare_wedged(gt_to_xe(q->gt));
> > +		xe_wedge_declare(gt_to_xe(q->gt));
> >  
> >  	/*
> >  	 * We want the job added back to the pending list so it gets freed; this
> > @@ -2462,7 +2463,7 @@ static int guc_exec_queue_wait_suspend_done(struct xe_exec_queue *q, bool blocki
> >  						       WAIT_COND, HZ * 5);
> >  	}
> >  
> > -	if (!blocking && vf_recovery(guc) && !xe_device_wedged(xe))
> > +	if (!blocking && vf_recovery(guc) && !xe_wedged(xe))
> >  		return -EAGAIN;
> >  
> >  	if (!ret)
> > @@ -2720,7 +2721,7 @@ int xe_guc_submit_reset_prepare(struct xe_guc *guc)
> >  
> >  void xe_guc_submit_reset_wait(struct xe_guc *guc)
> >  {
> > -	wait_event(guc->ct.wq, xe_device_wedged(guc_to_xe(guc)) ||
> > +	wait_event(guc->ct.wq, xe_wedged(guc_to_xe(guc)) ||
> >  		   !xe_guc_read_stopped(guc));
> >  }
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_guc_tlb_inval.c b/drivers/gpu/drm/xe/xe_guc_tlb_inval.c
> > index 111fef781b2a..dd38d95c6014 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_tlb_inval.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_tlb_inval.c
> > @@ -19,6 +19,7 @@
> >  #include "xe_sa.h"
> >  #include "xe_tlb_inval.h"
> >  #include "xe_vm.h"
> > +#include "xe_wedge.h"
> >  
> >  #include "regs/xe_guc_regs.h"
> >  
> > @@ -77,7 +78,7 @@ static int send_tlb_inval_ggtt(struct xe_tlb_inval *tlb_inval, u32 seqno)
> >  		};
> >  
> >  		return send_tlb_inval(guc, action, ARRAY_SIZE(action));
> > -	} else if (xe_device_uc_enabled(xe) && !xe_device_wedged(xe)) {
> > +	} else if (xe_device_uc_enabled(xe) && !xe_wedged(xe)) {
> >  		struct xe_mmio *mmio = &gt->mmio;
> >  
> >  		if (IS_SRIOV_VF(xe))
> > diff --git a/drivers/gpu/drm/xe/xe_mert.c b/drivers/gpu/drm/xe/xe_mert.c
> > index 32700c19a1df..b9948153ca0b 100644
> > --- a/drivers/gpu/drm/xe/xe_mert.c
> > +++ b/drivers/gpu/drm/xe/xe_mert.c
> > @@ -11,6 +11,7 @@
> >  #include "xe_mmio.h"
> >  #include "xe_sriov_printk.h"
> >  #include "xe_tile.h"
> > +#include "xe_wedge.h"
> >  
> >  /**
> >   * xe_mert_init_early() - Initialize MERT data
> > @@ -74,7 +75,7 @@ static void mert_handle_cat_error(struct xe_device *xe)
> >  		break;
> >  	case CATERR_UNMAPPED_GGTT:
> >  		xe_sriov_err(xe, "MERT: CAT_ERR: Access to an unmapped GGTT!\n");
> > -		xe_device_declare_wedged(xe);
> > +		xe_wedge_declare(xe);
> >  		break;
> >  	case CATERR_LMTT_FAULT:
> >  		xe_sriov_dbg_ratelimited(xe, "MERT: CAT_ERR: VF%u LMTT fault!\n", vfid);
> > @@ -82,7 +83,7 @@ static void mert_handle_cat_error(struct xe_device *xe)
> >  		break;
> >  	default:
> >  		xe_sriov_err(xe, "MERT: Unexpected CAT_ERR code=%#x!\n", code);
> > -		xe_device_declare_wedged(xe);
> > +		xe_wedge_declare(xe);
> >  		break;
> >  	}
> >  }
> > diff --git a/drivers/gpu/drm/xe/xe_pci_error.c b/drivers/gpu/drm/xe/xe_pci_error.c
> > index 79ce0c671549..418b07dc983a 100644
> > --- a/drivers/gpu/drm/xe/xe_pci_error.c
> > +++ b/drivers/gpu/drm/xe/xe_pci_error.c
> > @@ -13,6 +13,7 @@
> >  #include "xe_printk.h"
> >  #include "xe_ras.h"
> >  #include "xe_survivability_mode.h"
> > +#include "xe_wedge.h"
> >  
> >  static void prepare_device_for_reset(struct pci_dev *pdev)
> >  {
> > @@ -22,7 +23,7 @@ static void prepare_device_for_reset(struct pci_dev *pdev)
> >  
> >  	/*
> >  	 * Wedge the device to prevent userspace access but do not send the uevent.
> > -	 * xe_device_wedged_fini() releases runtime pm if wedged flag is set, so acquire a runtime
> > +	 * xe_wedge_fini() releases runtime pm if wedged flag is set, so acquire a runtime
> >  	 * pm reference to avoid underflow.
> >  	 */
> >  	if (!atomic_xchg(&xe->wedged.flag, 1))
> > @@ -31,7 +32,7 @@ static void prepare_device_for_reset(struct pci_dev *pdev)
> >  	xe_device_set_in_reset(xe);
> >  
> >  	for_each_gt(gt, xe, id)
> > -		xe_gt_declare_wedged(gt);
> > +		xe_gt_wedge_declare(gt);
> >  
> >  	pci_disable_device(pdev);
> >  }
> > @@ -61,7 +62,7 @@ static pci_ers_result_t xe_pci_error_detected(struct pci_dev *pdev, pci_channel_
> >  		return PCI_ERS_RESULT_DISCONNECT;
> >  
> >  	/* If the device is already wedged or in survivability mode, do not attempt recovery */
> > -	if (xe_survivability_mode_is_boot_enabled(xe) || xe_device_wedged(xe))
> > +	if (xe_survivability_mode_is_boot_enabled(xe) || xe_wedged(xe))
> >  		return PCI_ERS_RESULT_DISCONNECT;
> >  
> >  	switch (state) {
> > @@ -86,7 +87,7 @@ static pci_ers_result_t xe_pci_error_mmio_enabled(struct pci_dev *pdev)
> >  
> >  	/* User wants to debug the error, prevent reset */
> >  	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET) {
> > -		xe_device_declare_wedged(xe);
> > +		xe_wedge_declare(xe);
> >  		return PCI_ERS_RESULT_DISCONNECT;
> >  	}
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_ras.c b/drivers/gpu/drm/xe/xe_ras.c
> > index 7a85735c57d5..2e8eb8856f97 100644
> > --- a/drivers/gpu/drm/xe/xe_ras.c
> > +++ b/drivers/gpu/drm/xe/xe_ras.c
> > @@ -16,6 +16,7 @@
> >  #include "xe_sysctrl_event_types.h"
> >  #include "xe_sysctrl_mailbox.h"
> >  #include "xe_sysctrl_mailbox_types.h"
> > +#include "xe_wedge.h"
> >  
> >  #define CORE_COMPUTE_UNCORR_TYPE	GENMASK(26, 25)
> >  /*
> > @@ -321,8 +322,8 @@ static u8 handle_core_compute_errors(struct xe_ras_error_array *arr)
> >  
> >  static void punit_error_handler(struct xe_device *xe)
> >  {
> > -	xe_device_set_wedged_method(xe, DRM_WEDGE_RECOVERY_COLD_RESET);
> > -	xe_device_declare_wedged(xe);
> > +	xe_wedge_set_method(xe, DRM_WEDGE_RECOVERY_COLD_RESET);
> > +	xe_wedge_declare(xe);
> >  }
> >  
> >  static u8 handle_soc_internal_errors(struct xe_device *xe, struct xe_ras_error_array *arr)
> > diff --git a/drivers/gpu/drm/xe/xe_sriov_pf.c b/drivers/gpu/drm/xe/xe_sriov_pf.c
> > index 33bd754d138f..ce0db26203ec 100644
> > --- a/drivers/gpu/drm/xe/xe_sriov_pf.c
> > +++ b/drivers/gpu/drm/xe/xe_sriov_pf.c
> > @@ -19,6 +19,7 @@
> >  #include "xe_sriov_pf_service.h"
> >  #include "xe_sriov_pf_sysfs.h"
> >  #include "xe_sriov_printk.h"
> > +#include "xe_wedge.h"
> >  
> >  static unsigned int wanted_max_vfs(struct xe_device *xe)
> >  {
> > @@ -157,7 +158,7 @@ int xe_sriov_pf_wait_ready(struct xe_device *xe)
> >  	unsigned int id;
> >  	int err;
> >  
> > -	if (xe_device_wedged(xe))
> > +	if (xe_wedged(xe))
> >  		return -ECANCELED;
> >  
> >  	for_each_gt(gt, xe, id) {
> > diff --git a/drivers/gpu/drm/xe/xe_survivability_mode.c b/drivers/gpu/drm/xe/xe_survivability_mode.c
> > index 45d44ebe288b..dacb6303b8da 100644
> > --- a/drivers/gpu/drm/xe/xe_survivability_mode.c
> > +++ b/drivers/gpu/drm/xe/xe_survivability_mode.c
> > @@ -20,6 +20,7 @@
> >  #include "xe_pcode_api.h"
> >  #include "xe_printk.h"
> >  #include "xe_vsec.h"
> > +#include "xe_wedge.h"
> >  
> >  /**
> >   * DOC: Survivability Mode
> > @@ -446,8 +447,8 @@ void xe_survivability_mode_runtime_enable(struct xe_device *xe)
> >  	survivability->type = XE_SURVIVABILITY_TYPE_RUNTIME;
> >  	xe_log_err(xe, SURVIVABILITY, 0, "Runtime Mode enabled!\n");
> >  
> > -	xe_device_set_wedged_method(xe, DRM_WEDGE_RECOVERY_VENDOR);
> > -	xe_device_declare_wedged(xe);
> > +	xe_wedge_set_method(xe, DRM_WEDGE_RECOVERY_VENDOR);
> > +	xe_wedge_declare(xe);
> >  
> >  	xe_log_err(xe, SURVIVABILITY, 0, "Firmware flash required!\n");
> >  	xe_info(xe, "Please refer to the userspace documentation for more details how to flash the firmware on %s!\n",
> > diff --git a/drivers/gpu/drm/xe/xe_uc.c b/drivers/gpu/drm/xe/xe_uc.c
> > index 65f59f06177f..686c28856014 100644
> > --- a/drivers/gpu/drm/xe/xe_uc.c
> > +++ b/drivers/gpu/drm/xe/xe_uc.c
> > @@ -326,15 +326,15 @@ void xe_uc_runtime_resume(struct xe_uc *uc)
> >  }
> >  
> >  /**
> > - * xe_uc_declare_wedged() - Declare UC wedged
> > + * xe_uc_wedge_declare() - Declare UC wedged
> >   * @uc: the UC object
> >   *
> >   * Wedge the UC which stops all submission, saves desired debug state, and
> >   * cleans up anything which could timeout.
> >   */
> > -void xe_uc_declare_wedged(struct xe_uc *uc)
> > +void xe_uc_wedge_declare(struct xe_uc *uc)
> >  {
> >  	xe_gt_assert(uc_to_gt(uc), uc_to_xe(uc)->wedged.mode);
> >  
> > -	xe_guc_declare_wedged(&uc->guc);
> > +	xe_guc_wedge_declare(&uc->guc);
> >  }
> > diff --git a/drivers/gpu/drm/xe/xe_uc.h b/drivers/gpu/drm/xe/xe_uc.h
> > index 255a54a8f876..23bc0ce1c42f 100644
> > --- a/drivers/gpu/drm/xe/xe_uc.h
> > +++ b/drivers/gpu/drm/xe/xe_uc.h
> > @@ -21,6 +21,6 @@ int xe_uc_start(struct xe_uc *uc);
> >  void xe_uc_suspend_prepare(struct xe_uc *uc);
> >  int xe_uc_suspend(struct xe_uc *uc);
> >  int xe_uc_sanitize_reset(struct xe_uc *uc);
> > -void xe_uc_declare_wedged(struct xe_uc *uc);
> > +void xe_uc_wedge_declare(struct xe_uc *uc);
> >  
> >  #endif
> > diff --git a/drivers/gpu/drm/xe/xe_wedge.c b/drivers/gpu/drm/xe/xe_wedge.c
> > new file mode 100644
> > index 000000000000..c3710a5eafcd
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_wedge.c
> > @@ -0,0 +1,286 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#include <drm/drm_drv.h>
> > +#include <drm/drm_managed.h>
> > +
> > +#include "xe_defaults.h"
> > +#include "xe_device_types.h"
> > +#include "xe_gt.h"
> > +#include "xe_gt_printk.h"
> > +#include "xe_guc_ads.h"
> > +#include "xe_log.h"
> > +#include "xe_module.h"
> > +#include "xe_pm.h"
> > +#include "xe_printk.h"
> > +#include "xe_wedge.h"
> 
> missing at least sriov include in here...
> 
> > +
> > +/**
> > + * DOC: Xe Device Wedging
> > + *
> > + * Xe driver uses drm device wedged uevent as documented in Documentation/gpu/drm-uapi.rst.
> > + * When device is in wedged state, every IOCTL will be blocked and GT cannot
> > + * be used. The conditions under which the driver declares the device wedged
> > + * depend on the wedge mode configuration (see &enum xe_wedged_mode). The
> > + * default recovery method for a wedged state is rebind/bus-reset.
> > + *
> > + * Another recovery method is vendor-specific. Below are the cases that send
> > + * ``WEDGED=vendor-specific`` recovery method in drm device wedged uevent.
> > + *
> > + * Case: Firmware Flash
> > + * --------------------
> > + *
> > + * Identification Hint
> > + * +++++++++++++++++++
> > + *
> > + * ``WEDGED=vendor-specific`` drm device wedged uevent with
> > + * :ref:`Runtime Survivability mode <xe-survivability-mode>` is used to notify
> > + * admin/userspace consumer about the need for a firmware flash.
> > + *
> > + * Recovery Procedure
> > + * ++++++++++++++++++
> > + *
> > + * Once ``WEDGED=vendor-specific`` drm device wedged uevent is received, follow
> > + * the below steps
> > + *
> > + * - Check Runtime Survivability mode sysfs.
> > + *   If enabled, firmware flash is required to recover the device.
> > + *
> > + *   /sys/bus/pci/devices/<device>/survivability_mode
> > + *
> > + * - Admin/userspace consumer can use firmware flashing tools like fwupd to flash
> > + *   firmware and restore device to normal operation.
> > + */
> > +
> > +/**
> > + * xe_wedge_set_method() - Set wedge recovery method
> > + * @xe: xe device instance
> > + * @method: recovery method to set
> > + *
> > + * Set wedge recovery method to be sent in drm wedged uevent.
> > + */
> > +void xe_wedge_set_method(struct xe_device *xe, unsigned long method)
> > +{
> > +	xe->wedged.method = method;
> > +}
> > +
> > +/**
> > + * xe_wedged() - Check for wedged device
> > + * @xe: xe device instance
> > + *
> > + * Returns: %true if device is wedged, %false otherwise.
> > + */
> > +bool xe_wedged(struct xe_device *xe)
> > +{
> > +	return atomic_read(&xe->wedged.flag);
> > +}
> > +
> > +static void wedge_work(struct work_struct *work)
> > +{
> > +	struct xe_device *xe = container_of(work, struct xe_device, wedged.work);
> > +
> > +	/*
> > +	 * XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging
> > +	 * hangs, so wedge the device with 'none' recovery method and have
> > +	 * it available to the user for debugging.
> > +	 */
> > +	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
> > +		xe_wedge_set_method(xe, DRM_WEDGE_RECOVERY_NONE);
> > +	/* If no wedge recovery method is set, use default */
> > +	else if (!xe->wedged.method)
> > +		xe_wedge_set_method(xe, DRM_WEDGE_RECOVERY_REBIND |
> > +					DRM_WEDGE_RECOVERY_BUS_RESET);
> > +
> > +	/* Notify userspace of wedged device */
> > +	drm_dev_wedged_event(&xe->drm, xe->wedged.method, NULL);
> > +}
> > +
> > +#define WEDGED_URL	"https://docs.kernel.org/gpu/drm-uapi.html#device-wedging"
> > +#define XE_BUG_URL	"https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"
> > +
> > +/**
> > + * xe_wedge_declare() - Declare device wedged
> > + * @xe: xe device instance
> > + *
> > + * This is a final state that can only be cleared with the recovery method
> > + * specified in the drm wedged uevent. The method can be set using
> > + * xe_wedge_set_method() before declaring the device as wedged.
> > + * If no method is set, rebind/bus-reset will be sent by default.
> > + *
> > + * In this state every IOCTL will be blocked so the GT cannot be used.
> > + * In general it will be called upon any critical error such as gt reset
> > + * failure or guc loading failure. Userspace will be notified of this state
> > + * through device wedged uevent.
> > + * If xe.wedged module parameter is set to 2, this function will be called
> > + * on every single execution timeout (a.k.a. GPU hang) right after devcoredump
> > + * snapshot capture. In this mode, GT reset won't be attempted so the state of
> > + * the issue is preserved for further debugging.
> > + *
> > + * Since the wedge handling is done as part of worker thread, this is safe for
> > + * atomic callers.
> > + */
> > +void xe_wedge_declare(struct xe_device *xe)
> > +{
> > +	struct xe_gt *gt;
> > +	u8 id;
> > +
> > +	if (xe->wedged.mode == XE_WEDGED_MODE_NEVER) {
> > +		xe_dbg(xe, "Wedged mode is forcibly disabled\n");
> > +		return;
> > +	}
> > +
> > +	if (atomic_xchg(&xe->wedged.flag, 1))
> > +		return;
> > +
> > +	xe->needs_flr_on_fini = true;
> > +	xe_pm_runtime_get_noresume(xe);
> > +
> > +	xe_log_err_fatal(xe, WEDGED, -EIO, "Device declared wedged!\n");
> > +	xe_err_once(xe, "IOCTLs and executions are now blocked!\n"
> > +			"For recovery procedure, refer to %s\n"
> > +			"Please file a _new_ bug report at %s\n",
> > +			WEDGED_URL, XE_BUG_URL);
> > +
> > +	for_each_gt(gt, xe, id)
> > +		xe_gt_wedge_declare(gt);
> > +
> > +	schedule_work(&xe->wedged.work);
> > +}
> > +
> > +static const char *wedge_mode_to_string(enum xe_wedged_mode mode)
> > +{
> > +	switch (mode) {
> > +	case XE_WEDGED_MODE_NEVER:
> > +		return "never";
> > +	case XE_WEDGED_MODE_UPON_CRITICAL_ERROR:
> > +		return "upon-critical-error";
> > +	case XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET:
> > +		return "upon-any-hang-no-reset";
> > +	default:
> > +		return "<invalid>";
> > +	}
> > +}
> > +
> > +static int wedge_validate_mode(struct xe_device *xe, unsigned int mode)
> > +{
> > +	if (mode > XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET) {
> > +		xe_dbg(xe, "wedged_mode: invalid value (%u)\n", mode);
> > +		return -EINVAL;
> > +	} else if (mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET && (IS_SRIOV_VF(xe) ||
> > +		   (IS_SRIOV_PF(xe) && !IS_ENABLED(CONFIG_DRM_XE_DEBUG)))) {
> > +		xe_dbg(xe, "wedged_mode: (%u) %s mode is not supported for %s\n",
> > +		       mode, wedge_mode_to_string(mode),
> > +		       xe_sriov_mode_to_string(xe_device_sriov_mode(xe)));
> > +		return -EPERM;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static bool wedge_mode_needs_policy_update(struct xe_device *xe, enum xe_wedged_mode mode)
> > +{
> > +	if (xe->wedged.inconsistent_reset)
> > +		return true;
> > +
> > +	if (xe->wedged.mode == mode)
> > +		return false;
> > +
> > +	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ||
> > +	    mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
> > +		return true;
> > +
> > +	return false;
> > +}
> > +
> > +static int __wedge_mode_set_reset_policy(struct xe_gt *gt, enum xe_wedged_mode mode)
> > +{
> > +	bool enable_engine_reset;
> > +	int ret;
> > +
> > +	enable_engine_reset = (mode != XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET);
> > +	ret = xe_guc_ads_scheduler_policy_toggle_reset(&gt->uc.guc.ads,
> > +						       enable_engine_reset);
> > +	if (ret)
> > +		xe_gt_err(gt, "Failed to update GuC ADS scheduler policy (%pe)\n", ERR_PTR(ret));
> > +
> > +	return ret;
> > +}
> > +
> > +static int wedge_mode_set_reset_policy(struct xe_device *xe, enum xe_wedged_mode mode)
> > +{
> > +	struct xe_gt *gt;
> > +	int ret;
> > +	u8 id;
> > +
> > +	guard(xe_pm_runtime)(xe);
> > +	for_each_gt(gt, xe, id) {
> > +		ret = __wedge_mode_set_reset_policy(gt, mode);
> > +		if (ret) {
> > +			if (id > 0) {
> > +				xe->wedged.inconsistent_reset = true;
> > +				xe_err(xe, "Inconsistent reset policy state between GTs\n");
> > +			}
> > +			return ret;
> > +		}
> > +	}
> > +
> > +	xe->wedged.inconsistent_reset = false;
> > +
> > +	return 0;
> > +}
> > +
> > +/**
> > + * xe_wedge_set_mode() - Set wedge mode
> > + * @xe: xe device instance
> > + * @mode: wedge mode to be set
> > + *
> > + * Returns: 0 on success, negative error code otherwise.
> > + */
> > +int xe_wedge_set_mode(struct xe_device *xe, enum xe_wedged_mode mode)
> > +{
> > +	int ret;
> > +
> > +	ret = wedge_validate_mode(xe, mode);
> > +	if (ret)
> > +		return ret;
> > +
> > +	if (wedge_mode_needs_policy_update(xe, mode)) {
> > +		ret = wedge_mode_set_reset_policy(xe, mode);
> > +		if (ret)
> > +			return ret;
> > +	}
> > +
> > +	xe->wedged.mode = mode;
> > +
> > +	return ret;
> > +}
> > +
> > +static void xe_wedge_fini(struct drm_device *drm, void *arg)
> > +{
> > +	struct xe_device *xe = arg;
> > +
> > +	disable_work_sync(&xe->wedged.work);
> > +
> > +	if (atomic_read(&xe->wedged.flag))
> > +		xe_pm_runtime_put(xe);
> > +}
> > +
> > +/**
> > + * xe_wedge_init() - Initialize wedge
> > + * @xe: xe device instance
> > + *
> > + * Returns: 0 on success, negative error code otherwise.
> > + */
> > +int xe_wedge_init(struct xe_device *xe)
> > +{
> > +	INIT_WORK(&xe->wedged.work, wedge_work);
> > +
> > +	xe->wedged.mode = wedge_validate_mode(xe, xe_modparam.wedged_mode) ?
> > +			  XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;
> > +	xe_dbg(xe, "wedged_mode: setting mode (%u) %s\n",
> > +	       xe->wedged.mode, wedge_mode_to_string(xe->wedged.mode));
> > +
> > +	return drmm_add_action_or_reset(&xe->drm, xe_wedge_fini, xe);
> > +}
> > diff --git a/drivers/gpu/drm/xe/xe_wedge.h b/drivers/gpu/drm/xe/xe_wedge.h
> > new file mode 100644
> > index 000000000000..e564a3b9d7d8
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_wedge.h
> > @@ -0,0 +1,20 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _XE_WEDGE_H_
> > +#define _XE_WEDGE_H_
> > +
> > +#include <linux/types.h>
> > +
> > +struct xe_device;
> > +enum xe_wedged_mode;
> > +
> > +bool xe_wedged(struct xe_device *xe);
> > +void xe_wedge_declare(struct xe_device *xe);
> > +int xe_wedge_init(struct xe_device *xe);
> > +void xe_wedge_set_method(struct xe_device *xe, unsigned long method);
> > +int xe_wedge_set_mode(struct xe_device *xe, enum xe_wedged_mode mode);
> > +
> > +#endif
> > diff --git a/drivers/gpu/drm/xe/xe_wedge_types.h b/drivers/gpu/drm/xe/xe_wedge_types.h
> > new file mode 100644
> > index 000000000000..e6084f151c62
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_wedge_types.h
> > @@ -0,0 +1,45 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _XE_WEDGE_TYPES_H_
> > +#define _XE_WEDGE_TYPES_H_
> > +
> > +#include <linux/atomic.h>
> > +#include <linux/types.h>
> > +#include <linux/workqueue_types.h>
> > +
> > +/**
> > + * enum xe_wedged_mode - Possible wedge modes
> > + * @XE_WEDGED_MODE_NEVER: Device will never be declared wedged.
> > + * @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only
> > + *	when critical error occurs like GT reset failure or firmware failure.
> > + *	This is the default mode.
> > + * @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on
> > + *	any hang. In this mode, engine resets are disabled to avoid automatic
> > + *	recovery attempts. This mode is primarily intended for debugging hangs.
> > + */
> > +enum xe_wedged_mode {
> > +	XE_WEDGED_MODE_NEVER = 0,
> > +	XE_WEDGED_MODE_UPON_CRITICAL_ERROR = 1,
> > +	XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET = 2,
> > +};
> > +
> > +/**
> > + * struct xe_wedge - Struct to control Wedged States and mode
> > + */
> > +struct xe_wedge {
> > +	/** @flag: Xe device faced a critical error and is now blocked. */
> > +	atomic_t flag;
> > +	/** @mode: Mode controlled by kernel parameter and debugfs */
> > +	enum xe_wedged_mode mode;
> > +	/** @method: Recovery method to be sent in the drm device wedged uevent */
> > +	unsigned long method;
> > +	/** @inconsistent_reset: Inconsistent reset policy state between GTs */
> > +	bool inconsistent_reset;
> > +	/** @work: Worker for wedge handling */
> > +	struct work_struct work;
> > +};
> > +
> > +#endif
> > -- 
> > 2.43.0
> >