]>
Commit | Line | Data |
---|---|---|
ba4e7d97 TH |
1 | /************************************************************************** |
2 | * | |
3 | * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA | |
4 | * All Rights Reserved. | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a | |
7 | * copy of this software and associated documentation files (the | |
8 | * "Software"), to deal in the Software without restriction, including | |
9 | * without limitation the rights to use, copy, modify, merge, publish, | |
10 | * distribute, sub license, and/or sell copies of the Software, and to | |
11 | * permit persons to whom the Software is furnished to do so, subject to | |
12 | * the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice (including the | |
15 | * next paragraph) shall be included in all copies or substantial portions | |
16 | * of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, | |
22 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
23 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
24 | * USE OR OTHER DEALINGS IN THE SOFTWARE. | |
25 | * | |
26 | **************************************************************************/ | |
27 | /* | |
28 | * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> | |
29 | */ | |
30 | ||
31 | #ifndef _TTM_BO_API_H_ | |
32 | #define _TTM_BO_API_H_ | |
33 | ||
8eb8833e | 34 | #include <drm/drm_gem.h> |
a1ce3928 | 35 | #include <drm/drm_hashtab.h> |
72525b3f | 36 | #include <drm/drm_vma_manager.h> |
ba4e7d97 TH |
37 | #include <linux/kref.h> |
38 | #include <linux/list.h> | |
39 | #include <linux/wait.h> | |
40 | #include <linux/mutex.h> | |
41 | #include <linux/mm.h> | |
ba4e7d97 | 42 | #include <linux/bitmap.h> |
52791eee | 43 | #include <linux/dma-resv.h> |
ba4e7d97 | 44 | |
38392633 CK |
45 | struct ttm_bo_global; |
46 | ||
ba4e7d97 TH |
47 | struct ttm_bo_device; |
48 | ||
49 | struct drm_mm_node; | |
50 | ||
7c732ea6 | 51 | struct ttm_placement; |
ca262a99 | 52 | |
a2ab19fe CK |
53 | struct ttm_place; |
54 | ||
9a277952 CK |
55 | struct ttm_lru_bulk_move; |
56 | ||
82c5da6b JG |
57 | /** |
58 | * struct ttm_bus_placement | |
59 | * | |
60 | * @addr: mapped virtual address | |
61 | * @base: bus base address | |
62 | * @is_iomem: is this io memory ? | |
63 | * @size: size in byte | |
64 | * @offset: offset from the base address | |
eba67093 TH |
65 | * @io_reserved_vm: The VM system has a refcount in @io_reserved_count |
66 | * @io_reserved_count: Refcounting the numbers of callers to ttm_mem_io_reserve | |
82c5da6b JG |
67 | * |
68 | * Structure indicating the bus placement of an object. | |
69 | */ | |
70 | struct ttm_bus_placement { | |
71 | void *addr; | |
749b48fa | 72 | phys_addr_t base; |
82c5da6b JG |
73 | unsigned long size; |
74 | unsigned long offset; | |
75 | bool is_iomem; | |
eba67093 TH |
76 | bool io_reserved_vm; |
77 | uint64_t io_reserved_count; | |
82c5da6b JG |
78 | }; |
79 | ||
ca262a99 | 80 | |
ba4e7d97 TH |
81 | /** |
82 | * struct ttm_mem_reg | |
83 | * | |
84 | * @mm_node: Memory manager node. | |
85 | * @size: Requested size of memory region. | |
86 | * @num_pages: Actual size of memory region in pages. | |
87 | * @page_alignment: Page alignment. | |
88 | * @placement: Placement flags. | |
82c5da6b | 89 | * @bus: Placement on io bus accessible to the CPU |
ba4e7d97 TH |
90 | * |
91 | * Structure indicating the placement and space resources used by a | |
92 | * buffer object. | |
93 | */ | |
94 | ||
95 | struct ttm_mem_reg { | |
d961db75 BS |
96 | void *mm_node; |
97 | unsigned long start; | |
ba4e7d97 TH |
98 | unsigned long size; |
99 | unsigned long num_pages; | |
100 | uint32_t page_alignment; | |
101 | uint32_t mem_type; | |
102 | uint32_t placement; | |
82c5da6b | 103 | struct ttm_bus_placement bus; |
ba4e7d97 TH |
104 | }; |
105 | ||
106 | /** | |
107 | * enum ttm_bo_type | |
108 | * | |
109 | * @ttm_bo_type_device: These are 'normal' buffers that can | |
110 | * be mmapped by user space. Each of these bos occupy a slot in the | |
111 | * device address space, that can be used for normal vm operations. | |
112 | * | |
ba4e7d97 TH |
113 | * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers, |
114 | * but they cannot be accessed from user-space. For kernel-only use. | |
129b78bf DA |
115 | * |
116 | * @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another | |
117 | * driver. | |
ba4e7d97 TH |
118 | */ |
119 | ||
120 | enum ttm_bo_type { | |
121 | ttm_bo_type_device, | |
129b78bf DA |
122 | ttm_bo_type_kernel, |
123 | ttm_bo_type_sg | |
ba4e7d97 TH |
124 | }; |
125 | ||
126 | struct ttm_tt; | |
127 | ||
128 | /** | |
129 | * struct ttm_buffer_object | |
130 | * | |
8eb8833e | 131 | * @base: drm_gem_object superclass data. |
ba4e7d97 | 132 | * @bdev: Pointer to the buffer object device structure. |
ba4e7d97 TH |
133 | * @type: The bo type. |
134 | * @destroy: Destruction function. If NULL, kfree is used. | |
135 | * @num_pages: Actual number of pages. | |
ba4e7d97 TH |
136 | * @acc_size: Accounted size for this object. |
137 | * @kref: Reference count of this buffer object. When this refcount reaches | |
138 | * zero, the object is put on the delayed delete list. | |
139 | * @list_kref: List reference count of this buffer object. This member is | |
140 | * used to avoid destruction while the buffer object is still on a list. | |
141 | * Lru lists may keep one refcount, the delayed delete list, and kref != 0 | |
142 | * keeps one refcount. When this refcount reaches zero, | |
143 | * the object is destroyed. | |
ba4e7d97 | 144 | * @mem: structure describing current placement. |
5df23979 | 145 | * @persistent_swap_storage: Usually the swap storage is deleted for buffers |
ba4e7d97 | 146 | * pinned in physical memory. If this behaviour is not desired, this member |
5df23979 | 147 | * holds a pointer to a persistent shmem object. |
ba4e7d97 TH |
148 | * @ttm: TTM structure holding system pages. |
149 | * @evicted: Whether the object was evicted without user-space knowing. | |
150 | * @cpu_writes: For synchronization. Number of cpu writers. | |
151 | * @lru: List head for the lru list. | |
152 | * @ddestroy: List head for the delayed destroy list. | |
153 | * @swap: List head for swap LRU list. | |
5bc73067 | 154 | * @moving: Fence set when BO is moving |
ba4e7d97 TH |
155 | * @offset: The current GPU offset, which can have different meanings |
156 | * depending on the memory type. For SYSTEM type memory, it should be 0. | |
157 | * @cur_placement: Hint of current placement. | |
c58f009e | 158 | * @wu_mutex: Wait unreserved mutex. |
ba4e7d97 TH |
159 | * |
160 | * Base class for TTM buffer object, that deals with data placement and CPU | |
161 | * mappings. GPU mappings are really up to the driver, but for simpler GPUs | |
162 | * the driver can usually use the placement offset @offset directly as the | |
163 | * GPU virtual address. For drivers implementing multiple | |
164 | * GPU memory manager contexts, the driver should manage the address space | |
165 | * in these contexts separately and use these objects to get the correct | |
166 | * placement and caching for these GPU maps. This makes it possible to use | |
167 | * these objects for even quite elaborate memory management schemes. | |
168 | * The destroy member, the API visibility of this object makes it possible | |
169 | * to derive driver specific types. | |
170 | */ | |
171 | ||
172 | struct ttm_buffer_object { | |
8eb8833e GH |
173 | struct drm_gem_object base; |
174 | ||
ba4e7d97 TH |
175 | /** |
176 | * Members constant at init. | |
177 | */ | |
178 | ||
179 | struct ttm_bo_device *bdev; | |
ba4e7d97 TH |
180 | enum ttm_bo_type type; |
181 | void (*destroy) (struct ttm_buffer_object *); | |
182 | unsigned long num_pages; | |
ba4e7d97 TH |
183 | size_t acc_size; |
184 | ||
185 | /** | |
186 | * Members not needing protection. | |
187 | */ | |
188 | ||
189 | struct kref kref; | |
190 | struct kref list_kref; | |
ba4e7d97 TH |
191 | |
192 | /** | |
5e338405 | 193 | * Members protected by the bo::resv::reserved lock. |
ba4e7d97 TH |
194 | */ |
195 | ||
ba4e7d97 | 196 | struct ttm_mem_reg mem; |
5df23979 | 197 | struct file *persistent_swap_storage; |
ba4e7d97 TH |
198 | struct ttm_tt *ttm; |
199 | bool evicted; | |
200 | ||
201 | /** | |
202 | * Members protected by the bo::reserved lock only when written to. | |
203 | */ | |
204 | ||
205 | atomic_t cpu_writers; | |
206 | ||
207 | /** | |
208 | * Members protected by the bdev::lru_lock. | |
209 | */ | |
210 | ||
211 | struct list_head lru; | |
212 | struct list_head ddestroy; | |
213 | struct list_head swap; | |
eba67093 | 214 | struct list_head io_reserve_lru; |
ba4e7d97 | 215 | |
ba4e7d97 | 216 | /** |
dd7cfd64 | 217 | * Members protected by a bo reservation. |
ba4e7d97 TH |
218 | */ |
219 | ||
f54d1867 | 220 | struct dma_fence *moving; |
cf6c467d CK |
221 | unsigned priority; |
222 | ||
ba4e7d97 TH |
223 | /** |
224 | * Special members that are protected by the reserve lock | |
225 | * and the bo::lock when written to. Can be read with | |
226 | * either of these locks held. | |
227 | */ | |
228 | ||
54c4cd68 | 229 | uint64_t offset; /* GPU address space is independent of CPU word size */ |
129b78bf DA |
230 | |
231 | struct sg_table *sg; | |
5e338405 | 232 | |
c58f009e | 233 | struct mutex wu_mutex; |
ba4e7d97 TH |
234 | }; |
235 | ||
236 | /** | |
237 | * struct ttm_bo_kmap_obj | |
238 | * | |
239 | * @virtual: The current kernel virtual address. | |
240 | * @page: The page when kmap'ing a single page. | |
241 | * @bo_kmap_type: Type of bo_kmap. | |
242 | * | |
243 | * Object describing a kernel mapping. Since a TTM bo may be located | |
244 | * in various memory types with various caching policies, the | |
245 | * mapping can either be an ioremap, a vmap, a kmap or part of a | |
246 | * premapped region. | |
247 | */ | |
248 | ||
a0724fcf | 249 | #define TTM_BO_MAP_IOMEM_MASK 0x80 |
ba4e7d97 TH |
250 | struct ttm_bo_kmap_obj { |
251 | void *virtual; | |
252 | struct page *page; | |
253 | enum { | |
a0724fcf PP |
254 | ttm_bo_map_iomap = 1 | TTM_BO_MAP_IOMEM_MASK, |
255 | ttm_bo_map_vmap = 2, | |
256 | ttm_bo_map_kmap = 3, | |
257 | ttm_bo_map_premapped = 4 | TTM_BO_MAP_IOMEM_MASK, | |
ba4e7d97 | 258 | } bo_kmap_type; |
82c5da6b | 259 | struct ttm_buffer_object *bo; |
ba4e7d97 TH |
260 | }; |
261 | ||
19be5570 CK |
262 | /** |
263 | * struct ttm_operation_ctx | |
264 | * | |
265 | * @interruptible: Sleep interruptible if sleeping. | |
266 | * @no_wait_gpu: Return immediately if the GPU is busy. | |
8836e4b8 | 267 | * @resv: Reservation object to allow reserved evictions with. |
d330fca1 | 268 | * @flags: Including the following flags |
19be5570 CK |
269 | * |
270 | * Context for TTM operations like changing buffer placement or general memory | |
271 | * allocation. | |
272 | */ | |
273 | struct ttm_operation_ctx { | |
274 | bool interruptible; | |
275 | bool no_wait_gpu; | |
52791eee | 276 | struct dma_resv *resv; |
6cd2e71e | 277 | uint64_t bytes_moved; |
d330fca1 | 278 | uint32_t flags; |
19be5570 CK |
279 | }; |
280 | ||
d330fca1 | 281 | /* Allow eviction of reserved BOs */ |
aa7662b6 RH |
282 | #define TTM_OPT_FLAG_ALLOW_RES_EVICT 0x1 |
283 | /* when serving page fault or suspend, allow alloc anyway */ | |
284 | #define TTM_OPT_FLAG_FORCE_ALLOC 0x2 | |
d330fca1 | 285 | |
89c815ef TZ |
286 | /** |
287 | * ttm_bo_get - reference a struct ttm_buffer_object | |
288 | * | |
289 | * @bo: The buffer object. | |
290 | */ | |
291 | static inline void ttm_bo_get(struct ttm_buffer_object *bo) | |
292 | { | |
293 | kref_get(&bo->kref); | |
294 | } | |
295 | ||
24dc64c1 TH |
296 | /** |
297 | * ttm_bo_get_unless_zero - reference a struct ttm_buffer_object unless | |
298 | * its refcount has already reached zero. | |
299 | * @bo: The buffer object. | |
300 | * | |
301 | * Used to reference a TTM buffer object in lookups where the object is removed | |
302 | * from the lookup structure during the destructor and for RCU lookups. | |
303 | * | |
304 | * Returns: @bo if the referencing was successful, NULL otherwise. | |
305 | */ | |
306 | static inline __must_check struct ttm_buffer_object * | |
307 | ttm_bo_get_unless_zero(struct ttm_buffer_object *bo) | |
308 | { | |
309 | if (!kref_get_unless_zero(&bo->kref)) | |
310 | return NULL; | |
311 | return bo; | |
312 | } | |
313 | ||
ba4e7d97 TH |
314 | /** |
315 | * ttm_bo_wait - wait for buffer idle. | |
316 | * | |
317 | * @bo: The buffer object. | |
318 | * @interruptible: Use interruptible wait. | |
319 | * @no_wait: Return immediately if buffer is busy. | |
320 | * | |
321 | * This function must be called with the bo::mutex held, and makes | |
322 | * sure any previous rendering to the buffer is completed. | |
323 | * Note: It might be necessary to block validations before the | |
324 | * wait by reserving the buffer. | |
325 | * Returns -EBUSY if no_wait is true and the buffer is busy. | |
98ffc415 | 326 | * Returns -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 | 327 | */ |
ba87349e | 328 | int ttm_bo_wait(struct ttm_buffer_object *bo, bool interruptible, bool no_wait); |
94477bff SY |
329 | |
330 | /** | |
331 | * ttm_bo_mem_compat - Check if proposed placement is compatible with a bo | |
332 | * | |
333 | * @placement: Return immediately if buffer is busy. | |
334 | * @mem: The struct ttm_mem_reg indicating the region where the bo resides | |
335 | * @new_flags: Describes compatible placement found | |
336 | * | |
337 | * Returns true if the placement is compatible | |
338 | */ | |
ba87349e CK |
339 | bool ttm_bo_mem_compat(struct ttm_placement *placement, struct ttm_mem_reg *mem, |
340 | uint32_t *new_flags); | |
94477bff | 341 | |
ba4e7d97 | 342 | /** |
09855acb | 343 | * ttm_bo_validate |
ba4e7d97 TH |
344 | * |
345 | * @bo: The buffer object. | |
ca262a99 | 346 | * @placement: Proposed placement for the buffer object. |
19be5570 | 347 | * @ctx: validation parameters. |
ba4e7d97 TH |
348 | * |
349 | * Changes placement and caching policy of the buffer object | |
ca262a99 | 350 | * according proposed placement. |
ba4e7d97 | 351 | * Returns |
ca262a99 | 352 | * -EINVAL on invalid proposed placement. |
ba4e7d97 TH |
353 | * -ENOMEM on out-of-memory condition. |
354 | * -EBUSY if no_wait is true and buffer busy. | |
98ffc415 | 355 | * -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 | 356 | */ |
ba87349e CK |
357 | int ttm_bo_validate(struct ttm_buffer_object *bo, |
358 | struct ttm_placement *placement, | |
19be5570 | 359 | struct ttm_operation_ctx *ctx); |
ca262a99 | 360 | |
89c815ef TZ |
361 | /** |
362 | * ttm_bo_put | |
363 | * | |
364 | * @bo: The buffer object. | |
365 | * | |
366 | * Unreference a buffer object. | |
367 | */ | |
368 | void ttm_bo_put(struct ttm_buffer_object *bo); | |
369 | ||
d6ea8886 DA |
370 | /** |
371 | * ttm_bo_add_to_lru | |
372 | * | |
373 | * @bo: The buffer object. | |
374 | * | |
375 | * Add this bo to the relevant mem type lru and, if it's backed by | |
376 | * system pages (ttms) to the swap list. | |
377 | * This function must be called with struct ttm_bo_global::lru_lock held, and | |
378 | * is typically called immediately prior to unreserving a bo. | |
379 | */ | |
ba87349e | 380 | void ttm_bo_add_to_lru(struct ttm_buffer_object *bo); |
d6ea8886 DA |
381 | |
382 | /** | |
383 | * ttm_bo_del_from_lru | |
384 | * | |
385 | * @bo: The buffer object. | |
386 | * | |
387 | * Remove this bo from all lru lists used to lookup and reserve an object. | |
388 | * This function must be called with struct ttm_bo_global::lru_lock held, | |
389 | * and is usually called just immediately after the bo has been reserved to | |
390 | * avoid recursive reservation from lru lists. | |
391 | */ | |
ba87349e | 392 | void ttm_bo_del_from_lru(struct ttm_buffer_object *bo); |
d6ea8886 | 393 | |
ab749618 CK |
394 | /** |
395 | * ttm_bo_move_to_lru_tail | |
396 | * | |
397 | * @bo: The buffer object. | |
9a277952 | 398 | * @bulk: optional bulk move structure to remember BO positions |
ab749618 CK |
399 | * |
400 | * Move this BO to the tail of all lru lists used to lookup and reserve an | |
401 | * object. This function must be called with struct ttm_bo_global::lru_lock | |
402 | * held, and is used to make a BO less likely to be considered for eviction. | |
403 | */ | |
9a277952 CK |
404 | void ttm_bo_move_to_lru_tail(struct ttm_buffer_object *bo, |
405 | struct ttm_lru_bulk_move *bulk); | |
d6ea8886 | 406 | |
7748e2dc HR |
407 | /** |
408 | * ttm_bo_bulk_move_lru_tail | |
409 | * | |
410 | * @bulk: bulk move structure | |
411 | * | |
412 | * Bulk move BOs to the LRU tail, only valid to use when driver makes sure that | |
413 | * BO order never changes. Should be called with ttm_bo_global::lru_lock held. | |
414 | */ | |
415 | void ttm_bo_bulk_move_lru_tail(struct ttm_lru_bulk_move *bulk); | |
416 | ||
7c5ee536 MG |
417 | /** |
418 | * ttm_bo_lock_delayed_workqueue | |
419 | * | |
420 | * Prevent the delayed workqueue from running. | |
421 | * Returns | |
422 | * True if the workqueue was queued at the time | |
423 | */ | |
ba87349e | 424 | int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev); |
7c5ee536 MG |
425 | |
426 | /** | |
427 | * ttm_bo_unlock_delayed_workqueue | |
428 | * | |
429 | * Allows the delayed workqueue to run. | |
430 | */ | |
ba87349e | 431 | void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev, int resched); |
7c5ee536 | 432 | |
a2ab19fe CK |
433 | /** |
434 | * ttm_bo_eviction_valuable | |
435 | * | |
436 | * @bo: The buffer object to evict | |
437 | * @place: the placement we need to make room for | |
438 | * | |
439 | * Check if it is valuable to evict the BO to make room for the given placement. | |
440 | */ | |
441 | bool ttm_bo_eviction_valuable(struct ttm_buffer_object *bo, | |
442 | const struct ttm_place *place); | |
443 | ||
ba4e7d97 TH |
444 | /** |
445 | * ttm_bo_synccpu_write_grab | |
446 | * | |
447 | * @bo: The buffer object: | |
448 | * @no_wait: Return immediately if buffer is busy. | |
449 | * | |
450 | * Synchronizes a buffer object for CPU RW access. This means | |
654aa792 ML |
451 | * command submission that affects the buffer will return -EBUSY |
452 | * until ttm_bo_synccpu_write_release is called. | |
453 | * | |
ba4e7d97 TH |
454 | * Returns |
455 | * -EBUSY if the buffer is busy and no_wait is true. | |
98ffc415 | 456 | * -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 | 457 | */ |
ba87349e | 458 | int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait); |
57de4ba9 | 459 | |
ba4e7d97 TH |
460 | /** |
461 | * ttm_bo_synccpu_write_release: | |
462 | * | |
463 | * @bo : The buffer object. | |
464 | * | |
465 | * Releases a synccpu lock. | |
466 | */ | |
ba87349e | 467 | void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo); |
ba4e7d97 | 468 | |
57de4ba9 JG |
469 | /** |
470 | * ttm_bo_acc_size | |
471 | * | |
472 | * @bdev: Pointer to a ttm_bo_device struct. | |
473 | * @bo_size: size of the buffer object in byte. | |
474 | * @struct_size: size of the structure holding buffer object datas | |
475 | * | |
476 | * Returns size to account for a buffer object | |
477 | */ | |
478 | size_t ttm_bo_acc_size(struct ttm_bo_device *bdev, | |
479 | unsigned long bo_size, | |
480 | unsigned struct_size); | |
481 | size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev, | |
482 | unsigned long bo_size, | |
483 | unsigned struct_size); | |
484 | ||
ca9cf68d NH |
485 | /** |
486 | * ttm_bo_init_reserved | |
487 | * | |
488 | * @bdev: Pointer to a ttm_bo_device struct. | |
489 | * @bo: Pointer to a ttm_buffer_object to be initialized. | |
490 | * @size: Requested size of buffer object. | |
491 | * @type: Requested type of buffer object. | |
492 | * @flags: Initial placement flags. | |
493 | * @page_alignment: Data alignment in pages. | |
6fead44a | 494 | * @ctx: TTM operation context for memory allocation. |
ca9cf68d | 495 | * @acc_size: Accounted size for this object. |
52791eee | 496 | * @resv: Pointer to a dma_resv, or NULL to let ttm allocate one. |
ca9cf68d NH |
497 | * @destroy: Destroy function. Use NULL for kfree(). |
498 | * | |
499 | * This function initializes a pre-allocated struct ttm_buffer_object. | |
500 | * As this object may be part of a larger structure, this function, | |
501 | * together with the @destroy function, | |
502 | * enables driver-specific objects derived from a ttm_buffer_object. | |
503 | * | |
504 | * On successful return, the caller owns an object kref to @bo. The kref and | |
505 | * list_kref are usually set to 1, but note that in some situations, other | |
506 | * tasks may already be holding references to @bo as well. | |
507 | * Furthermore, if resv == NULL, the buffer's reservation lock will be held, | |
508 | * and it is the caller's responsibility to call ttm_bo_unreserve. | |
509 | * | |
510 | * If a failure occurs, the function will call the @destroy function, or | |
511 | * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is | |
512 | * illegal and will likely cause memory corruption. | |
513 | * | |
514 | * Returns | |
515 | * -ENOMEM: Out of memory. | |
516 | * -EINVAL: Invalid placement flags. | |
517 | * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources. | |
518 | */ | |
519 | ||
ba87349e CK |
520 | int ttm_bo_init_reserved(struct ttm_bo_device *bdev, |
521 | struct ttm_buffer_object *bo, | |
522 | unsigned long size, | |
523 | enum ttm_bo_type type, | |
524 | struct ttm_placement *placement, | |
525 | uint32_t page_alignment, | |
6fead44a | 526 | struct ttm_operation_ctx *ctx, |
ba87349e CK |
527 | size_t acc_size, |
528 | struct sg_table *sg, | |
52791eee | 529 | struct dma_resv *resv, |
ba87349e | 530 | void (*destroy) (struct ttm_buffer_object *)); |
ca9cf68d | 531 | |
ba4e7d97 | 532 | /** |
09855acb | 533 | * ttm_bo_init |
ba4e7d97 TH |
534 | * |
535 | * @bdev: Pointer to a ttm_bo_device struct. | |
536 | * @bo: Pointer to a ttm_buffer_object to be initialized. | |
537 | * @size: Requested size of buffer object. | |
538 | * @type: Requested type of buffer object. | |
539 | * @flags: Initial placement flags. | |
540 | * @page_alignment: Data alignment in pages. | |
ba4e7d97 TH |
541 | * @interruptible: If needing to sleep to wait for GPU resources, |
542 | * sleep interruptible. | |
ba4e7d97 | 543 | * pinned in physical memory. If this behaviour is not desired, this member |
5df23979 | 544 | * holds a pointer to a persistent shmem object. Typically, this would |
ba4e7d97 TH |
545 | * point to the shmem object backing a GEM object if TTM is used to back a |
546 | * GEM user interface. | |
547 | * @acc_size: Accounted size for this object. | |
52791eee | 548 | * @resv: Pointer to a dma_resv, or NULL to let ttm allocate one. |
ba4e7d97 TH |
549 | * @destroy: Destroy function. Use NULL for kfree(). |
550 | * | |
551 | * This function initializes a pre-allocated struct ttm_buffer_object. | |
552 | * As this object may be part of a larger structure, this function, | |
553 | * together with the @destroy function, | |
554 | * enables driver-specific objects derived from a ttm_buffer_object. | |
882e8cfc NH |
555 | * |
556 | * On successful return, the caller owns an object kref to @bo. The kref and | |
557 | * list_kref are usually set to 1, but note that in some situations, other | |
558 | * tasks may already be holding references to @bo as well. | |
559 | * | |
7dfbbdcf TH |
560 | * If a failure occurs, the function will call the @destroy function, or |
561 | * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is | |
562 | * illegal and will likely cause memory corruption. | |
563 | * | |
ba4e7d97 TH |
564 | * Returns |
565 | * -ENOMEM: Out of memory. | |
566 | * -EINVAL: Invalid placement flags. | |
98ffc415 | 567 | * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources. |
ba4e7d97 | 568 | */ |
ba87349e CK |
569 | int ttm_bo_init(struct ttm_bo_device *bdev, struct ttm_buffer_object *bo, |
570 | unsigned long size, enum ttm_bo_type type, | |
571 | struct ttm_placement *placement, | |
724daa4f | 572 | uint32_t page_alignment, bool interrubtible, size_t acc_size, |
52791eee | 573 | struct sg_table *sg, struct dma_resv *resv, |
ba87349e | 574 | void (*destroy) (struct ttm_buffer_object *)); |
57de4ba9 | 575 | |
ba4e7d97 | 576 | /** |
59201052 | 577 | * ttm_bo_create |
ba4e7d97 TH |
578 | * |
579 | * @bdev: Pointer to a ttm_bo_device struct. | |
ba4e7d97 TH |
580 | * @size: Requested size of buffer object. |
581 | * @type: Requested type of buffer object. | |
59201052 | 582 | * @placement: Initial placement. |
ba4e7d97 | 583 | * @page_alignment: Data alignment in pages. |
ba4e7d97 TH |
584 | * @interruptible: If needing to sleep while waiting for GPU resources, |
585 | * sleep interruptible. | |
ba4e7d97 TH |
586 | * @p_bo: On successful completion *p_bo points to the created object. |
587 | * | |
09855acb JG |
588 | * This function allocates a ttm_buffer_object, and then calls ttm_bo_init |
589 | * on that object. The destroy function is set to kfree(). | |
ba4e7d97 TH |
590 | * Returns |
591 | * -ENOMEM: Out of memory. | |
592 | * -EINVAL: Invalid placement flags. | |
98ffc415 | 593 | * -ERESTARTSYS: Interrupted by signal while waiting for resources. |
ba4e7d97 | 594 | */ |
ba87349e CK |
595 | int ttm_bo_create(struct ttm_bo_device *bdev, unsigned long size, |
596 | enum ttm_bo_type type, struct ttm_placement *placement, | |
597 | uint32_t page_alignment, bool interruptible, | |
ba87349e | 598 | struct ttm_buffer_object **p_bo); |
ba4e7d97 | 599 | |
ba4e7d97 TH |
600 | /** |
601 | * ttm_bo_init_mm | |
602 | * | |
603 | * @bdev: Pointer to a ttm_bo_device struct. | |
604 | * @mem_type: The memory type. | |
ba4e7d97 TH |
605 | * @p_size: size managed area in pages. |
606 | * | |
607 | * Initialize a manager for a given memory type. | |
608 | * Note: if part of driver firstopen, it must be protected from a | |
609 | * potentially racing lastclose. | |
610 | * Returns: | |
611 | * -EINVAL: invalid size or memory type. | |
612 | * -ENOMEM: Not enough memory. | |
613 | * May also return driver-specified errors. | |
614 | */ | |
ba87349e CK |
615 | int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type, |
616 | unsigned long p_size); | |
ba4e7d97 | 617 | |
ba4e7d97 TH |
618 | /** |
619 | * ttm_bo_clean_mm | |
620 | * | |
621 | * @bdev: Pointer to a ttm_bo_device struct. | |
622 | * @mem_type: The memory type. | |
623 | * | |
624 | * Take down a manager for a given memory type after first walking | |
625 | * the LRU list to evict any buffers left alive. | |
626 | * | |
627 | * Normally, this function is part of lastclose() or unload(), and at that | |
628 | * point there shouldn't be any buffers left created by user-space, since | |
629 | * there should've been removed by the file descriptor release() method. | |
630 | * However, before this function is run, make sure to signal all sync objects, | |
631 | * and verify that the delayed delete queue is empty. The driver must also | |
632 | * make sure that there are no NO_EVICT buffers present in this memory type | |
633 | * when the call is made. | |
634 | * | |
635 | * If this function is part of a VT switch, the caller must make sure that | |
636 | * there are no appications currently validating buffers before this | |
637 | * function is called. The caller can do that by first taking the | |
638 | * struct ttm_bo_device::ttm_lock in write mode. | |
639 | * | |
640 | * Returns: | |
641 | * -EINVAL: invalid or uninitialized memory type. | |
642 | * -EBUSY: There are still buffers left in this memory type. | |
643 | */ | |
ba87349e | 644 | int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type); |
ba4e7d97 TH |
645 | |
646 | /** | |
647 | * ttm_bo_evict_mm | |
648 | * | |
649 | * @bdev: Pointer to a ttm_bo_device struct. | |
650 | * @mem_type: The memory type. | |
651 | * | |
652 | * Evicts all buffers on the lru list of the memory type. | |
653 | * This is normally part of a VT switch or an | |
654 | * out-of-memory-space-due-to-fragmentation handler. | |
655 | * The caller must make sure that there are no other processes | |
656 | * currently validating buffers, and can do that by taking the | |
657 | * struct ttm_bo_device::ttm_lock in write mode. | |
658 | * | |
659 | * Returns: | |
660 | * -EINVAL: Invalid or uninitialized memory type. | |
98ffc415 | 661 | * -ERESTARTSYS: The call was interrupted by a signal while waiting to |
ba4e7d97 TH |
662 | * evict a buffer. |
663 | */ | |
ba87349e | 664 | int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type); |
ba4e7d97 TH |
665 | |
666 | /** | |
667 | * ttm_kmap_obj_virtual | |
668 | * | |
669 | * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap. | |
670 | * @is_iomem: Pointer to an integer that on return indicates 1 if the | |
671 | * virtual map is io memory, 0 if normal memory. | |
672 | * | |
673 | * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap. | |
674 | * If *is_iomem is 1 on return, the virtual address points to an io memory area, | |
675 | * that should strictly be accessed by the iowriteXX() and similar functions. | |
676 | */ | |
ba4e7d97 TH |
677 | static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map, |
678 | bool *is_iomem) | |
679 | { | |
a0724fcf | 680 | *is_iomem = !!(map->bo_kmap_type & TTM_BO_MAP_IOMEM_MASK); |
ba4e7d97 TH |
681 | return map->virtual; |
682 | } | |
683 | ||
684 | /** | |
685 | * ttm_bo_kmap | |
686 | * | |
687 | * @bo: The buffer object. | |
688 | * @start_page: The first page to map. | |
689 | * @num_pages: Number of pages to map. | |
690 | * @map: pointer to a struct ttm_bo_kmap_obj representing the map. | |
691 | * | |
692 | * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the | |
693 | * data in the buffer object. The ttm_kmap_obj_virtual function can then be | |
694 | * used to obtain a virtual address to the data. | |
695 | * | |
696 | * Returns | |
697 | * -ENOMEM: Out of memory. | |
698 | * -EINVAL: Invalid range. | |
699 | */ | |
ba87349e CK |
700 | int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page, |
701 | unsigned long num_pages, struct ttm_bo_kmap_obj *map); | |
ba4e7d97 TH |
702 | |
703 | /** | |
704 | * ttm_bo_kunmap | |
705 | * | |
706 | * @map: Object describing the map to unmap. | |
707 | * | |
708 | * Unmaps a kernel map set up by ttm_bo_kmap. | |
709 | */ | |
ba87349e | 710 | void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map); |
ba4e7d97 | 711 | |
ba4e7d97 TH |
712 | /** |
713 | * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object. | |
714 | * | |
715 | * @vma: vma as input from the fbdev mmap method. | |
716 | * @bo: The bo backing the address space. The address space will | |
717 | * have the same size as the bo, and start at offset 0. | |
718 | * | |
719 | * This function is intended to be called by the fbdev mmap method | |
720 | * if the fbdev address space is to be backed by a bo. | |
721 | */ | |
ba87349e | 722 | int ttm_fbdev_mmap(struct vm_area_struct *vma, struct ttm_buffer_object *bo); |
ba4e7d97 TH |
723 | |
724 | /** | |
725 | * ttm_bo_mmap - mmap out of the ttm device address space. | |
726 | * | |
727 | * @filp: filp as input from the mmap method. | |
728 | * @vma: vma as input from the mmap method. | |
729 | * @bdev: Pointer to the ttm_bo_device with the address space manager. | |
730 | * | |
731 | * This function is intended to be called by the device mmap method. | |
732 | * if the device address space is to be backed by the bo manager. | |
733 | */ | |
ba87349e CK |
734 | int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma, |
735 | struct ttm_bo_device *bdev); | |
ba4e7d97 | 736 | |
9c11fcf1 TH |
737 | void *ttm_kmap_atomic_prot(struct page *page, pgprot_t prot); |
738 | ||
739 | void ttm_kunmap_atomic_prot(void *addr, pgprot_t prot); | |
740 | ||
ba4e7d97 TH |
741 | /** |
742 | * ttm_bo_io | |
743 | * | |
744 | * @bdev: Pointer to the struct ttm_bo_device. | |
745 | * @filp: Pointer to the struct file attempting to read / write. | |
746 | * @wbuf: User-space pointer to address of buffer to write. NULL on read. | |
747 | * @rbuf: User-space pointer to address of buffer to read into. | |
748 | * Null on write. | |
749 | * @count: Number of bytes to read / write. | |
750 | * @f_pos: Pointer to current file position. | |
751 | * @write: 1 for read, 0 for write. | |
752 | * | |
753 | * This function implements read / write into ttm buffer objects, and is | |
754 | * intended to | |
755 | * be called from the fops::read and fops::write method. | |
756 | * Returns: | |
757 | * See man (2) write, man(2) read. In particular, | |
98ffc415 | 758 | * the function may return -ERESTARTSYS if |
ba4e7d97 TH |
759 | * interrupted by a signal. |
760 | */ | |
ba87349e CK |
761 | ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp, |
762 | const char __user *wbuf, char __user *rbuf, | |
763 | size_t count, loff_t *f_pos, bool write); | |
ba4e7d97 | 764 | |
dc947770 RH |
765 | int ttm_bo_swapout(struct ttm_bo_global *glob, |
766 | struct ttm_operation_ctx *ctx); | |
ba87349e CK |
767 | void ttm_bo_swapout_all(struct ttm_bo_device *bdev); |
768 | int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo); | |
8eb8833e GH |
769 | |
770 | /** | |
771 | * ttm_bo_uses_embedded_gem_object - check if the given bo uses the | |
772 | * embedded drm_gem_object. | |
773 | * | |
774 | * Most ttm drivers are using gem too, so the embedded | |
775 | * ttm_buffer_object.base will be initialized by the driver (before | |
776 | * calling ttm_bo_init). It is also possible to use ttm without gem | |
777 | * though (vmwgfx does that). | |
778 | * | |
779 | * This helper will figure whenever a given ttm bo is a gem object too | |
780 | * or not. | |
781 | * | |
782 | * @bo: The bo to check. | |
783 | */ | |
784 | static inline bool ttm_bo_uses_embedded_gem_object(struct ttm_buffer_object *bo) | |
785 | { | |
786 | return bo->base.dev != NULL; | |
787 | } | |
ba4e7d97 | 788 | #endif |