drivers/gpu/drm/xe/xe_vm.h

   1 /* SPDX-License-Identifier: MIT */
   2 /*
   3  * Copyright © 2021 Intel Corporation
   4  */
   5
   6 #ifndef _XE_VM_H_
   7 #define _XE_VM_H_
   8
   9 #include "xe_bo_types.h"
  10 #include "xe_macros.h"
  11 #include "xe_map.h"
  12 #include "xe_vm_types.h"
  13
  14 struct drm_device;
  15 struct drm_printer;
  16 struct drm_file;
  17
  18 struct ttm_buffer_object;
  19 struct ttm_validate_buffer;
  20
  21 struct xe_exec_queue;
  22 struct xe_file;
  23 struct xe_sync_entry;
  24 struct drm_exec;
  25
  26 struct xe_vm *xe_vm_create(struct xe_device *xe, u32 flags);
  27
  28 struct xe_vm *xe_vm_lookup(struct xe_file *xef, u32 id);
  29 int xe_vma_cmp_vma_cb(const void *key, const struct rb_node *node);
  30
  31 static inline struct xe_vm *xe_vm_get(struct xe_vm *vm)
  32 {
  33         drm_gpuvm_get(&vm->gpuvm);
  34         return vm;
  35 }
  36
  37 static inline void xe_vm_put(struct xe_vm *vm)
  38 {
  39         drm_gpuvm_put(&vm->gpuvm);
  40 }
  41
  42 int xe_vm_lock(struct xe_vm *vm, bool intr);
  43
  44 void xe_vm_unlock(struct xe_vm *vm);
  45
  46 static inline bool xe_vm_is_closed(struct xe_vm *vm)
  47 {
  48         /* Only guaranteed not to change when vm->lock is held */
  49         return !vm->size;
  50 }
  51
  52 static inline bool xe_vm_is_banned(struct xe_vm *vm)
  53 {
  54         return vm->flags & XE_VM_FLAG_BANNED;
  55 }
  56
  57 static inline bool xe_vm_is_closed_or_banned(struct xe_vm *vm)
  58 {
  59         lockdep_assert_held(&vm->lock);
  60         return xe_vm_is_closed(vm) || xe_vm_is_banned(vm);
  61 }
  62
  63 struct xe_vma *
  64 xe_vm_find_overlapping_vma(struct xe_vm *vm, u64 start, u64 range);
  65
  66 static inline struct xe_vm *gpuva_to_vm(struct drm_gpuva *gpuva)
  67 {
  68         return container_of(gpuva->vm, struct xe_vm, gpuvm);
  69 }
  70
  71 static inline struct xe_vma *gpuva_to_vma(struct drm_gpuva *gpuva)
  72 {
  73         return container_of(gpuva, struct xe_vma, gpuva);
  74 }
  75
  76 static inline struct xe_vma_op *gpuva_op_to_vma_op(struct drm_gpuva_op *op)
  77 {
  78         return container_of(op, struct xe_vma_op, base);
  79 }
  80
  81 /**
  82  * DOC: Provide accessors for vma members to facilitate easy change of
  83  * implementation.
  84  */
  85 static inline u64 xe_vma_start(struct xe_vma *vma)
  86 {
  87         return vma->gpuva.va.addr;
  88 }
  89
  90 static inline u64 xe_vma_size(struct xe_vma *vma)
  91 {
  92         return vma->gpuva.va.range;
  93 }
  94
  95 static inline u64 xe_vma_end(struct xe_vma *vma)
  96 {
  97         return xe_vma_start(vma) + xe_vma_size(vma);
  98 }
  99
 100 static inline u64 xe_vma_bo_offset(struct xe_vma *vma)
 101 {
 102         return vma->gpuva.gem.offset;
 103 }
 104
 105 static inline struct xe_bo *xe_vma_bo(struct xe_vma *vma)
 106 {
 107         return !vma->gpuva.gem.obj ? NULL :
 108                 container_of(vma->gpuva.gem.obj, struct xe_bo, ttm.base);
 109 }
 110
 111 static inline struct xe_vm *xe_vma_vm(struct xe_vma *vma)
 112 {
 113         return container_of(vma->gpuva.vm, struct xe_vm, gpuvm);
 114 }
 115
 116 static inline bool xe_vma_read_only(struct xe_vma *vma)
 117 {
 118         return vma->gpuva.flags & XE_VMA_READ_ONLY;
 119 }
 120
 121 static inline u64 xe_vma_userptr(struct xe_vma *vma)
 122 {
 123         return vma->gpuva.gem.offset;
 124 }
 125
 126 static inline bool xe_vma_is_null(struct xe_vma *vma)
 127 {
 128         return vma->gpuva.flags & DRM_GPUVA_SPARSE;
 129 }
 130
 131 static inline bool xe_vma_has_no_bo(struct xe_vma *vma)
 132 {
 133         return !xe_vma_bo(vma);
 134 }
 135
 136 static inline bool xe_vma_is_userptr(struct xe_vma *vma)
 137 {
 138         return xe_vma_has_no_bo(vma) && !xe_vma_is_null(vma);
 139 }
 140
 141 u64 xe_vm_pdp4_descriptor(struct xe_vm *vm, struct xe_tile *tile);
 142
 143 int xe_vm_create_ioctl(struct drm_device *dev, void *data,
 144                        struct drm_file *file);
 145 int xe_vm_destroy_ioctl(struct drm_device *dev, void *data,
 146                         struct drm_file *file);
 147 int xe_vm_bind_ioctl(struct drm_device *dev, void *data,
 148                      struct drm_file *file);
 149
 150 void xe_vm_close_and_put(struct xe_vm *vm);
 151
 152 static inline bool xe_vm_in_compute_mode(struct xe_vm *vm)
 153 {
 154         return vm->flags & XE_VM_FLAG_COMPUTE_MODE;
 155 }
 156
 157 static inline bool xe_vm_in_fault_mode(struct xe_vm *vm)
 158 {
 159         return vm->flags & XE_VM_FLAG_FAULT_MODE;
 160 }
 161
 162 static inline bool xe_vm_no_dma_fences(struct xe_vm *vm)
 163 {
 164         return xe_vm_in_compute_mode(vm) || xe_vm_in_fault_mode(vm);
 165 }
 166
 167 int xe_vm_add_compute_exec_queue(struct xe_vm *vm, struct xe_exec_queue *q);
 168
 169 int xe_vm_userptr_pin(struct xe_vm *vm);
 170
 171 int __xe_vm_userptr_needs_repin(struct xe_vm *vm);
 172
 173 int xe_vm_userptr_check_repin(struct xe_vm *vm);
 174
 175 struct dma_fence *xe_vm_rebind(struct xe_vm *vm, bool rebind_worker);
 176
 177 int xe_vm_invalidate_vma(struct xe_vma *vma);
 178
 179 int xe_vm_async_fence_wait_start(struct dma_fence *fence);
 180
 181 extern struct ttm_device_funcs xe_ttm_funcs;
 182
 183 struct ttm_buffer_object *xe_vm_ttm_bo(struct xe_vm *vm);
 184
 185 static inline void xe_vm_queue_rebind_worker(struct xe_vm *vm)
 186 {
 187         XE_WARN_ON(!xe_vm_in_compute_mode(vm));
 188         queue_work(vm->xe->ordered_wq, &vm->preempt.rebind_work);
 189 }
 190
 191 /**
 192  * xe_vm_reactivate_rebind() - Reactivate the rebind functionality on compute
 193  * vms.
 194  * @vm: The vm.
 195  *
 196  * If the rebind functionality on a compute vm was disabled due
 197  * to nothing to execute. Reactivate it and run the rebind worker.
 198  * This function should be called after submitting a batch to a compute vm.
 199  */
 200 static inline void xe_vm_reactivate_rebind(struct xe_vm *vm)
 201 {
 202         if (xe_vm_in_compute_mode(vm) && vm->preempt.rebind_deactivated) {
 203                 vm->preempt.rebind_deactivated = false;
 204                 xe_vm_queue_rebind_worker(vm);
 205         }
 206 }
 207
 208 int xe_vma_userptr_pin_pages(struct xe_vma *vma);
 209
 210 int xe_vma_userptr_check_repin(struct xe_vma *vma);
 211
 212 bool xe_vm_validate_should_retry(struct drm_exec *exec, int err, ktime_t *end);
 213
 214 int xe_vm_lock_dma_resv(struct xe_vm *vm, struct drm_exec *exec,
 215                         unsigned int num_shared, bool lock_vm);
 216
 217 void xe_vm_fence_all_extobjs(struct xe_vm *vm, struct dma_fence *fence,
 218                              enum dma_resv_usage usage);
 219
 220 int xe_analyze_vm(struct drm_printer *p, struct xe_vm *vm, int gt_id);
 221
 222 int xe_vm_prepare_vma(struct drm_exec *exec, struct xe_vma *vma,
 223                       unsigned int num_shared);
 224
 225 /**
 226  * xe_vm_resv() - Return's the vm's reservation object
 227  * @vm: The vm
 228  *
 229  * Return: Pointer to the vm's reservation object.
 230  */
 231 static inline struct dma_resv *xe_vm_resv(struct xe_vm *vm)
 232 {
 233         return drm_gpuvm_resv(&vm->gpuvm);
 234 }
 235
 236 /**
 237  * xe_vm_assert_held(vm) - Assert that the vm's reservation object is held.
 238  * @vm: The vm
 239  */
 240 #define xe_vm_assert_held(vm) dma_resv_assert_held(xe_vm_resv(vm))
 241
 242 #if IS_ENABLED(CONFIG_DRM_XE_DEBUG_VM)
 243 #define vm_dbg drm_dbg
 244 #else
 245 __printf(2, 3)
 246 static inline void vm_dbg(const struct drm_device *dev,
 247                           const char *format, ...)
 248 { /* noop */ }
 249 #endif
 250 #endif