PAT and cache coherency support
Subsystems (3)
v10 cover PAT and cache coherency support
Branch available here:
https://gitlab.freedesktop.org/mwa/kernel/-/tree/xe-pat-index?ref_type=heads
IGT changes:
https://patchwork.freedesktop.org/series/124667/
Mesa:
https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/25462
Goal here is to allow userspace to directly control the pat_index when mapping memory via the ppGTT, in addtion to the CPU caching mode. This is very much needed on newer igpu platforms which allow incoherent GT access, where the choice over the cache level and expected coherency is best left to userspace depending on their usecase. In the future there may also be other stuff encoded in the pat_index, so giving userspace direct control will also be needed there.
To support this we added new gem_create uAPI for selecting the CPU cache mode to use for system memory, including the expected GPU coherency mode. There are various restrictions here for the selected coherency mode and compatible CPU cache modes. With that in place the actual pat_index can now be provided as part of vm_bind. The only restriction is that the coherency mode of the pat_index must be at least as coherent as the gem_create coherency mode. There are also some special cases like with userptr and dma-buf.
v2:
- Loads of improvements/tweaks. Main changes are to now allow gem_create.coh_mode <= coh_mode(pat_index), rather than it needing to match exactly. This simplifies the dma-buf policy from userspace pov. Also we now only consider COH_NONE and COH_AT_LEAST_1WAY.
v3:
- Rebase. Split the pte_encode() refactoring, plus various smaller tweaks and fixes.
v4:
- Rebase on Lucas' new series.
- Drop UC cache mode.
- s/smem_cpu_caching/cpu_caching/. Idea is to make VRAM WC explicit in the uapi, plus make it more future proof.
v5:
- Rebase, plus some small tweaks and fixes.
v6:
- CI hooks fixes + checkpatch.
v7:
- Some small tweaks
v8:
- Rebase on Xe2 PAT table additions.
v9:
- Drop coh_mode.
v10:
- Rebase. Also add some UMD acks.
Signature · 1 line
2.42.0
PATCH v10 1/3 drm/xe/uapi: Add support for CPU caching mode
From: Pallavi Mishra <[email protected]>
Allow userspace to specify the CPU caching mode at object creation. Modify gem create handler and introduce xe_bo_create_user to replace xe_bo_create. In a later patch we will support setting the pat_index as part of vm_bind, where expectation is that the coherency mode extracted from the pat_index must be least 1way coherent if using cpu_caching=wb.
v2
- s/smem_caching/smem_cpu_caching/ and s/XE_GEM_CACHING/XE_GEM_CPU_CACHING/. (Matt Roper)
- Drop COH_2WAY and just use COH_NONE + COH_AT_LEAST_1WAY; KMD mostly just cares that zeroing/swap-in can't be bypassed with the given smem_caching mode. (Matt Roper)
- Fix broken range check for coh_mode and smem_cpu_caching and also don't use constant value, but the already defined macros. (José)
- Prefer switch statement for smem_cpu_caching -> ttm_caching. (José)
- Add note in kernel-doc for dgpu and coherency modes for system memory. (José)
v3 (José):
- Make sure to reject coh_mode == 0 for VRAM-only.
- Also make sure to actually pass along the (start, end) for
__xe_bo_create_locked.
v4
- Drop UC caching mode. Can be added back if we need it. (Matt Roper)
- s/smem_cpu_caching/cpu_caching. Idea is that VRAM is always WC, but that is currently implicit and KMD controlled. Make it explicit in the uapi with the limitation that it currently must be WC. For VRAM
+ SYS objects userspace must now select WC. (José)
- Make sure to initialize bo_flags. (José)
v5
- Make to align with the other uapi and prefix uapi constants with DRM_ (José)
v6:
- Make it clear that zero cpu_caching is only allowed for kernel objects. (José)
v7: (Oak)
- With all the changes from the original design, it looks we can further simplify here and drop the explicit coh_mode. We can just infer the coh_mode from the cpu_caching. i.e reject cpu_caching=wb + coh_none. It's one less thing for userspace to maintain so seems worth it.
Testcase: igt@xe_mmap@cpu-caching
--- drivers/gpu/drm/xe/xe_bo.c | 102 +++++++++++++++++++++++-------- drivers/gpu/drm/xe/xe_bo.h | 9 +-- drivers/gpu/drm/xe/xe_bo_types.h | 5 ++ drivers/gpu/drm/xe/xe_dma_buf.c | 5 +- include/uapi/drm/xe_drm.h | 19 +++++- 5 files changed, 108 insertions(+), 32 deletions(-)
drivers/gpu/drm/xe/xe_bo.c +77 -25
@@ -327,7 +327,7 @@ static struct ttm_tt *xe_ttm_tt_create(struct ttm_buffer_object *ttm_bo,struct xe_device *xe =xe_bo_device (bo);struct xe_ttm_tt *tt;unsigned long extra_pages; -enum ttm_caching caching = ttm_cached; +enum ttm_caching caching;int err; tt =kzalloc (sizeof (*tt),GFP_KERNEL );
@@ -341,13 +341,24 @@ static struct ttm_tt *xe_ttm_tt_create(struct ttm_buffer_object *ttm_bo, extra_pages =DIV_ROUND_UP (xe_device_ccs_bytes (xe, bo->size),PAGE_SIZE ); +switch (bo->cpu_caching) { +case DRM_XE_GEM_CPU_CACHING_WC : + caching = ttm_write_combined; +break ; +default : + caching = ttm_cached; +break ; + } + +WARN_ON ((bo->flags &XE_BO_CREATE_USER_BIT ) && !bo->cpu_caching); +/* * Display scanout is always non-coherent with the CPU cache. * * For Xe_LPG and beyond, PPGTT PTE lookups are also non-coherent and * require a CPU:WC mapping. */ -if (bo->flags &XE_BO_SCANOUT_BIT || +if ((!bo->cpu_caching && bo->flags &XE_BO_SCANOUT_BIT ) || (xe->info.graphics_verx100 >=1270 && bo->flags &XE_BO_PAGETABLE )) caching = ttm_write_combined;
@@ -1191,10 +1202,11 @@ void xe_bo_free(struct xe_bo *bo)kfree (bo); } -struct xe_bo *__xe_bo_create_locked (struct xe_device *xe,struct xe_bo *bo, -struct xe_tile *tile,struct dma_resv *resv, -struct ttm_lru_bulk_move *bulk,size_t size, -enum ttm_bo_type type,u32 flags) +struct xe_bo *___xe_bo_create_locked (struct xe_device *xe,struct xe_bo *bo, +struct xe_tile *tile,struct dma_resv *resv, +struct ttm_lru_bulk_move *bulk,size_t size, +u16 cpu_caching,enum ttm_bo_type type, +u32 flags) {struct ttm_operation_ctx ctx = { .interruptible = true,
@@ -1232,6 +1244,7 @@ struct xe_bo *__xe_bo_create_locked(struct xe_device *xe, struct xe_bo *bo, bo->tile = tile; bo->size = size; bo->flags = flags; + bo->cpu_caching = cpu_caching; bo->ttm.base.funcs = &xe_gem_object_funcs; bo->props.preferred_mem_class =XE_BO_PROPS_INVALID ; bo->props.preferred_gt =XE_BO_PROPS_INVALID ;
@@ -1347,11 +1360,11 @@ static int __xe_bo_fixed_placement(struct xe_device *xe,return 0 ; } -struct xe_bo * -xe_bo_create_locked_range (struct xe_device *xe, -struct xe_tile *tile,struct xe_vm *vm, -size_t size,u64 start,u64 end, -enum ttm_bo_type type,u32 flags) +static struct xe_bo * +__xe_bo_create_locked (struct xe_device *xe, +struct xe_tile *tile,struct xe_vm *vm, +size_t size,u64 start,u64 end, +u16 cpu_caching,enum ttm_bo_type type,u32 flags) {struct xe_bo *bo =NULL ;int err;
@@ -1372,11 +1385,11 @@ xe_bo_create_locked_range(struct xe_device *xe, } } - bo =__xe_bo_create_locked (xe, bo, tile, vm ? &vm->resv :NULL , - vm && !xe_vm_in_fault_mode (vm) && - flags &XE_BO_CREATE_USER_BIT ? - &vm->lru_bulk_move :NULL , size, - type, flags); + bo =___xe_bo_create_locked (xe, bo, tile, vm ? &vm->resv :NULL , + vm && !xe_vm_in_fault_mode (vm) && + flags &XE_BO_CREATE_USER_BIT ? + &vm->lru_bulk_move :NULL , size, + cpu_caching, type, flags);if (IS_ERR (bo))return bo;
@@ -1409,11 +1422,35 @@ xe_bo_create_locked_range(struct xe_device *xe,return ERR_PTR (err); } +struct xe_bo * +xe_bo_create_locked_range (struct xe_device *xe, +struct xe_tile *tile,struct xe_vm *vm, +size_t size,u64 start,u64 end, +enum ttm_bo_type type,u32 flags) +{ +return __xe_bo_create_locked (xe, tile, vm, size, start, end,0 , type, flags); +} +struct xe_bo *xe_bo_create_locked (struct xe_device *xe,struct xe_tile *tile,struct xe_vm *vm,size_t size,enum ttm_bo_type type,u32 flags) { -return xe_bo_create_locked_range (xe, tile, vm, size,0 , ~0ULL , type, flags); +return __xe_bo_create_locked (xe, tile, vm, size,0 , ~0ULL ,0 , type, flags); +} + +static struct xe_bo *xe_bo_create_user (struct xe_device *xe,struct xe_tile *tile, +struct xe_vm *vm,size_t size, +u16 cpu_caching, +enum ttm_bo_type type, +u32 flags) +{ +struct xe_bo *bo =__xe_bo_create_locked (xe, tile, vm, size,0 , ~0ULL , + cpu_caching, type, + flags |XE_BO_CREATE_USER_BIT ); +if (!IS_ERR (bo)) +xe_bo_unlock_vm_held (bo); + +return bo; } struct xe_bo *xe_bo_create(struct xe_device *xe, struct xe_tile *tile,
@@ -1795,11 +1832,11 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data,struct drm_xe_gem_create *args = data;struct xe_vm *vm =NULL ;struct xe_bo *bo; -unsigned int bo_flags =XE_BO_CREATE_USER_BIT ; +unsigned int bo_flags;u32 handle;int err; -if (XE_IOCTL_DBG (xe, args->extensions) ||XE_IOCTL_DBG (xe, args->pad) || +if (XE_IOCTL_DBG (xe, args->extensions) ||XE_IOCTL_DBG (xe, args->reserved[0 ] || args->reserved[1 ]))return -EINVAL ;
@@ -1826,6 +1863,7 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data,if (XE_IOCTL_DBG (xe, args->size & ~PAGE_MASK ))return -EINVAL ; + bo_flags =0 ;if (args->flags &DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING ) bo_flags |=XE_BO_DEFER_BACKING ;
@@ -1841,6 +1879,18 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data, bo_flags |=XE_BO_NEEDS_CPU_ACCESS ; } +if (XE_IOCTL_DBG (xe, !args->cpu_caching || + args->cpu_caching >DRM_XE_GEM_CPU_CACHING_WC )) +return -EINVAL ; + +if (XE_IOCTL_DBG (xe, bo_flags &XE_BO_CREATE_VRAM_MASK && + args->cpu_caching !=DRM_XE_GEM_CPU_CACHING_WC )) +return -EINVAL ; + +if (XE_IOCTL_DBG (xe, bo_flags &XE_BO_SCANOUT_BIT && + args->cpu_caching ==DRM_XE_GEM_CPU_CACHING_WB )) +return -EINVAL ; +if (args->vm_id) { vm =xe_vm_lookup (xef, args->vm_id);if (XE_IOCTL_DBG (xe, !vm))
@@ -1850,8 +1900,8 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data, goto out_vm; } - bo =xe_bo_create (xe,NULL , vm, args->size, ttm_bo_type_device, - bo_flags); + bo =xe_bo_create_user (xe,NULL , vm, args->size, args->cpu_caching, + ttm_bo_type_device, bo_flags);if (vm)xe_vm_unlock (vm);
@@ -2149,10 +2199,12 @@ int xe_bo_dumb_create(struct drm_file *file_priv, args->size =ALIGN (mul_u32_u32 (args->pitch, args->height), page_size); - bo =xe_bo_create (xe,NULL ,NULL , args->size, ttm_bo_type_device, -XE_BO_CREATE_VRAM_IF_DGFX (xe_device_get_root_tile (xe)) | -XE_BO_CREATE_USER_BIT |XE_BO_SCANOUT_BIT | -XE_BO_NEEDS_CPU_ACCESS ); + bo =xe_bo_create_user (xe,NULL ,NULL , args->size, +DRM_XE_GEM_CPU_CACHING_WC , + ttm_bo_type_device, +XE_BO_CREATE_VRAM_IF_DGFX (xe_device_get_root_tile (xe)) | +XE_BO_CREATE_USER_BIT |XE_BO_SCANOUT_BIT | +XE_BO_NEEDS_CPU_ACCESS );if (IS_ERR (bo))return PTR_ERR (bo);
drivers/gpu/drm/xe/xe_bo.h +5 -4
@@ -85,10 +85,11 @@ struct sg_table;struct xe_bo *xe_bo_alloc (void );void xe_bo_free (struct xe_bo *bo); -struct xe_bo *__xe_bo_create_locked (struct xe_device *xe,struct xe_bo *bo, -struct xe_tile *tile,struct dma_resv *resv, -struct ttm_lru_bulk_move *bulk,size_t size, -enum ttm_bo_type type,u32 flags); +struct xe_bo *___xe_bo_create_locked (struct xe_device *xe,struct xe_bo *bo, +struct xe_tile *tile,struct dma_resv *resv, +struct ttm_lru_bulk_move *bulk,size_t size, +u16 cpu_caching,enum ttm_bo_type type, +u32 flags);struct xe_bo * xe_bo_create_locked_range(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm,
drivers/gpu/drm/xe/xe_bo_types.h +5 -0
@@ -79,6 +79,11 @@ struct xe_bo {struct llist_node freed;/** @created: Whether the bo has passed initial creation */ bool created; +/** +* @cpu_caching: CPU caching mode. Currently only used for userspace +* objects. +*/ +u16 cpu_caching; };#define intel_bo_to_drm_bo (bo) (&(bo)->ttm.base)
drivers/gpu/drm/xe/xe_dma_buf.c +3 -2
@@ -214,8 +214,9 @@ xe_dma_buf_init_obj(struct drm_device *dev, struct xe_bo *storage,int ret;dma_resv_lock (resv,NULL ); - bo =__xe_bo_create_locked (xe, storage,NULL , resv,NULL , dma_buf->size, - ttm_bo_type_sg,XE_BO_CREATE_SYSTEM_BIT ); + bo =___xe_bo_create_locked (xe, storage,NULL , resv,NULL , dma_buf->size, +0 ,/* Will require 1way or 2way for vm_bind */ + ttm_bo_type_sg,XE_BO_CREATE_SYSTEM_BIT );if (IS_ERR (bo)) { ret =PTR_ERR (bo); goto error;
include/uapi/drm/xe_drm.h +18 -1
@@ -541,8 +541,25 @@ struct drm_xe_gem_create {*/ __u32 handle; +/** +* @cpu_caching: The CPU caching mode to select for this object. If +* mmaping the object the mode selected here will also be used. +* +* Supported values: +* +* DRM_XE_GEM_CPU_CACHING_WB: Allocate the pages with write-back +* caching. On iGPU this can't be used for scanout surfaces. Currently +* not allowed for objects placed in VRAM. +* +* DRM_XE_GEM_CPU_CACHING_WC: Allocate the pages as write-combined. This +* is uncached. Scanout surfaces should likely use this. All objects +* that can be placed in VRAM must use this. +*/ +#define DRM_XE_GEM_CPU_CACHING_WB 1 +#define DRM_XE_GEM_CPU_CACHING_WC 2 +__u16 cpu_caching;/** @pad: MBZ */ -__u32 pad; +__u16 pad;/** @reserved: Reserved */ __u64 reserved[2 ];
Signature · 1 line
2.42.0
PATCH v10 2/3 drm/xe/pat: annotate pat_index with coherency mode
In reply to Matthew AuldFuture uapi needs to give userspace the ability to select the pat_index for a given vm_bind. However we need to be able to extract the coherency mode from the provided pat_index to ensure it's compatible with the cpu_caching mode set at object creation. There are various security reasons for why this matters. However the pat_index itself is very platform specific, so seems reasonable to annotate each platform definition of the pat table. On some older platforms there is no explicit coherency mode, so we just pick whatever makes sense.
v2:
- Simplify with COH_AT_LEAST_1_WAY
- Add some kernel-doc
v3 (Matt Roper):
- Some small tweaks
v4:
- Rebase
v5:
- Rebase on Xe2 PAT additions
v6:
- Rebase on removal of coh_mode from uapi
Bspec: 45101, 44235 #xe
Bspec: 70552, 71582, 59400 #xe2
--- drivers/gpu/drm/xe/xe_device_types.h | 2 +- drivers/gpu/drm/xe/xe_pat.c | 96 +++++++++++++++++----------- drivers/gpu/drm/xe/xe_pat.h | 31 ++++++++- 3 files changed, 88 insertions(+), 41 deletions(-)
drivers/gpu/drm/xe/xe_device_types.h +1 -1
@@ -359,7 +359,7 @@ struct xe_device {/** Internal operations to abstract platforms */ const struct xe_pat_ops *ops;/** PAT table to program in the HW */ -const u32 *table; +const struct xe_pat_table_entry *table;/** Number of PAT entries */ int n_entries;u32 idx[__XE_CACHE_LEVEL_COUNT];
drivers/gpu/drm/xe/xe_pat.c +57 -39
158 lines not on this page · raw message
drivers/gpu/drm/xe/xe_pat.h +30 -1
@@ -6,9 +6,30 @@#ifndef _XE_PAT_H_#define _XE_PAT_H_ +#include <linux/types.h> +struct drm_printer ; -struct xe_gt ;struct xe_device ; +struct xe_gt ; + +/** +* struct xe_pat_table_entry - The pat_index encoding and other meta information. +*/ +struct xe_pat_table_entry { +/** +* @value: The platform specific value encoding the various memory +* attributes (this maps to some fixed pat_index). So things like +* caching, coherency, compression etc can be encoded here. +*/ +u32 value; + +/** +* @coh_mode: The GPU coherency mode that @value maps to. +*/ +#define XE_COH_NONE 1 +#define XE_COH_AT_LEAST_1WAY 2 +u16 coh_mode; +};/** * xe_pat_init_early - SW initialization, setting up data based on device
@@ -29,4 +50,12 @@ void xe_pat_init(struct xe_gt *gt);*/ void xe_pat_dump (struct xe_gt *gt,struct drm_printer *p); +/** +* xe_pat_index_get_coh_mode - Extract the coherency mode for the given +* pat_index. +* @xe: xe device +* @pat_index: The pat_index to query +*/ +u16 xe_pat_index_get_coh_mode (struct xe_device *xe,u16 pat_index); +#endif
Signature · 1 line
2.42.0
PATCH v10 3/3 drm/xe/uapi: support pat_index selection with vm_bind
In reply to Matthew AuldAllow userspace to directly control the pat_index for a given vm binding. This should allow directly controlling the coherency, caching behaviour, compression and potentially other stuff in the future for the ppGTT binding.
The exact meaning behind the pat_index is very platform specific (see BSpec or PRMs) but effectively maps to some predefined memory attributes. From the KMD pov we only care about the coherency that is provided by the pat_index, which falls into either NONE, 1WAY or 2WAY. The vm_bind coherency mode for the given pat_index needs to be at least 1way coherent when using cpu_caching with DRM_XE_GEM_CPU_CACHING_WB. For platforms that lack the explicit coherency mode attribute, we treat UC/WT/WC as NONE and WB as AT_LEAST_1WAY.
For userptr mappings we lack a corresponding gem object, so the expected coherency mode is instead implicit and must fall into either 1WAY or 2WAY. Trying to use NONE will be rejected by the kernel. For imported dma-buf (from a different device) the coherency mode is also implicit and must also be either 1WAY or 2WAY.
v2:
- Undefined coh_mode(pat_index) can now be treated as programmer error. (Matt Roper)
- We now allow gem_create.coh_mode <= coh_mode(pat_index), rather than having to match exactly. This ensures imported dma-buf can always just use 1way (or even 2way), now that we also bundle 1way/2way into at_least_1way. We still require 1way/2way for external dma-buf, but the policy can now be the same for self-import, if desired.
- Use u16 for pat_index in uapi. u32 is massive overkill. (José)
- Move as much of the pat_index validation as we can into vm_bind_ioctl_check_args. (José)
v3 (Matt Roper):
- Split the pte_encode() refactoring into separate patch.
v4:
- Rebase
v5:
- Check for and reject !coh_mode which would indicate hw reserved pat_index on xe2.
v6:
- Rebase on removal of coh_mode from uapi. We just need to reject cpu_caching=wb + pat_index with coh_none.
Testcase: igt@xe_pat
Bspec: 45101, 44235 #xe
Bspec: 70552, 71582, 59400 #xe2
--- drivers/gpu/drm/xe/xe_pt.c | 11 +----- drivers/gpu/drm/xe/xe_vm.c | 68 ++++++++++++++++++++++++++++---- drivers/gpu/drm/xe/xe_vm_types.h | 7 ++++ include/uapi/drm/xe_drm.h | 42 +++++++++++++++++++- 4 files changed, 110 insertions(+), 18 deletions(-)
drivers/gpu/drm/xe/xe_pt.c +2 -9
@@ -290,8 +290,6 @@ struct xe_pt_stage_bind_walk {struct xe_vm *vm;/** @tile: The tile we're building for. */ struct xe_tile *tile; -/** @cache: Desired cache level for the ptes */ -enum xe_cache_level cache;/** @default_pte: PTE flag only template. No address is associated */ u64 default_pte;/** @dma_offset: DMA offset to add to the PTE. */
@@ -511,7 +509,7 @@ xe_pt_stage_bind_entry(struct xe_ptw *parent, pgoff_t offset, {struct xe_pt_stage_bind_walk *xe_walk =container_of (walk,typeof (*xe_walk), base); -u16 pat_index =tile_to_xe (xe_walk->tile)->pat.idx[xe_walk->cache]; +u16 pat_index = xe_walk->vma->pat_index;struct xe_pt *xe_parent =container_of (parent,typeof (*xe_parent), base);struct xe_vm *vm = xe_walk->vm;struct xe_pt *xe_child;
@@ -657,13 +655,8 @@ xe_pt_stage_bind(struct xe_tile *tile, struct xe_vma *vma,if (is_devmem) { xe_walk.default_pte |=XE_PPGTT_PTE_DM ; xe_walk.dma_offset =vram_region_gpu_offset (bo->ttm.resource); - xe_walk.cache =XE_CACHE_WB ; - }else { -if (!xe_vma_has_no_bo (vma) && bo->flags &XE_BO_SCANOUT_BIT ) - xe_walk.cache =XE_CACHE_WT ; -else - xe_walk.cache =XE_CACHE_WB ; } +if (!xe_vma_has_no_bo (vma) &&xe_bo_is_stolen (bo)) xe_walk.dma_offset =xe_ttm_stolen_gpu_offset (xe_bo_device (bo));
drivers/gpu/drm/xe/xe_vm.c +60 -8
173 lines not on this page · raw message
drivers/gpu/drm/xe/xe_vm_types.h +7 -0
@@ -110,6 +110,11 @@ struct xe_vma {*/ u8 tile_present; +/** +* @pat_index: The pat index to use when encoding the PTEs for this vma. +*/ +u16 pat_index; +struct {struct list_head rebind_link; } notifier;
@@ -402,6 +407,8 @@ struct xe_vma_op {struct list_head link;/** @tile_mask: gt mask for this operation */ u8 tile_mask; +/** @pat_index: The pat index to use for this operation. */ +u16 pat_index;/** @flags: operation flags */ enum xe_vma_op_flags flags;
include/uapi/drm/xe_drm.h +41 -1
49 lines not on this page · raw message
Signature · 1 line
2.42.0
Patchwork
CI[Intel-xe] ✗ CI.Patch_applied: failure for PAT and cache coherency support (rev12)
In reply to Matthew Auld== Series Details ==
== Series Details ==
Series: PAT and cache coherency support (rev12)
URL : https://patchwork.freedesktop.org/series/123027/
State : failure
== Summary ==
=== Applying kernel patches on branch 'drm-xe-next' with base: === Base commit: 723ff01a3 drm/xe: ATS-M device ID update
=== git am output follows ===
error: patch failed: drivers/gpu/drm/xe/xe_vm.c:2195
error: drivers/gpu/drm/xe/xe_vm.c: patch does not apply
hint: Use 'git am --show-current-patch' to see the failed patch
Applying: drm/xe/uapi: Add support for CPU caching mode
Applying: drm/xe/pat: annotate pat_index with coherency mode
Applying: drm/xe/uapi: support pat_index selection with vm_bind Patch failed at 0003 drm/xe/uapi: support pat_index selection with vm_bind When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort".
Patchwork
CI[Intel-xe] ✗ CI.Patch_applied: failure for PAT and cache coherency support (rev12)
In reply to Matthew Auld== Series Details ==
== Series Details ==
Series: PAT and cache coherency support (rev12)
URL : https://patchwork.freedesktop.org/series/123027/
State : failure
== Summary ==
=== Applying kernel patches on branch 'drm-xe-next' with base: ===
Base commit: 89e2bb1e1 fixup! drm/xe: Moving and renaming existing frequency sysfs attributes === git am output follows ===
error: patch failed: drivers/gpu/drm/xe/xe_vm.c:2195
error: drivers/gpu/drm/xe/xe_vm.c: patch does not apply
hint: Use 'git am --show-current-patch' to see the failed patch
Applying: drm/xe/uapi: Add support for CPU caching mode
Applying: drm/xe/pat: annotate pat_index with coherency mode
Applying: drm/xe/uapi: support pat_index selection with vm_bind
Patch failed at 0003 drm/xe/uapi: support pat_index selection with vm_bind When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".