Commit d3d76739 authored by Matthew Brost's avatar Matthew Brost Committed by Rodrigo Vivi
Browse files

drm/xe/uapi: Remove sync binds 



Remove concept of async vs sync VM bind queues, rather make all binds
async.

The following bits have dropped from the uAPI:
DRM_XE_ENGINE_CLASS_VM_BIND_ASYNC
DRM_XE_ENGINE_CLASS_VM_BIND_SYNC
DRM_XE_VM_CREATE_FLAG_ASYNC_DEFAULT
DRM_XE_VM_BIND_FLAG_ASYNC

To implement sync binds the UMD is expected to use the out-fence
interface.

v2: Send correct version
v3: Drop drm_xe_syncs

Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Francois Dugast <francois.dugast@intel.com>
Signed-off-by: default avatarMatthew Brost <matthew.brost@intel.com>
Reviewed-by: default avatarThomas Hellström <thomas.hellstrom@linux.intel.com>
Acked-by: default avatarJosé Roberto de Souza <jose.souza@intel.com>
Acked-by: default avatarMateusz Naklicki <mateusz.naklicki@intel.com>
Signed-off-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
parent 7e9337c2

drivers/gpu/drm/xe/xe_exec_queue.c

+1 −6
Original line number Diff line number Diff line
@@ -625,10 +625,7 @@ int xe_exec_queue_create_ioctl(struct drm_device *dev, void *data, 
	if (XE_IOCTL_DBG(xe, eci[0].gt_id >= xe->info.gt_count))

		return -EINVAL;



	if (eci[0].engine_class >= DRM_XE_ENGINE_CLASS_VM_BIND_ASYNC) {

		bool sync = eci[0].engine_class ==

			DRM_XE_ENGINE_CLASS_VM_BIND_SYNC;



	if (eci[0].engine_class == DRM_XE_ENGINE_CLASS_VM_BIND) {

		for_each_gt(gt, xe, id) {

			struct xe_exec_queue *new;
@@ -654,8 +651,6 @@ int xe_exec_queue_create_ioctl(struct drm_device *dev, void *data, 
						   args->width, hwe,

						   EXEC_QUEUE_FLAG_PERSISTENT |

						   EXEC_QUEUE_FLAG_VM |

						   (sync ? 0 :

						    EXEC_QUEUE_FLAG_VM_ASYNC) |

						   (id ?

						    EXEC_QUEUE_FLAG_BIND_ENGINE_CHILD :

						    0));

drivers/gpu/drm/xe/xe_exec_queue_types.h

+0 −2
Original line number Diff line number Diff line
@@ -84,8 +84,6 @@ struct xe_exec_queue { 
#define EXEC_QUEUE_FLAG_VM			BIT(4)

/* child of VM queue for multi-tile VM jobs */

#define EXEC_QUEUE_FLAG_BIND_ENGINE_CHILD	BIT(5)

/* VM jobs for this queue are asynchronous */

#define EXEC_QUEUE_FLAG_VM_ASYNC		BIT(6)



	/**

	 * @flags: flags for this exec queue, should statically setup aside from ban

drivers/gpu/drm/xe/xe_vm.c

+9 −66
Original line number Diff line number Diff line
@@ -1343,9 +1343,7 @@ struct xe_vm *xe_vm_create(struct xe_device *xe, u32 flags) 
			struct xe_gt *gt = tile->primary_gt;

			struct xe_vm *migrate_vm;

			struct xe_exec_queue *q;

			u32 create_flags = EXEC_QUEUE_FLAG_VM |

				((flags & XE_VM_FLAG_ASYNC_DEFAULT) ?

				EXEC_QUEUE_FLAG_VM_ASYNC : 0);

			u32 create_flags = EXEC_QUEUE_FLAG_VM;



			if (!vm->pt_root[id])

				continue;
@@ -1712,12 +1710,6 @@ xe_vm_bind_vma(struct xe_vma *vma, struct xe_exec_queue *q, 
	return ERR_PTR(err);

}



static bool xe_vm_sync_mode(struct xe_vm *vm, struct xe_exec_queue *q)

{

	return q ? !(q->flags & EXEC_QUEUE_FLAG_VM_ASYNC) :

		!(vm->flags & XE_VM_FLAG_ASYNC_DEFAULT);

}



static int __xe_vm_bind(struct xe_vm *vm, struct xe_vma *vma,

			struct xe_exec_queue *q, struct xe_sync_entry *syncs,

			u32 num_syncs, bool immediate, bool first_op,
@@ -1747,8 +1739,6 @@ static int __xe_vm_bind(struct xe_vm *vm, struct xe_vma *vma, 


	if (last_op)

		xe_exec_queue_last_fence_set(wait_exec_queue, vm, fence);

	if (last_op && xe_vm_sync_mode(vm, q))

		dma_fence_wait(fence, true);

	dma_fence_put(fence);



	return 0;
@@ -1791,8 +1781,6 @@ static int xe_vm_unbind(struct xe_vm *vm, struct xe_vma *vma, 
	xe_vma_destroy(vma, fence);

	if (last_op)

		xe_exec_queue_last_fence_set(wait_exec_queue, vm, fence);

	if (last_op && xe_vm_sync_mode(vm, q))

		dma_fence_wait(fence, true);

	dma_fence_put(fence);



	return 0;
@@ -1800,7 +1788,6 @@ static int xe_vm_unbind(struct xe_vm *vm, struct xe_vma *vma, 


#define ALL_DRM_XE_VM_CREATE_FLAGS (DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE | \

				    DRM_XE_VM_CREATE_FLAG_LR_MODE | \

				    DRM_XE_VM_CREATE_FLAG_ASYNC_DEFAULT | \

				    DRM_XE_VM_CREATE_FLAG_FAULT_MODE)



int xe_vm_create_ioctl(struct drm_device *dev, void *data,
@@ -1854,8 +1841,6 @@ int xe_vm_create_ioctl(struct drm_device *dev, void *data, 
		flags |= XE_VM_FLAG_SCRATCH_PAGE;

	if (args->flags & DRM_XE_VM_CREATE_FLAG_LR_MODE)

		flags |= XE_VM_FLAG_LR_MODE;

	if (args->flags & DRM_XE_VM_CREATE_FLAG_ASYNC_DEFAULT)

		flags |= XE_VM_FLAG_ASYNC_DEFAULT;

	if (args->flags & DRM_XE_VM_CREATE_FLAG_FAULT_MODE)

		flags |= XE_VM_FLAG_FAULT_MODE;
@@ -2263,8 +2248,7 @@ static int xe_vma_op_commit(struct xe_vm *vm, struct xe_vma_op *op) 
static int vm_bind_ioctl_ops_parse(struct xe_vm *vm, struct xe_exec_queue *q,

				   struct drm_gpuva_ops *ops,

				   struct xe_sync_entry *syncs, u32 num_syncs,

				   struct list_head *ops_list, bool last,

				   bool async)

				   struct list_head *ops_list, bool last)

{

	struct xe_vma_op *last_op = NULL;

	struct drm_gpuva_op *__op;
@@ -2696,23 +2680,22 @@ static int vm_bind_ioctl_ops_execute(struct xe_vm *vm, 


#ifdef TEST_VM_ASYNC_OPS_ERROR

#define SUPPORTED_FLAGS	\

	(FORCE_ASYNC_OP_ERROR | DRM_XE_VM_BIND_FLAG_ASYNC | \

	 DRM_XE_VM_BIND_FLAG_READONLY | DRM_XE_VM_BIND_FLAG_IMMEDIATE | \

	 DRM_XE_VM_BIND_FLAG_NULL | 0xffff)

	(FORCE_ASYNC_OP_ERROR | DRM_XE_VM_BIND_FLAG_READONLY | \

	 DRM_XE_VM_BIND_FLAG_IMMEDIATE | DRM_XE_VM_BIND_FLAG_NULL | 0xffff)

#else

#define SUPPORTED_FLAGS	\

	(DRM_XE_VM_BIND_FLAG_ASYNC | DRM_XE_VM_BIND_FLAG_READONLY | \

	(DRM_XE_VM_BIND_FLAG_READONLY | \

	 DRM_XE_VM_BIND_FLAG_IMMEDIATE | DRM_XE_VM_BIND_FLAG_NULL | \

	 0xffff)

#endif

#define XE_64K_PAGE_MASK 0xffffull

#define ALL_DRM_XE_SYNCS_FLAGS (DRM_XE_SYNCS_FLAG_WAIT_FOR_OP)



#define MAX_BINDS	512	/* FIXME: Picking random upper limit */



static int vm_bind_ioctl_check_args(struct xe_device *xe,

				    struct drm_xe_vm_bind *args,

				    struct drm_xe_vm_bind_op **bind_ops,

				    bool *async)

				    struct drm_xe_vm_bind_op **bind_ops)

{

	int err;

	int i;
@@ -2775,18 +2758,6 @@ static int vm_bind_ioctl_check_args(struct xe_device *xe, 
			goto free_bind_ops;

		}



		if (i == 0) {

			*async = !!(flags & DRM_XE_VM_BIND_FLAG_ASYNC);

			if (XE_IOCTL_DBG(xe, !*async && args->num_syncs)) {

				err = -EINVAL;

				goto free_bind_ops;

			}

		} else if (XE_IOCTL_DBG(xe, *async !=

					!!(flags & DRM_XE_VM_BIND_FLAG_ASYNC))) {

			err = -EINVAL;

			goto free_bind_ops;

		}



		if (XE_IOCTL_DBG(xe, op > DRM_XE_VM_BIND_OP_PREFETCH) ||

		    XE_IOCTL_DBG(xe, flags & ~SUPPORTED_FLAGS) ||

		    XE_IOCTL_DBG(xe, obj && is_null) ||
@@ -2854,14 +2825,6 @@ static int vm_bind_ioctl_signal_fences(struct xe_vm *vm, 


	xe_exec_queue_last_fence_set(to_wait_exec_queue(vm, q), vm,

				     fence);



	if (xe_vm_sync_mode(vm, q)) {

		long timeout = dma_fence_wait(fence, true);



		if (timeout < 0)

			err = -EINTR;

	}



	dma_fence_put(fence);



	return err;
@@ -2881,18 +2844,13 @@ int xe_vm_bind_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	struct xe_sync_entry *syncs = NULL;

	struct drm_xe_vm_bind_op *bind_ops;

	LIST_HEAD(ops_list);

	bool async;

	int err;

	int i;



	err = vm_bind_ioctl_check_args(xe, args, &bind_ops, &async);

	err = vm_bind_ioctl_check_args(xe, args, &bind_ops);

	if (err)

		return err;



	if (XE_IOCTL_DBG(xe, args->pad || args->pad2) ||

	    XE_IOCTL_DBG(xe, args->reserved[0] || args->reserved[1]))

		return -EINVAL;



	if (args->exec_queue_id) {

		q = xe_exec_queue_lookup(xef, args->exec_queue_id);

		if (XE_IOCTL_DBG(xe, !q)) {
@@ -2904,12 +2862,6 @@ int xe_vm_bind_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
			err = -EINVAL;

			goto put_exec_queue;

		}



		if (XE_IOCTL_DBG(xe, args->num_binds && async !=

				 !!(q->flags & EXEC_QUEUE_FLAG_VM_ASYNC))) {

			err = -EINVAL;

			goto put_exec_queue;

		}

	}



	vm = xe_vm_lookup(xef, args->vm_id);
@@ -2918,14 +2870,6 @@ int xe_vm_bind_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
		goto put_exec_queue;

	}



	if (!args->exec_queue_id) {

		if (XE_IOCTL_DBG(xe, args->num_binds && async !=

				 !!(vm->flags & XE_VM_FLAG_ASYNC_DEFAULT))) {

			err = -EINVAL;

			goto put_vm;

		}

	}



	err = down_write_killable(&vm->lock);

	if (err)

		goto put_vm;
@@ -3060,8 +3004,7 @@ int xe_vm_bind_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 


		err = vm_bind_ioctl_ops_parse(vm, q, ops[i], syncs, num_syncs,

					      &ops_list,

					      i == args->num_binds - 1,

					      async);

					      i == args->num_binds - 1);

		if (err)

			goto unwind_ops;

	}

drivers/gpu/drm/xe/xe_vm_types.h

+6 −7
Original line number Diff line number Diff line
@@ -138,13 +138,12 @@ struct xe_vm { 
	 */

#define XE_VM_FLAG_64K			BIT(0)

#define XE_VM_FLAG_LR_MODE		BIT(1)

#define XE_VM_FLAG_ASYNC_DEFAULT	BIT(2)

#define XE_VM_FLAG_MIGRATION		BIT(3)

#define XE_VM_FLAG_SCRATCH_PAGE		BIT(4)

#define XE_VM_FLAG_FAULT_MODE		BIT(5)

#define XE_VM_FLAG_BANNED		BIT(6)

#define XE_VM_FLAG_TILE_ID(flags)	FIELD_GET(GENMASK(8, 7), flags)

#define XE_VM_FLAG_SET_TILE_ID(tile)	FIELD_PREP(GENMASK(8, 7), (tile)->id)

#define XE_VM_FLAG_MIGRATION		BIT(2)

#define XE_VM_FLAG_SCRATCH_PAGE		BIT(3)

#define XE_VM_FLAG_FAULT_MODE		BIT(4)

#define XE_VM_FLAG_BANNED		BIT(5)

#define XE_VM_FLAG_TILE_ID(flags)	FIELD_GET(GENMASK(7, 6), flags)

#define XE_VM_FLAG_SET_TILE_ID(tile)	FIELD_PREP(GENMASK(7, 6), (tile)->id)

	unsigned long flags;



	/** @composite_fence_ctx: context composite fence */

include/uapi/drm/xe_drm.h

+4 −7
Original line number Diff line number Diff line
@@ -139,8 +139,7 @@ struct drm_xe_engine_class_instance { 
	 * Kernel only classes (not actual hardware engine class). Used for

	 * creating ordered queues of VM bind operations.

	 */

#define DRM_XE_ENGINE_CLASS_VM_BIND_ASYNC	5

#define DRM_XE_ENGINE_CLASS_VM_BIND_SYNC	6

#define DRM_XE_ENGINE_CLASS_VM_BIND		5

	/** @engine_class: engine class id */

	__u16 engine_class;

	/** @engine_instance: engine instance id */
@@ -660,7 +659,6 @@ struct drm_xe_vm_create { 
	 * still enable recoverable pagefaults if supported by the device.

	 */

#define DRM_XE_VM_CREATE_FLAG_LR_MODE	        (1 << 1)

#define DRM_XE_VM_CREATE_FLAG_ASYNC_DEFAULT	(1 << 2)

	/*

	 * DRM_XE_VM_CREATE_FLAG_FAULT_MODE requires also

	 * DRM_XE_VM_CREATE_FLAG_LR_MODE. It allows memory to be allocated
@@ -668,7 +666,7 @@ struct drm_xe_vm_create { 
	 * The xe driver internally uses recoverable pagefaults to implement

	 * this.

	 */

#define DRM_XE_VM_CREATE_FLAG_FAULT_MODE	(1 << 3)

#define DRM_XE_VM_CREATE_FLAG_FAULT_MODE	(1 << 2)

	/** @flags: Flags */

	__u32 flags;
@@ -776,12 +774,11 @@ struct drm_xe_vm_bind_op { 
	__u32 op;



#define DRM_XE_VM_BIND_FLAG_READONLY	(1 << 0)

#define DRM_XE_VM_BIND_FLAG_ASYNC	(1 << 1)

	/*

	 * Valid on a faulting VM only, do the MAP operation immediately rather

	 * than deferring the MAP to the page fault handler.

	 */

#define DRM_XE_VM_BIND_FLAG_IMMEDIATE	(1 << 2)

#define DRM_XE_VM_BIND_FLAG_IMMEDIATE	(1 << 1)

	/*

	 * When the NULL flag is set, the page tables are setup with a special

	 * bit which indicates writes are dropped and all reads return zero.  In
@@ -789,7 +786,7 @@ struct drm_xe_vm_bind_op { 
	 * operations, the BO handle MBZ, and the BO offset MBZ. This flag is

	 * intended to implement VK sparse bindings.

	 */

#define DRM_XE_VM_BIND_FLAG_NULL	(1 << 3)

#define DRM_XE_VM_BIND_FLAG_NULL	(1 << 2)

	/** @flags: Bind flags */

	__u32 flags;