Loading...
Note: File does not exist in v3.5.6.
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
66struct sg_table;
67
68struct xe_bo *xe_bo_alloc(void);
69void xe_bo_free(struct xe_bo *bo);
70
71struct 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);
76struct xe_bo *
77xe_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);
81struct 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);
84struct 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);
87struct 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);
91struct 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);
94struct 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);
97struct 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);
103struct 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);
106struct xe_bo *xe_managed_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile,
107 size_t size, u32 flags);
108struct 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);
110int xe_managed_bo_reinit_in_vram(struct xe_device *xe, struct xe_tile *tile, struct xe_bo **src);
111
112int xe_bo_placement_for_flags(struct xe_device *xe, struct xe_bo *bo,
113 u32 bo_flags);
114
115static 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
120static 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
127static 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
135void xe_bo_put(struct xe_bo *bo);
136
137static 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
143static 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
149int xe_bo_lock(struct xe_bo *bo, bool intr);
150
151void xe_bo_unlock(struct xe_bo *bo);
152
153static 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
164int xe_bo_pin_external(struct xe_bo *bo);
165int xe_bo_pin(struct xe_bo *bo);
166void xe_bo_unpin_external(struct xe_bo *bo);
167void xe_bo_unpin(struct xe_bo *bo);
168int xe_bo_validate(struct xe_bo *bo, struct xe_vm *vm, bool allow_res_evict);
169
170static inline bool xe_bo_is_pinned(struct xe_bo *bo)
171{
172 return bo->ttm.pin_count;
173}
174
175static 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
186bool xe_bo_is_xe_bo(struct ttm_buffer_object *bo);
187dma_addr_t __xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);
188dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);
189
190static inline dma_addr_t
191xe_bo_main_addr(struct xe_bo *bo, size_t page_size)
192{
193 return xe_bo_addr(bo, 0, page_size);
194}
195
196static inline u32
197xe_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
207int xe_bo_vmap(struct xe_bo *bo);
208void xe_bo_vunmap(struct xe_bo *bo);
209
210bool mem_type_is_vram(u32 mem_type);
211bool xe_bo_is_vram(struct xe_bo *bo);
212bool xe_bo_is_stolen(struct xe_bo *bo);
213bool xe_bo_is_stolen_devmem(struct xe_bo *bo);
214bool xe_bo_has_single_placement(struct xe_bo *bo);
215uint64_t vram_region_gpu_offset(struct ttm_resource *res);
216
217bool xe_bo_can_migrate(struct xe_bo *bo, u32 mem_type);
218
219int xe_bo_migrate(struct xe_bo *bo, u32 mem_type);
220int xe_bo_evict(struct xe_bo *bo, bool force_alloc);
221
222int xe_bo_evict_pinned(struct xe_bo *bo);
223int xe_bo_restore_pinned(struct xe_bo *bo);
224
225extern const struct ttm_device_funcs xe_ttm_funcs;
226extern const char *const xe_mem_type_to_name[];
227
228int xe_gem_create_ioctl(struct drm_device *dev, void *data,
229 struct drm_file *file);
230int xe_gem_mmap_offset_ioctl(struct drm_device *dev, void *data,
231 struct drm_file *file);
232void xe_bo_runtime_pm_release_mmap_offset(struct xe_bo *bo);
233
234int xe_bo_dumb_create(struct drm_file *file_priv,
235 struct drm_device *dev,
236 struct drm_mode_create_dumb *args);
237
238bool xe_bo_needs_ccs_pages(struct xe_bo *bo);
239
240static inline size_t xe_bo_ccs_pages_start(struct xe_bo *bo)
241{
242 return PAGE_ALIGN(bo->ttm.base.size);
243}
244
245static 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
254void __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 */
279static inline bool
280xe_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
293void xe_bo_put_commit(struct llist_head *deferred);
294
295struct 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 */
304static 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 */
330static 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