Commit ec9223b4 authored by Matthew Brost's avatar Matthew Brost
Browse files

drm/xe: Drop bo->size 



bo->size is redundant because the base GEM object already has a size
field with the same value. Drop bo->size and use the base GEM object’s
size instead. While at it, introduce xe_bo_size() to abstract the BO
size.

v2:
 - Fix typo in kernel doc (Ashutosh)
 - Fix kunit (CI)
 - Fix line wrap (Checkpatch)
v3:
 - Fix sriov build (CI)
v4:
 - Fix display build (CI)

Signed-off-by: default avatarMatthew Brost <matthew.brost@intel.com>
Reviewed-by: default avatarAshutosh Dixit <ashutosh.dixit@intel.com>
Link: https://lore.kernel.org/r/20250625144128.2827577-1-matthew.brost@intel.com
parent 9c7d93a8

drivers/gpu/drm/xe/display/xe_fb_pin.c

+1 −1
Original line number Diff line number Diff line
@@ -227,7 +227,7 @@ static int __xe_pin_fb_vma_ggtt(const struct intel_framebuffer *fb, 
			goto out_unlock;

		}



		ret = xe_ggtt_node_insert_locked(vma->node, bo->size, align, 0);

		ret = xe_ggtt_node_insert_locked(vma->node, xe_bo_size(bo), align, 0);

		if (ret) {

			xe_ggtt_node_fini(vma->node);

			goto out_unlock;

drivers/gpu/drm/xe/display/xe_hdcp_gsc.c

+1 −1
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ static int intel_hdcp_gsc_initialize_message(struct xe_device *xe, 


	cmd_in = xe_bo_ggtt_addr(bo);

	cmd_out = cmd_in + PAGE_SIZE;

	xe_map_memset(xe, &bo->vmap, 0, 0, bo->size);

	xe_map_memset(xe, &bo->vmap, 0, 0, xe_bo_size(bo));



	gsc_context->hdcp_bo = bo;

	gsc_context->hdcp_cmd_in = cmd_in;

drivers/gpu/drm/xe/tests/xe_bo.c

+1 −1
Original line number Diff line number Diff line
@@ -106,7 +106,7 @@ static int ccs_test_migrate(struct xe_tile *tile, struct xe_bo *bo, 
	}



	/* Check last CCS value, or at least last value in page. */

	offset = xe_device_ccs_bytes(tile_to_xe(tile), bo->size);

	offset = xe_device_ccs_bytes(tile_to_xe(tile), xe_bo_size(bo));

	offset = min_t(u32, offset, PAGE_SIZE) / sizeof(u64) - 1;

	if (cpu_map[offset] != get_val) {

		KUNIT_FAIL(test,

drivers/gpu/drm/xe/tests/xe_guc_buf_kunit.c

+2 −2
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ static struct xe_bo *replacement_xe_managed_bo_create_pin_map(struct xe_device * 


	bo->tile = tile;

	bo->ttm.bdev = &xe->ttm;

	bo->size = size;

	bo->ttm.base.size = size;

	iosys_map_set_vaddr(&bo->vmap, buf);



	if (flags & XE_BO_FLAG_GGTT) {
@@ -43,7 +43,7 @@ static struct xe_bo *replacement_xe_managed_bo_create_pin_map(struct xe_device * 


		KUNIT_ASSERT_EQ(test, 0,

				xe_ggtt_node_insert(bo->ggtt_node[tile->id],

						    bo->size, SZ_4K));

						    xe_bo_size(bo), SZ_4K));

	}



	return bo;

drivers/gpu/drm/xe/tests/xe_migrate.c

+26 −26
Original line number Diff line number Diff line
@@ -74,13 +74,13 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo, 
{

	struct xe_device *xe = tile_to_xe(m->tile);

	u64 retval, expected = 0;

	bool big = bo->size >= SZ_2M;

	bool big = xe_bo_size(bo) >= SZ_2M;

	struct dma_fence *fence;

	const char *str = big ? "Copying big bo" : "Copying small bo";

	int err;



	struct xe_bo *remote = xe_bo_create_locked(xe, m->tile, NULL,

						   bo->size,

						   xe_bo_size(bo),

						   ttm_bo_type_kernel,

						   region |

						   XE_BO_FLAG_NEEDS_CPU_ACCESS |
@@ -105,7 +105,7 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo, 
		goto out_unlock;

	}



	xe_map_memset(xe, &remote->vmap, 0, 0xd0, remote->size);

	xe_map_memset(xe, &remote->vmap, 0, 0xd0, xe_bo_size(remote));

	fence = xe_migrate_clear(m, remote, remote->ttm.resource,

				 XE_MIGRATE_CLEAR_FLAG_FULL);

	if (!sanity_fence_failed(xe, fence, big ? "Clearing remote big bo" :
@@ -113,15 +113,15 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo, 
		retval = xe_map_rd(xe, &remote->vmap, 0, u64);

		check(retval, expected, "remote first offset should be cleared",

		      test);

		retval = xe_map_rd(xe, &remote->vmap, remote->size - 8, u64);

		retval = xe_map_rd(xe, &remote->vmap, xe_bo_size(remote) - 8, u64);

		check(retval, expected, "remote last offset should be cleared",

		      test);

	}

	dma_fence_put(fence);



	/* Try to copy 0xc0 from remote to vram with 2MB or 64KiB/4KiB pages */

	xe_map_memset(xe, &remote->vmap, 0, 0xc0, remote->size);

	xe_map_memset(xe, &bo->vmap, 0, 0xd0, bo->size);

	xe_map_memset(xe, &remote->vmap, 0, 0xc0, xe_bo_size(remote));

	xe_map_memset(xe, &bo->vmap, 0, 0xd0, xe_bo_size(bo));



	expected = 0xc0c0c0c0c0c0c0c0;

	fence = xe_migrate_copy(m, remote, bo, remote->ttm.resource,
@@ -131,15 +131,15 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo, 
		retval = xe_map_rd(xe, &bo->vmap, 0, u64);

		check(retval, expected,

		      "remote -> vram bo first offset should be copied", test);

		retval = xe_map_rd(xe, &bo->vmap, bo->size - 8, u64);

		retval = xe_map_rd(xe, &bo->vmap, xe_bo_size(bo) - 8, u64);

		check(retval, expected,

		      "remote -> vram bo offset should be copied", test);

	}

	dma_fence_put(fence);



	/* And other way around.. slightly hacky.. */

	xe_map_memset(xe, &remote->vmap, 0, 0xd0, remote->size);

	xe_map_memset(xe, &bo->vmap, 0, 0xc0, bo->size);

	xe_map_memset(xe, &remote->vmap, 0, 0xd0, xe_bo_size(remote));

	xe_map_memset(xe, &bo->vmap, 0, 0xc0, xe_bo_size(bo));



	fence = xe_migrate_copy(m, bo, remote, bo->ttm.resource,

				remote->ttm.resource, false);
@@ -148,7 +148,7 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo, 
		retval = xe_map_rd(xe, &remote->vmap, 0, u64);

		check(retval, expected,

		      "vram -> remote bo first offset should be copied", test);

		retval = xe_map_rd(xe, &remote->vmap, bo->size - 8, u64);

		retval = xe_map_rd(xe, &remote->vmap, xe_bo_size(bo) - 8, u64);

		check(retval, expected,

		      "vram -> remote bo last offset should be copied", test);

	}
@@ -245,9 +245,9 @@ static void xe_migrate_sanity_test(struct xe_migrate *m, struct kunit *test) 
	if (m->q->vm->flags & XE_VM_FLAG_64K)

		expected |= XE_PTE_PS64;

	if (xe_bo_is_vram(pt))

		xe_res_first(pt->ttm.resource, 0, pt->size, &src_it);

		xe_res_first(pt->ttm.resource, 0, xe_bo_size(pt), &src_it);

	else

		xe_res_first_sg(xe_bo_sg(pt), 0, pt->size, &src_it);

		xe_res_first_sg(xe_bo_sg(pt), 0, xe_bo_size(pt), &src_it);



	emit_pte(m, bb, NUM_KERNEL_PDE - 1, xe_bo_is_vram(pt), false,

		 &src_it, XE_PAGE_SIZE, pt->ttm.resource);
@@ -276,7 +276,7 @@ static void xe_migrate_sanity_test(struct xe_migrate *m, struct kunit *test) 


	/* Clear a small bo */

	kunit_info(test, "Clearing small buffer object\n");

	xe_map_memset(xe, &tiny->vmap, 0, 0x22, tiny->size);

	xe_map_memset(xe, &tiny->vmap, 0, 0x22, xe_bo_size(tiny));

	expected = 0;

	fence = xe_migrate_clear(m, tiny, tiny->ttm.resource,

				 XE_MIGRATE_CLEAR_FLAG_FULL);
@@ -286,7 +286,7 @@ static void xe_migrate_sanity_test(struct xe_migrate *m, struct kunit *test) 
	dma_fence_put(fence);

	retval = xe_map_rd(xe, &tiny->vmap, 0, u32);

	check(retval, expected, "Command clear small first value", test);

	retval = xe_map_rd(xe, &tiny->vmap, tiny->size - 4, u32);

	retval = xe_map_rd(xe, &tiny->vmap, xe_bo_size(tiny) - 4, u32);

	check(retval, expected, "Command clear small last value", test);



	kunit_info(test, "Copying small buffer object to system\n");
@@ -298,7 +298,7 @@ static void xe_migrate_sanity_test(struct xe_migrate *m, struct kunit *test) 


	/* Clear a big bo */

	kunit_info(test, "Clearing big buffer object\n");

	xe_map_memset(xe, &big->vmap, 0, 0x11, big->size);

	xe_map_memset(xe, &big->vmap, 0, 0x11, xe_bo_size(big));

	expected = 0;

	fence = xe_migrate_clear(m, big, big->ttm.resource,

				 XE_MIGRATE_CLEAR_FLAG_FULL);
@@ -308,7 +308,7 @@ static void xe_migrate_sanity_test(struct xe_migrate *m, struct kunit *test) 
	dma_fence_put(fence);

	retval = xe_map_rd(xe, &big->vmap, 0, u32);

	check(retval, expected, "Command clear big first value", test);

	retval = xe_map_rd(xe, &big->vmap, big->size - 4, u32);

	retval = xe_map_rd(xe, &big->vmap, xe_bo_size(big) - 4, u32);

	check(retval, expected, "Command clear big last value", test);



	kunit_info(test, "Copying big buffer object to system\n");
@@ -370,7 +370,7 @@ static struct dma_fence *blt_copy(struct xe_tile *tile, 
	struct xe_migrate *m = tile->migrate;

	struct xe_device *xe = gt_to_xe(gt);

	struct dma_fence *fence = NULL;

	u64 size = src_bo->size;

	u64 size = xe_bo_size(src_bo);

	struct xe_res_cursor src_it, dst_it;

	struct ttm_resource *src = src_bo->ttm.resource, *dst = dst_bo->ttm.resource;

	u64 src_L0_ofs, dst_L0_ofs;
@@ -498,7 +498,7 @@ static void test_migrate(struct xe_device *xe, struct xe_tile *tile, 
	long ret;



	expected = 0xd0d0d0d0d0d0d0d0;

	xe_map_memset(xe, &sys_bo->vmap, 0, 0xd0, sys_bo->size);

	xe_map_memset(xe, &sys_bo->vmap, 0, 0xd0, xe_bo_size(sys_bo));



	fence = blt_copy(tile, sys_bo, vram_bo, false, "Blit copy from sysmem to vram", test);

	if (!sanity_fence_failed(xe, fence, "Blit copy from sysmem to vram", test)) {
@@ -523,7 +523,7 @@ static void test_migrate(struct xe_device *xe, struct xe_tile *tile, 


	retval = xe_map_rd(xe, &vram_bo->vmap, 0, u64);

	check(retval, expected, "Clear evicted vram data first value", test);

	retval = xe_map_rd(xe, &vram_bo->vmap, vram_bo->size - 8, u64);

	retval = xe_map_rd(xe, &vram_bo->vmap, xe_bo_size(vram_bo) - 8, u64);

	check(retval, expected, "Clear evicted vram data last value", test);



	fence = blt_copy(tile, vram_bo, ccs_bo,
@@ -532,7 +532,7 @@ static void test_migrate(struct xe_device *xe, struct xe_tile *tile, 
		retval = xe_map_rd(xe, &ccs_bo->vmap, 0, u64);

		check(retval, 0, "Clear ccs data first value", test);



		retval = xe_map_rd(xe, &ccs_bo->vmap, ccs_bo->size - 8, u64);

		retval = xe_map_rd(xe, &ccs_bo->vmap, xe_bo_size(ccs_bo) - 8, u64);

		check(retval, 0, "Clear ccs data last value", test);

	}

	dma_fence_put(fence);
@@ -562,7 +562,7 @@ static void test_migrate(struct xe_device *xe, struct xe_tile *tile, 


	retval = xe_map_rd(xe, &vram_bo->vmap, 0, u64);

	check(retval, expected, "Restored value must be equal to initial value", test);

	retval = xe_map_rd(xe, &vram_bo->vmap, vram_bo->size - 8, u64);

	retval = xe_map_rd(xe, &vram_bo->vmap, xe_bo_size(vram_bo) - 8, u64);

	check(retval, expected, "Restored value must be equal to initial value", test);



	fence = blt_copy(tile, vram_bo, ccs_bo,
@@ -570,7 +570,7 @@ static void test_migrate(struct xe_device *xe, struct xe_tile *tile, 
	if (!sanity_fence_failed(xe, fence, "Clear ccs buffer data", test)) {

		retval = xe_map_rd(xe, &ccs_bo->vmap, 0, u64);

		check(retval, 0, "Clear ccs data first value", test);

		retval = xe_map_rd(xe, &ccs_bo->vmap, ccs_bo->size - 8, u64);

		retval = xe_map_rd(xe, &ccs_bo->vmap, xe_bo_size(ccs_bo) - 8, u64);

		check(retval, 0, "Clear ccs data last value", test);

	}

	dma_fence_put(fence);
@@ -583,7 +583,7 @@ static void test_clear(struct xe_device *xe, struct xe_tile *tile, 
	u64 expected, retval;



	expected = 0xd0d0d0d0d0d0d0d0;

	xe_map_memset(xe, &sys_bo->vmap, 0, 0xd0, sys_bo->size);

	xe_map_memset(xe, &sys_bo->vmap, 0, 0xd0, xe_bo_size(sys_bo));



	fence = blt_copy(tile, sys_bo, vram_bo, false, "Blit copy from sysmem to vram", test);

	if (!sanity_fence_failed(xe, fence, "Blit copy from sysmem to vram", test)) {
@@ -597,7 +597,7 @@ static void test_clear(struct xe_device *xe, struct xe_tile *tile, 
	if (!sanity_fence_failed(xe, fence, "Blit copy from vram to sysmem", test)) {

		retval = xe_map_rd(xe, &sys_bo->vmap, 0, u64);

		check(retval, expected, "Decompressed value must be equal to initial value", test);

		retval = xe_map_rd(xe, &sys_bo->vmap, sys_bo->size - 8, u64);

		retval = xe_map_rd(xe, &sys_bo->vmap, xe_bo_size(sys_bo) - 8, u64);

		check(retval, expected, "Decompressed value must be equal to initial value", test);

	}

	dma_fence_put(fence);
@@ -615,7 +615,7 @@ static void test_clear(struct xe_device *xe, struct xe_tile *tile, 
	if (!sanity_fence_failed(xe, fence, "Clear main buffer data", test)) {

		retval = xe_map_rd(xe, &sys_bo->vmap, 0, u64);

		check(retval, expected, "Clear main buffer first value", test);

		retval = xe_map_rd(xe, &sys_bo->vmap, sys_bo->size - 8, u64);

		retval = xe_map_rd(xe, &sys_bo->vmap, xe_bo_size(sys_bo) - 8, u64);

		check(retval, expected, "Clear main buffer last value", test);

	}

	dma_fence_put(fence);
@@ -625,7 +625,7 @@ static void test_clear(struct xe_device *xe, struct xe_tile *tile, 
	if (!sanity_fence_failed(xe, fence, "Clear ccs buffer data", test)) {

		retval = xe_map_rd(xe, &sys_bo->vmap, 0, u64);

		check(retval, expected, "Clear ccs data first value", test);

		retval = xe_map_rd(xe, &sys_bo->vmap, sys_bo->size - 8, u64);

		retval = xe_map_rd(xe, &sys_bo->vmap, xe_bo_size(sys_bo) - 8, u64);

		check(retval, expected, "Clear ccs data last value", test);

	}

	dma_fence_put(fence);