[PATCH] lib/intel_pat: Handle platforms without compressed PAT index

Sanjay Yadav
2026-02-18T10:40:41Z

Previously intel_get_pat_idx_uc_comp() would silently return zero on
platforms where no compressed PAT index exists (e.g. CRI),
since uc_comp was zero-initialized by default. This could lead to
incorrect behavior when callers assume the returned index is valid.

Fix this by:
- Adding XE_PAT_IDX_INVALID sentinel to detect unsupported platforms
- Initializing uc_comp to XE_PAT_IDX_INVALID in intel_get_pat_idx();
only platforms with CCS (graphics_ver 20/30) override it to a valid
index
- Adding igt_assert_f() in intel_get_pat_idx_uc_comp() to fail with
a clear error instead of returning an invalid index

Also update the bo-comp-disable-bind test to distinguish between "CCS
is disabled" and "CCS does not exist" using HAS_FLATCCS(). On platforms
without CCS, the compressed PAT bind check is skipped since there is no
valid compressed PAT index to test with.

Suggested-by: Matthew Auld <matthew.auld@intel.com>
Signed-off-by: Sanjay Yadav <sanjay.kumar.yadav@intel.com>
---
lib/intel_pat.c | 5 +++++
lib/intel_pat.h | 1 +
tests/intel/xe_pat.c | 30 ++++++++++++++++++++++--------
3 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/lib/intel_pat.c b/lib/intel_pat.c
index 9815efc18..d30bee453 100644
--- a/lib/intel_pat.c
+++ b/lib/intel_pat.c
@@ -98,6 +98,8 @@ static void intel_get_pat_idx(int fd, struct intel_pat_cache *pat)
{
uint16_t dev_id = intel_get_drm_devid(fd);

+ pat->uc_comp = XE_PAT_IDX_INVALID;
+
if (intel_graphics_ver(dev_id) == IP_VER(35, 11)) {
pat->uc = 3;
pat->wb = 2;
@@ -155,8 +157,11 @@ uint8_t intel_get_pat_idx_uc_comp(int fd)
uint16_t dev_id = intel_get_drm_devid(fd);

igt_assert(intel_gen(dev_id) >= 20);
+ igt_assert(HAS_FLATCCS(dev_id));

intel_get_pat_idx(fd, &pat);
+ igt_assert_f(pat.uc_comp != XE_PAT_IDX_INVALID,
+ "No compressed PAT index available on this platform\n");
return pat.uc_comp;
}

diff --git a/lib/intel_pat.h b/lib/intel_pat.h
index e9ade2e2e..e5dd8a0af 100644
--- a/lib/intel_pat.h
+++ b/lib/intel_pat.h
@@ -10,6 +10,7 @@
#include <stdint.h>

#define DEFAULT_PAT_INDEX ((uint8_t)-1) /* igt-core can pick 1way or better */
+#define XE_PAT_IDX_INVALID ((uint8_t)-2) /* no such PAT index on this platform */
#define XE_PAT_MAX_ENTRIES 32

struct xe_pat_entry {
diff --git a/tests/intel/xe_pat.c b/tests/intel/xe_pat.c
index 21547c84e..052b7b699 100644
--- a/tests/intel/xe_pat.c
+++ b/tests/intel/xe_pat.c
@@ -844,15 +844,18 @@ static bool has_no_compression_hint(int fd)
* Test category: functionality test
* Description: Validates that binding a BO created with
* the NO_COMPRESSION flag using a compressed PAT index fails
- * with -EINVAL on Xe2+ platforms.
+ * with -EINVAL on Xe2+ platforms. On platforms where CCS
+ * does not exist, the test verifies uncompressed access works.
*/

static void bo_comp_disable_bind(int fd)
{
size_t size = xe_get_default_alignment(fd);
- uint8_t comp_pat_index, uncomp_pat_index;
- bool supported;
+ uint16_t dev_id = intel_get_drm_devid(fd);
+ bool has_flatccs = HAS_FLATCCS(dev_id);
+ uint8_t uncomp_pat_index;
uint32_t vm, bo;
+ bool supported;
int ret;

supported = has_no_compression_hint(fd);
@@ -868,14 +871,25 @@ static void bo_comp_disable_bind(int fd)
igt_assert_eq(ret, 0);
vm = xe_vm_create(fd, 0, 0);

- comp_pat_index = intel_get_pat_idx_uc_comp(fd);
uncomp_pat_index = intel_get_pat_idx_uc(fd);

- igt_assert_eq(__xe_vm_bind(fd, vm, 0, bo, 0, 0x100000,
- size, 0, 0, NULL, 0,
- 0, comp_pat_index, 0),
- -EINVAL);
+ /*
+ * On platforms with CCS, binding a NO_COMPRESSION BO with a
+ * compressed PAT index must fail. On platforms without CCS,
+ * there is no valid compressed PAT index, so skip this check.
+ */
+ if (has_flatccs) {
+ uint8_t comp_pat_index = intel_get_pat_idx_uc_comp(fd);
+
+ igt_assert_eq(__xe_vm_bind(fd, vm, 0, bo, 0, 0x100000,
+ size, 0, 0, NULL, 0,
+ 0, comp_pat_index, 0),
+ -EINVAL);
+ } else {
+ igt_debug("Platform has no CCS, skipping compressed PAT bind check\n");
+ }

+ /* Uncompressed bind must always succeed */
igt_assert_eq(__xe_vm_bind(fd, vm, 0, bo, 0, 0x100000,
size, 0, 0, NULL, 0,
0, uncomp_pat_index, 0),
--
2.52.0