drm/i915/lmem: support optional CPU clearing for special internal use

For some internal device local-memory objects it would be useful to have
an option to CPU clear the pages upon gathering the backing store. Note
that this might be before the blitter is useable, which is the case for
some internal GuC objects.

Signed-off-by: Matthew Auld <matthew.auld@intel.com>
Cc: Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com>
Cc: Jon Bloomfield <jon.bloomfield@intel.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Kenneth Graunke <kenneth@whitecape.org>
Cc: Jason Ekstrand <jason@jlekstrand.net>
Cc: Dave Airlie <airlied@gmail.com>
Cc: dri-devel@lists.freedesktop.org
Cc: mesa-dev@lists.freedesktop.org
Acked-by: Kenneth Graunke <kenneth@whitecape.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20210429103056.407067-7-matthew.auld@intel.com

diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h
index 69d6e54bc56969a35c55d0d92ec32de0b3fcf3e8..0727d0c76aa082137d1ebc17bf5a0baeba645d2d 100644 (file)
--- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h
+++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h
@@ -172,11 +172,13 @@ struct drm_i915_gem_object {
 #define I915_BO_ALLOC_CONTIGUOUS BIT(0)
 #define I915_BO_ALLOC_VOLATILE   BIT(1)
 #define I915_BO_ALLOC_STRUCT_PAGE BIT(2)
+#define I915_BO_ALLOC_CPU_CLEAR  BIT(3)
 #define I915_BO_ALLOC_FLAGS (I915_BO_ALLOC_CONTIGUOUS | \
                             I915_BO_ALLOC_VOLATILE | \
-                            I915_BO_ALLOC_STRUCT_PAGE)
-#define I915_BO_READONLY         BIT(3)
-#define I915_TILING_QUIRK_BIT    4 /* unknown swizzling; do not release! */
+                            I915_BO_ALLOC_STRUCT_PAGE | \
+                            I915_BO_ALLOC_CPU_CLEAR)
+#define I915_BO_READONLY         BIT(4)
+#define I915_TILING_QUIRK_BIT    5 /* unknown swizzling; do not release! */
 
        /*
         * Is the object to be mapped as read-only to the GPU

diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.c b/drivers/gpu/drm/i915/gem/i915_gem_region.c
index 6a84fb6dde24d417db596eb74a042cac11d61615..ce8fcfc5407932abc20b739478c21bd22ae3f227 100644 (file)
--- a/drivers/gpu/drm/i915/gem/i915_gem_region.c
+++ b/drivers/gpu/drm/i915/gem/i915_gem_region.c
@@ -95,6 +95,28 @@ i915_gem_object_get_pages_buddy(struct drm_i915_gem_object *obj)
        sg_mark_end(sg);
        i915_sg_trim(st);
 
+       /* Intended for kernel internal use only */
+       if (obj->flags & I915_BO_ALLOC_CPU_CLEAR) {
+               struct scatterlist *sg;
+               unsigned long i;
+
+               for_each_sg(st->sgl, sg, st->nents, i) {
+                       unsigned int length;
+                       void __iomem *vaddr;
+                       dma_addr_t daddr;
+
+                       daddr = sg_dma_address(sg);
+                       daddr -= mem->region.start;
+                       length = sg_dma_len(sg);
+
+                       vaddr = io_mapping_map_wc(&mem->iomap, daddr, length);
+                       memset64((void __force *)vaddr, 0, length / sizeof(u64));
+                       io_mapping_unmap(vaddr);
+               }
+
+               wmb();
+       }
+
        __i915_gem_object_set_pages(obj, st, sg_page_sizes);
 
        return 0;

diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c
index a5fc0bf3feb9a74f21a48775089f3cffa3637190..f85fd8cbfbf5d89cf4a0243e14595ca218c07458 100644 (file)
--- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c
+++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c
@@ -513,7 +513,7 @@ static int igt_cpu_check(struct drm_i915_gem_object *obj, u32 dword, u32 val)
        if (err)
                return err;
 
-       ptr = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WC);
+       ptr = i915_gem_object_pin_map(obj, I915_MAP_WC);
        if (IS_ERR(ptr))
                return PTR_ERR(ptr);
 
@@ -593,7 +593,9 @@ static int igt_gpu_write(struct i915_gem_context *ctx,
                if (err)
                        break;
 
+               i915_gem_object_lock(obj, NULL);
                err = igt_cpu_check(obj, dword, rng);
+               i915_gem_object_unlock(obj);
                if (err)
                        break;
        } while (!__igt_timeout(end_time, NULL));
@@ -629,6 +631,88 @@ out_put:
        return err;
 }
 
+static int igt_lmem_create_cleared_cpu(void *arg)
+{
+       struct drm_i915_private *i915 = arg;
+       I915_RND_STATE(prng);
+       IGT_TIMEOUT(end_time);
+       u32 size, i;
+       int err;
+
+       i915_gem_drain_freed_objects(i915);
+
+       size = max_t(u32, PAGE_SIZE, i915_prandom_u32_max_state(SZ_32M, &prng));
+       size = round_up(size, PAGE_SIZE);
+       i = 0;
+
+       do {
+               struct drm_i915_gem_object *obj;
+               unsigned int flags;
+               u32 dword, val;
+               void *vaddr;
+
+               /*
+                * Alternate between cleared and uncleared allocations, while
+                * also dirtying the pages each time to check that the pages are
+                * always cleared if requested, since we should get some overlap
+                * of the underlying pages, if not all, since we are the only
+                * user.
+                */
+
+               flags = I915_BO_ALLOC_CPU_CLEAR;
+               if (i & 1)
+                       flags = 0;
+
+               obj = i915_gem_object_create_lmem(i915, size, flags);
+               if (IS_ERR(obj))
+                       return PTR_ERR(obj);
+
+               i915_gem_object_lock(obj, NULL);
+               err = i915_gem_object_pin_pages(obj);
+               if (err)
+                       goto out_put;
+
+               dword = i915_prandom_u32_max_state(PAGE_SIZE / sizeof(u32),
+                                                  &prng);
+
+               if (flags & I915_BO_ALLOC_CPU_CLEAR) {
+                       err = igt_cpu_check(obj, dword, 0);
+                       if (err) {
+                               pr_err("%s failed with size=%u, flags=%u\n",
+                                      __func__, size, flags);
+                               goto out_unpin;
+                       }
+               }
+
+               vaddr = i915_gem_object_pin_map(obj, I915_MAP_WC);
+               if (IS_ERR(vaddr)) {
+                       err = PTR_ERR(vaddr);
+                       goto out_unpin;
+               }
+
+               val = prandom_u32_state(&prng);
+
+               memset32(vaddr, val, obj->base.size / sizeof(u32));
+
+               i915_gem_object_flush_map(obj);
+               i915_gem_object_unpin_map(obj);
+out_unpin:
+               i915_gem_object_unpin_pages(obj);
+               __i915_gem_object_put_pages(obj);
+out_put:
+               i915_gem_object_unlock(obj);
+               i915_gem_object_put(obj);
+
+               if (err)
+                       break;
+               ++i;
+       } while (!__igt_timeout(end_time, NULL));
+
+       pr_info("%s completed (%u) iterations\n", __func__, i);
+
+       return err;
+}
+
 static int igt_lmem_write_gpu(void *arg)
 {
        struct drm_i915_private *i915 = arg;
@@ -1043,6 +1127,7 @@ int intel_memory_region_live_selftests(struct drm_i915_private *i915)
 {
        static const struct i915_subtest tests[] = {
                SUBTEST(igt_lmem_create),
+               SUBTEST(igt_lmem_create_cleared_cpu),
                SUBTEST(igt_lmem_write_cpu),
                SUBTEST(igt_lmem_write_gpu),
        };