xref: /linux/drivers/gpu/drm/xe/xe_bo.h (revision 7f4f3b14e8079ecde096bd734af10e30d40c27b7) 
1 /* SPDX-License-Identifier: MIT */
2 /*
3  * Copyright © 2021 Intel Corporation
4  */
5 
6 #ifndef _XE_BO_H_
7 #define _XE_BO_H_
8 
9 #include <drm/ttm/ttm_tt.h>
10 
11 #include "xe_bo_types.h"
12 #include "xe_macros.h"
13 #include "xe_vm_types.h"
14 #include "xe_vm.h"
15 
16 #define XE_DEFAULT_GTT_SIZE_MB          3072ULL /* 3GB by default */
17 
18 #define XE_BO_FLAG_USER		BIT(0)
19 /* The bits below need to be contiguous, or things break */
20 #define XE_BO_FLAG_SYSTEM		BIT(1)
21 #define XE_BO_FLAG_VRAM0		BIT(2)
22 #define XE_BO_FLAG_VRAM1		BIT(3)
23 #define XE_BO_FLAG_VRAM_MASK		(XE_BO_FLAG_VRAM0 | XE_BO_FLAG_VRAM1)
24 /* -- */
25 #define XE_BO_FLAG_STOLEN		BIT(4)
26 #define XE_BO_FLAG_VRAM_IF_DGFX(tile)	(IS_DGFX(tile_to_xe(tile)) ? \
27 					 XE_BO_FLAG_VRAM0 << (tile)->id : \
28 					 XE_BO_FLAG_SYSTEM)
29 #define XE_BO_FLAG_GGTT			BIT(5)
30 #define XE_BO_FLAG_IGNORE_MIN_PAGE_SIZE BIT(6)
31 #define XE_BO_FLAG_PINNED		BIT(7)
32 #define XE_BO_FLAG_NO_RESV_EVICT	BIT(8)
33 #define XE_BO_FLAG_DEFER_BACKING	BIT(9)
34 #define XE_BO_FLAG_SCANOUT		BIT(10)
35 #define XE_BO_FLAG_FIXED_PLACEMENT	BIT(11)
36 #define XE_BO_FLAG_PAGETABLE		BIT(12)
37 #define XE_BO_FLAG_NEEDS_CPU_ACCESS	BIT(13)
38 #define XE_BO_FLAG_NEEDS_UC		BIT(14)
39 #define XE_BO_FLAG_NEEDS_64K		BIT(15)
40 #define XE_BO_FLAG_NEEDS_2M		BIT(16)
41 #define XE_BO_FLAG_GGTT_INVALIDATE	BIT(17)
42 /* this one is trigger internally only */
43 #define XE_BO_FLAG_INTERNAL_TEST	BIT(30)
44 #define XE_BO_FLAG_INTERNAL_64K		BIT(31)
45 
46 #define XE_PTE_SHIFT			12
47 #define XE_PAGE_SIZE			(1 << XE_PTE_SHIFT)
48 #define XE_PTE_MASK			(XE_PAGE_SIZE - 1)
49 #define XE_PDE_SHIFT			(XE_PTE_SHIFT - 3)
50 #define XE_PDES				(1 << XE_PDE_SHIFT)
51 #define XE_PDE_MASK			(XE_PDES - 1)
52 
53 #define XE_64K_PTE_SHIFT		16
54 #define XE_64K_PAGE_SIZE		(1 << XE_64K_PTE_SHIFT)
55 #define XE_64K_PTE_MASK			(XE_64K_PAGE_SIZE - 1)
56 #define XE_64K_PDE_MASK			(XE_PDE_MASK >> 4)
57 
58 #define XE_PL_SYSTEM		TTM_PL_SYSTEM
59 #define XE_PL_TT		TTM_PL_TT
60 #define XE_PL_VRAM0		TTM_PL_VRAM
61 #define XE_PL_VRAM1		(XE_PL_VRAM0 + 1)
62 #define XE_PL_STOLEN		(TTM_NUM_MEM_TYPES - 1)
63 
64 #define XE_BO_PROPS_INVALID	(-1)
65 
66 struct sg_table;
67 
68 struct xe_bo *xe_bo_alloc(void);
69 void xe_bo_free(struct xe_bo *bo);
70 
71 struct xe_bo *___xe_bo_create_locked(struct xe_device *xe, struct xe_bo *bo,
72 				     struct xe_tile *tile, struct dma_resv *resv,
73 				     struct ttm_lru_bulk_move *bulk, size_t size,
74 				     u16 cpu_caching, enum ttm_bo_type type,
75 				     u32 flags);
76 struct xe_bo *
77 xe_bo_create_locked_range(struct xe_device *xe,
78 			  struct xe_tile *tile, struct xe_vm *vm,
79 			  size_t size, u64 start, u64 end,
80 			  enum ttm_bo_type type, u32 flags, u64 alignment);
81 struct xe_bo *xe_bo_create_locked(struct xe_device *xe, struct xe_tile *tile,
82 				  struct xe_vm *vm, size_t size,
83 				  enum ttm_bo_type type, u32 flags);
84 struct xe_bo *xe_bo_create(struct xe_device *xe, struct xe_tile *tile,
85 			   struct xe_vm *vm, size_t size,
86 			   enum ttm_bo_type type, u32 flags);
87 struct xe_bo *xe_bo_create_user(struct xe_device *xe, struct xe_tile *tile,
88 				struct xe_vm *vm, size_t size,
89 				u16 cpu_caching,
90 				u32 flags);
91 struct xe_bo *xe_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile,
92 				   struct xe_vm *vm, size_t size,
93 				   enum ttm_bo_type type, u32 flags);
94 struct xe_bo *xe_bo_create_pin_map_at(struct xe_device *xe, struct xe_tile *tile,
95 				      struct xe_vm *vm, size_t size, u64 offset,
96 				      enum ttm_bo_type type, u32 flags);
97 struct xe_bo *xe_bo_create_pin_map_at_aligned(struct xe_device *xe,
98 					      struct xe_tile *tile,
99 					      struct xe_vm *vm,
100 					      size_t size, u64 offset,
101 					      enum ttm_bo_type type, u32 flags,
102 					      u64 alignment);
103 struct xe_bo *xe_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
104 				     const void *data, size_t size,
105 				     enum ttm_bo_type type, u32 flags);
106 struct xe_bo *xe_managed_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile,
107 					   size_t size, u32 flags);
108 struct xe_bo *xe_managed_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
109 					     const void *data, size_t size, u32 flags);
110 int xe_managed_bo_reinit_in_vram(struct xe_device *xe, struct xe_tile *tile, struct xe_bo **src);
111 
112 int xe_bo_placement_for_flags(struct xe_device *xe, struct xe_bo *bo,
113 			      u32 bo_flags);
114 
115 static inline struct xe_bo *ttm_to_xe_bo(const struct ttm_buffer_object *bo)
116 {
117 	return container_of(bo, struct xe_bo, ttm);
118 }
119 
120 static inline struct xe_bo *gem_to_xe_bo(const struct drm_gem_object *obj)
121 {
122 	return container_of(obj, struct xe_bo, ttm.base);
123 }
124 
125 #define xe_bo_device(bo) ttm_to_xe_device((bo)->ttm.bdev)
126 
127 static inline struct xe_bo *xe_bo_get(struct xe_bo *bo)
128 {
129 	if (bo)
130 		drm_gem_object_get(&bo->ttm.base);
131 
132 	return bo;
133 }
134 
135 void xe_bo_put(struct xe_bo *bo);
136 
137 static inline void __xe_bo_unset_bulk_move(struct xe_bo *bo)
138 {
139 	if (bo)
140 		ttm_bo_set_bulk_move(&bo->ttm, NULL);
141 }
142 
143 static inline void xe_bo_assert_held(struct xe_bo *bo)
144 {
145 	if (bo)
146 		dma_resv_assert_held((bo)->ttm.base.resv);
147 }
148 
149 int xe_bo_lock(struct xe_bo *bo, bool intr);
150 
151 void xe_bo_unlock(struct xe_bo *bo);
152 
153 static inline void xe_bo_unlock_vm_held(struct xe_bo *bo)
154 {
155 	if (bo) {
156 		XE_WARN_ON(bo->vm && bo->ttm.base.resv != xe_vm_resv(bo->vm));
157 		if (bo->vm)
158 			xe_vm_assert_held(bo->vm);
159 		else
160 			dma_resv_unlock(bo->ttm.base.resv);
161 	}
162 }
163 
164 int xe_bo_pin_external(struct xe_bo *bo);
165 int xe_bo_pin(struct xe_bo *bo);
166 void xe_bo_unpin_external(struct xe_bo *bo);
167 void xe_bo_unpin(struct xe_bo *bo);
168 int xe_bo_validate(struct xe_bo *bo, struct xe_vm *vm, bool allow_res_evict);
169 
170 static inline bool xe_bo_is_pinned(struct xe_bo *bo)
171 {
172 	return bo->ttm.pin_count;
173 }
174 
175 static inline void xe_bo_unpin_map_no_vm(struct xe_bo *bo)
176 {
177 	if (likely(bo)) {
178 		xe_bo_lock(bo, false);
179 		xe_bo_unpin(bo);
180 		xe_bo_unlock(bo);
181 
182 		xe_bo_put(bo);
183 	}
184 }
185 
186 bool xe_bo_is_xe_bo(struct ttm_buffer_object *bo);
187 dma_addr_t __xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);
188 dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);
189 
190 static inline dma_addr_t
191 xe_bo_main_addr(struct xe_bo *bo, size_t page_size)
192 {
193 	return xe_bo_addr(bo, 0, page_size);
194 }
195 
196 static inline u32
197 xe_bo_ggtt_addr(struct xe_bo *bo)
198 {
199 	if (XE_WARN_ON(!bo->ggtt_node))
200 		return 0;
201 
202 	XE_WARN_ON(bo->ggtt_node->base.size > bo->size);
203 	XE_WARN_ON(bo->ggtt_node->base.start + bo->ggtt_node->base.size > (1ull << 32));
204 	return bo->ggtt_node->base.start;
205 }
206 
207 int xe_bo_vmap(struct xe_bo *bo);
208 void xe_bo_vunmap(struct xe_bo *bo);
209 
210 bool mem_type_is_vram(u32 mem_type);
211 bool xe_bo_is_vram(struct xe_bo *bo);
212 bool xe_bo_is_stolen(struct xe_bo *bo);
213 bool xe_bo_is_stolen_devmem(struct xe_bo *bo);
214 bool xe_bo_has_single_placement(struct xe_bo *bo);
215 uint64_t vram_region_gpu_offset(struct ttm_resource *res);
216 
217 bool xe_bo_can_migrate(struct xe_bo *bo, u32 mem_type);
218 
219 int xe_bo_migrate(struct xe_bo *bo, u32 mem_type);
220 int xe_bo_evict(struct xe_bo *bo, bool force_alloc);
221 
222 int xe_bo_evict_pinned(struct xe_bo *bo);
223 int xe_bo_restore_pinned(struct xe_bo *bo);
224 
225 extern const struct ttm_device_funcs xe_ttm_funcs;
226 extern const char *const xe_mem_type_to_name[];
227 
228 int xe_gem_create_ioctl(struct drm_device *dev, void *data,
229 			struct drm_file *file);
230 int xe_gem_mmap_offset_ioctl(struct drm_device *dev, void *data,
231 			     struct drm_file *file);
232 void xe_bo_runtime_pm_release_mmap_offset(struct xe_bo *bo);
233 
234 int xe_bo_dumb_create(struct drm_file *file_priv,
235 		      struct drm_device *dev,
236 		      struct drm_mode_create_dumb *args);
237 
238 bool xe_bo_needs_ccs_pages(struct xe_bo *bo);
239 
240 static inline size_t xe_bo_ccs_pages_start(struct xe_bo *bo)
241 {
242 	return PAGE_ALIGN(bo->ttm.base.size);
243 }
244 
245 static inline bool xe_bo_has_pages(struct xe_bo *bo)
246 {
247 	if ((bo->ttm.ttm && ttm_tt_is_populated(bo->ttm.ttm)) ||
248 	    xe_bo_is_vram(bo))
249 		return true;
250 
251 	return false;
252 }
253 
254 void __xe_bo_release_dummy(struct kref *kref);
255 
256 /**
257  * xe_bo_put_deferred() - Put a buffer object with delayed final freeing
258  * @bo: The bo to put.
259  * @deferred: List to which to add the buffer object if we cannot put, or
260  * NULL if the function is to put unconditionally.
261  *
262  * Since the final freeing of an object includes both sleeping and (!)
263  * memory allocation in the dma_resv individualization, it's not ok
264  * to put an object from atomic context nor from within a held lock
265  * tainted by reclaim. In such situations we want to defer the final
266  * freeing until we've exited the restricting context, or in the worst
267  * case to a workqueue.
268  * This function either puts the object if possible without the refcount
269  * reaching zero, or adds it to the @deferred list if that was not possible.
270  * The caller needs to follow up with a call to xe_bo_put_commit() to actually
271  * put the bo iff this function returns true. It's safe to always
272  * follow up with a call to xe_bo_put_commit().
273  * TODO: It's TTM that is the villain here. Perhaps TTM should add an
274  * interface like this.
275  *
276  * Return: true if @bo was the first object put on the @freed list,
277  * false otherwise.
278  */
279 static inline bool
280 xe_bo_put_deferred(struct xe_bo *bo, struct llist_head *deferred)
281 {
282 	if (!deferred) {
283 		xe_bo_put(bo);
284 		return false;
285 	}
286 
287 	if (!kref_put(&bo->ttm.base.refcount, __xe_bo_release_dummy))
288 		return false;
289 
290 	return llist_add(&bo->freed, deferred);
291 }
292 
293 void xe_bo_put_commit(struct llist_head *deferred);
294 
295 struct sg_table *xe_bo_sg(struct xe_bo *bo);
296 
297 /*
298  * xe_sg_segment_size() - Provides upper limit for sg segment size.
299  * @dev: device pointer
300  *
301  * Returns the maximum segment size for the 'struct scatterlist'
302  * elements.
303  */
304 static inline unsigned int xe_sg_segment_size(struct device *dev)
305 {
306 	struct scatterlist __maybe_unused sg;
307 	size_t max = BIT_ULL(sizeof(sg.length) * 8) - 1;
308 
309 	max = min_t(size_t, max, dma_max_mapping_size(dev));
310 
311 	/*
312 	 * The iommu_dma_map_sg() function ensures iova allocation doesn't
313 	 * cross dma segment boundary. It does so by padding some sg elements.
314 	 * This can cause overflow, ending up with sg->length being set to 0.
315 	 * Avoid this by ensuring maximum segment size is half of 'max'
316 	 * rounded down to PAGE_SIZE.
317 	 */
318 	return round_down(max / 2, PAGE_SIZE);
319 }
320 
321 #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
322 /**
323  * xe_bo_is_mem_type - Whether the bo currently resides in the given
324  * TTM memory type
325  * @bo: The bo to check.
326  * @mem_type: The TTM memory type.
327  *
328  * Return: true iff the bo resides in @mem_type, false otherwise.
329  */
330 static inline bool xe_bo_is_mem_type(struct xe_bo *bo, u32 mem_type)
331 {
332 	xe_bo_assert_held(bo);
333 	return bo->ttm.resource->mem_type == mem_type;
334 }
335 #endif
336 #endif
337