]>
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 | ||
34 | #include "drm_hashtab.h" | |
35 | #include <linux/kref.h> | |
36 | #include <linux/list.h> | |
37 | #include <linux/wait.h> | |
38 | #include <linux/mutex.h> | |
39 | #include <linux/mm.h> | |
40 | #include <linux/rbtree.h> | |
41 | #include <linux/bitmap.h> | |
42 | ||
43 | struct ttm_bo_device; | |
44 | ||
45 | struct drm_mm_node; | |
46 | ||
ca262a99 JG |
47 | |
48 | /** | |
49 | * struct ttm_placement | |
50 | * | |
51 | * @fpfn: first valid page frame number to put the object | |
52 | * @lpfn: last valid page frame number to put the object | |
25985edc LDM |
53 | * @num_placement: number of preferred placements |
54 | * @placement: preferred placements | |
55 | * @num_busy_placement: number of preferred placements when need to evict buffer | |
56 | * @busy_placement: preferred placements when need to evict buffer | |
ca262a99 JG |
57 | * |
58 | * Structure indicating the placement you request for an object. | |
59 | */ | |
60 | struct ttm_placement { | |
61 | unsigned fpfn; | |
62 | unsigned lpfn; | |
63 | unsigned num_placement; | |
64 | const uint32_t *placement; | |
65 | unsigned num_busy_placement; | |
66 | const uint32_t *busy_placement; | |
67 | }; | |
68 | ||
82c5da6b JG |
69 | /** |
70 | * struct ttm_bus_placement | |
71 | * | |
72 | * @addr: mapped virtual address | |
73 | * @base: bus base address | |
74 | * @is_iomem: is this io memory ? | |
75 | * @size: size in byte | |
76 | * @offset: offset from the base address | |
eba67093 TH |
77 | * @io_reserved_vm: The VM system has a refcount in @io_reserved_count |
78 | * @io_reserved_count: Refcounting the numbers of callers to ttm_mem_io_reserve | |
82c5da6b JG |
79 | * |
80 | * Structure indicating the bus placement of an object. | |
81 | */ | |
82 | struct ttm_bus_placement { | |
83 | void *addr; | |
84 | unsigned long base; | |
85 | unsigned long size; | |
86 | unsigned long offset; | |
87 | bool is_iomem; | |
eba67093 TH |
88 | bool io_reserved_vm; |
89 | uint64_t io_reserved_count; | |
82c5da6b JG |
90 | }; |
91 | ||
ca262a99 | 92 | |
ba4e7d97 TH |
93 | /** |
94 | * struct ttm_mem_reg | |
95 | * | |
96 | * @mm_node: Memory manager node. | |
97 | * @size: Requested size of memory region. | |
98 | * @num_pages: Actual size of memory region in pages. | |
99 | * @page_alignment: Page alignment. | |
100 | * @placement: Placement flags. | |
82c5da6b | 101 | * @bus: Placement on io bus accessible to the CPU |
ba4e7d97 TH |
102 | * |
103 | * Structure indicating the placement and space resources used by a | |
104 | * buffer object. | |
105 | */ | |
106 | ||
107 | struct ttm_mem_reg { | |
d961db75 BS |
108 | void *mm_node; |
109 | unsigned long start; | |
ba4e7d97 TH |
110 | unsigned long size; |
111 | unsigned long num_pages; | |
112 | uint32_t page_alignment; | |
113 | uint32_t mem_type; | |
114 | uint32_t placement; | |
82c5da6b | 115 | struct ttm_bus_placement bus; |
ba4e7d97 TH |
116 | }; |
117 | ||
118 | /** | |
119 | * enum ttm_bo_type | |
120 | * | |
121 | * @ttm_bo_type_device: These are 'normal' buffers that can | |
122 | * be mmapped by user space. Each of these bos occupy a slot in the | |
123 | * device address space, that can be used for normal vm operations. | |
124 | * | |
ba4e7d97 TH |
125 | * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers, |
126 | * but they cannot be accessed from user-space. For kernel-only use. | |
127 | */ | |
128 | ||
129 | enum ttm_bo_type { | |
130 | ttm_bo_type_device, | |
ba4e7d97 TH |
131 | ttm_bo_type_kernel |
132 | }; | |
133 | ||
134 | struct ttm_tt; | |
135 | ||
136 | /** | |
137 | * struct ttm_buffer_object | |
138 | * | |
139 | * @bdev: Pointer to the buffer object device structure. | |
140 | * @buffer_start: The virtual user-space start address of ttm_bo_type_user | |
141 | * buffers. | |
142 | * @type: The bo type. | |
143 | * @destroy: Destruction function. If NULL, kfree is used. | |
144 | * @num_pages: Actual number of pages. | |
145 | * @addr_space_offset: Address space offset. | |
146 | * @acc_size: Accounted size for this object. | |
147 | * @kref: Reference count of this buffer object. When this refcount reaches | |
148 | * zero, the object is put on the delayed delete list. | |
149 | * @list_kref: List reference count of this buffer object. This member is | |
150 | * used to avoid destruction while the buffer object is still on a list. | |
151 | * Lru lists may keep one refcount, the delayed delete list, and kref != 0 | |
152 | * keeps one refcount. When this refcount reaches zero, | |
153 | * the object is destroyed. | |
154 | * @event_queue: Queue for processes waiting on buffer object status change. | |
ba4e7d97 | 155 | * @mem: structure describing current placement. |
5df23979 | 156 | * @persistent_swap_storage: Usually the swap storage is deleted for buffers |
ba4e7d97 | 157 | * pinned in physical memory. If this behaviour is not desired, this member |
5df23979 | 158 | * holds a pointer to a persistent shmem object. |
ba4e7d97 TH |
159 | * @ttm: TTM structure holding system pages. |
160 | * @evicted: Whether the object was evicted without user-space knowing. | |
161 | * @cpu_writes: For synchronization. Number of cpu writers. | |
162 | * @lru: List head for the lru list. | |
163 | * @ddestroy: List head for the delayed destroy list. | |
164 | * @swap: List head for swap LRU list. | |
165 | * @val_seq: Sequence of the validation holding the @reserved lock. | |
166 | * Used to avoid starvation when many processes compete to validate the | |
167 | * buffer. This member is protected by the bo_device::lru_lock. | |
168 | * @seq_valid: The value of @val_seq is valid. This value is protected by | |
169 | * the bo_device::lru_lock. | |
170 | * @reserved: Deadlock-free lock used for synchronization state transitions. | |
171 | * @sync_obj_arg: Opaque argument to synchronization object function. | |
172 | * @sync_obj: Pointer to a synchronization object. | |
173 | * @priv_flags: Flags describing buffer object internal state. | |
174 | * @vm_rb: Rb node for the vm rb tree. | |
175 | * @vm_node: Address space manager node. | |
176 | * @offset: The current GPU offset, which can have different meanings | |
177 | * depending on the memory type. For SYSTEM type memory, it should be 0. | |
178 | * @cur_placement: Hint of current placement. | |
179 | * | |
180 | * Base class for TTM buffer object, that deals with data placement and CPU | |
181 | * mappings. GPU mappings are really up to the driver, but for simpler GPUs | |
182 | * the driver can usually use the placement offset @offset directly as the | |
183 | * GPU virtual address. For drivers implementing multiple | |
184 | * GPU memory manager contexts, the driver should manage the address space | |
185 | * in these contexts separately and use these objects to get the correct | |
186 | * placement and caching for these GPU maps. This makes it possible to use | |
187 | * these objects for even quite elaborate memory management schemes. | |
188 | * The destroy member, the API visibility of this object makes it possible | |
189 | * to derive driver specific types. | |
190 | */ | |
191 | ||
192 | struct ttm_buffer_object { | |
193 | /** | |
194 | * Members constant at init. | |
195 | */ | |
196 | ||
a987fcaa | 197 | struct ttm_bo_global *glob; |
ba4e7d97 TH |
198 | struct ttm_bo_device *bdev; |
199 | unsigned long buffer_start; | |
200 | enum ttm_bo_type type; | |
201 | void (*destroy) (struct ttm_buffer_object *); | |
202 | unsigned long num_pages; | |
203 | uint64_t addr_space_offset; | |
204 | size_t acc_size; | |
205 | ||
206 | /** | |
207 | * Members not needing protection. | |
208 | */ | |
209 | ||
210 | struct kref kref; | |
211 | struct kref list_kref; | |
212 | wait_queue_head_t event_queue; | |
ba4e7d97 TH |
213 | |
214 | /** | |
215 | * Members protected by the bo::reserved lock. | |
216 | */ | |
217 | ||
ba4e7d97 | 218 | struct ttm_mem_reg mem; |
5df23979 | 219 | struct file *persistent_swap_storage; |
ba4e7d97 TH |
220 | struct ttm_tt *ttm; |
221 | bool evicted; | |
222 | ||
223 | /** | |
224 | * Members protected by the bo::reserved lock only when written to. | |
225 | */ | |
226 | ||
227 | atomic_t cpu_writers; | |
228 | ||
229 | /** | |
230 | * Members protected by the bdev::lru_lock. | |
231 | */ | |
232 | ||
233 | struct list_head lru; | |
234 | struct list_head ddestroy; | |
235 | struct list_head swap; | |
eba67093 | 236 | struct list_head io_reserve_lru; |
ba4e7d97 TH |
237 | uint32_t val_seq; |
238 | bool seq_valid; | |
239 | ||
240 | /** | |
241 | * Members protected by the bdev::lru_lock | |
242 | * only when written to. | |
243 | */ | |
244 | ||
245 | atomic_t reserved; | |
246 | ||
ba4e7d97 | 247 | /** |
702adba2 | 248 | * Members protected by struct buffer_object_device::fence_lock |
1df6a2eb TH |
249 | * In addition, setting sync_obj to anything else |
250 | * than NULL requires bo::reserved to be held. This allows for | |
702adba2 | 251 | * checking NULL while reserved but not holding the mentioned lock. |
ba4e7d97 TH |
252 | */ |
253 | ||
254 | void *sync_obj_arg; | |
255 | void *sync_obj; | |
256 | unsigned long priv_flags; | |
257 | ||
258 | /** | |
259 | * Members protected by the bdev::vm_lock | |
260 | */ | |
261 | ||
262 | struct rb_node vm_rb; | |
263 | struct drm_mm_node *vm_node; | |
264 | ||
265 | ||
266 | /** | |
267 | * Special members that are protected by the reserve lock | |
268 | * and the bo::lock when written to. Can be read with | |
269 | * either of these locks held. | |
270 | */ | |
271 | ||
272 | unsigned long offset; | |
273 | uint32_t cur_placement; | |
274 | }; | |
275 | ||
276 | /** | |
277 | * struct ttm_bo_kmap_obj | |
278 | * | |
279 | * @virtual: The current kernel virtual address. | |
280 | * @page: The page when kmap'ing a single page. | |
281 | * @bo_kmap_type: Type of bo_kmap. | |
282 | * | |
283 | * Object describing a kernel mapping. Since a TTM bo may be located | |
284 | * in various memory types with various caching policies, the | |
285 | * mapping can either be an ioremap, a vmap, a kmap or part of a | |
286 | * premapped region. | |
287 | */ | |
288 | ||
a0724fcf | 289 | #define TTM_BO_MAP_IOMEM_MASK 0x80 |
ba4e7d97 TH |
290 | struct ttm_bo_kmap_obj { |
291 | void *virtual; | |
292 | struct page *page; | |
293 | enum { | |
a0724fcf PP |
294 | ttm_bo_map_iomap = 1 | TTM_BO_MAP_IOMEM_MASK, |
295 | ttm_bo_map_vmap = 2, | |
296 | ttm_bo_map_kmap = 3, | |
297 | ttm_bo_map_premapped = 4 | TTM_BO_MAP_IOMEM_MASK, | |
ba4e7d97 | 298 | } bo_kmap_type; |
82c5da6b | 299 | struct ttm_buffer_object *bo; |
ba4e7d97 TH |
300 | }; |
301 | ||
302 | /** | |
303 | * ttm_bo_reference - reference a struct ttm_buffer_object | |
304 | * | |
305 | * @bo: The buffer object. | |
306 | * | |
307 | * Returns a refcounted pointer to a buffer object. | |
308 | */ | |
309 | ||
310 | static inline struct ttm_buffer_object * | |
311 | ttm_bo_reference(struct ttm_buffer_object *bo) | |
312 | { | |
313 | kref_get(&bo->kref); | |
314 | return bo; | |
315 | } | |
316 | ||
317 | /** | |
318 | * ttm_bo_wait - wait for buffer idle. | |
319 | * | |
320 | * @bo: The buffer object. | |
321 | * @interruptible: Use interruptible wait. | |
322 | * @no_wait: Return immediately if buffer is busy. | |
323 | * | |
324 | * This function must be called with the bo::mutex held, and makes | |
325 | * sure any previous rendering to the buffer is completed. | |
326 | * Note: It might be necessary to block validations before the | |
327 | * wait by reserving the buffer. | |
328 | * Returns -EBUSY if no_wait is true and the buffer is busy. | |
98ffc415 | 329 | * Returns -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 TH |
330 | */ |
331 | extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy, | |
332 | bool interruptible, bool no_wait); | |
333 | /** | |
09855acb | 334 | * ttm_bo_validate |
ba4e7d97 TH |
335 | * |
336 | * @bo: The buffer object. | |
ca262a99 | 337 | * @placement: Proposed placement for the buffer object. |
ba4e7d97 | 338 | * @interruptible: Sleep interruptible if sleeping. |
9d87fa21 JG |
339 | * @no_wait_reserve: Return immediately if other buffers are busy. |
340 | * @no_wait_gpu: Return immediately if the GPU is busy. | |
ba4e7d97 TH |
341 | * |
342 | * Changes placement and caching policy of the buffer object | |
ca262a99 | 343 | * according proposed placement. |
ba4e7d97 | 344 | * Returns |
ca262a99 | 345 | * -EINVAL on invalid proposed placement. |
ba4e7d97 TH |
346 | * -ENOMEM on out-of-memory condition. |
347 | * -EBUSY if no_wait is true and buffer busy. | |
98ffc415 | 348 | * -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 | 349 | */ |
09855acb JG |
350 | extern int ttm_bo_validate(struct ttm_buffer_object *bo, |
351 | struct ttm_placement *placement, | |
9d87fa21 JG |
352 | bool interruptible, bool no_wait_reserve, |
353 | bool no_wait_gpu); | |
ca262a99 | 354 | |
ba4e7d97 TH |
355 | /** |
356 | * ttm_bo_unref | |
357 | * | |
358 | * @bo: The buffer object. | |
359 | * | |
360 | * Unreference and clear a pointer to a buffer object. | |
361 | */ | |
362 | extern void ttm_bo_unref(struct ttm_buffer_object **bo); | |
363 | ||
d6ea8886 DA |
364 | |
365 | /** | |
366 | * ttm_bo_list_ref_sub | |
367 | * | |
368 | * @bo: The buffer object. | |
369 | * @count: The number of references with which to decrease @bo::list_kref; | |
370 | * @never_free: The refcount should not reach zero with this operation. | |
371 | * | |
372 | * Release @count lru list references to this buffer object. | |
373 | */ | |
374 | extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count, | |
375 | bool never_free); | |
376 | ||
377 | /** | |
378 | * ttm_bo_add_to_lru | |
379 | * | |
380 | * @bo: The buffer object. | |
381 | * | |
382 | * Add this bo to the relevant mem type lru and, if it's backed by | |
383 | * system pages (ttms) to the swap list. | |
384 | * This function must be called with struct ttm_bo_global::lru_lock held, and | |
385 | * is typically called immediately prior to unreserving a bo. | |
386 | */ | |
387 | extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo); | |
388 | ||
389 | /** | |
390 | * ttm_bo_del_from_lru | |
391 | * | |
392 | * @bo: The buffer object. | |
393 | * | |
394 | * Remove this bo from all lru lists used to lookup and reserve an object. | |
395 | * This function must be called with struct ttm_bo_global::lru_lock held, | |
396 | * and is usually called just immediately after the bo has been reserved to | |
397 | * avoid recursive reservation from lru lists. | |
398 | */ | |
399 | extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo); | |
400 | ||
401 | ||
7c5ee536 MG |
402 | /** |
403 | * ttm_bo_lock_delayed_workqueue | |
404 | * | |
405 | * Prevent the delayed workqueue from running. | |
406 | * Returns | |
407 | * True if the workqueue was queued at the time | |
408 | */ | |
409 | extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev); | |
410 | ||
411 | /** | |
412 | * ttm_bo_unlock_delayed_workqueue | |
413 | * | |
414 | * Allows the delayed workqueue to run. | |
415 | */ | |
416 | extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev, | |
417 | int resched); | |
418 | ||
ba4e7d97 TH |
419 | /** |
420 | * ttm_bo_synccpu_write_grab | |
421 | * | |
422 | * @bo: The buffer object: | |
423 | * @no_wait: Return immediately if buffer is busy. | |
424 | * | |
425 | * Synchronizes a buffer object for CPU RW access. This means | |
426 | * blocking command submission that affects the buffer and | |
427 | * waiting for buffer idle. This lock is recursive. | |
428 | * Returns | |
429 | * -EBUSY if the buffer is busy and no_wait is true. | |
98ffc415 | 430 | * -ERESTARTSYS if interrupted by a signal. |
ba4e7d97 | 431 | */ |
ba4e7d97 TH |
432 | extern int |
433 | ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait); | |
57de4ba9 | 434 | |
ba4e7d97 TH |
435 | /** |
436 | * ttm_bo_synccpu_write_release: | |
437 | * | |
438 | * @bo : The buffer object. | |
439 | * | |
440 | * Releases a synccpu lock. | |
441 | */ | |
442 | extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo); | |
443 | ||
57de4ba9 JG |
444 | /** |
445 | * ttm_bo_acc_size | |
446 | * | |
447 | * @bdev: Pointer to a ttm_bo_device struct. | |
448 | * @bo_size: size of the buffer object in byte. | |
449 | * @struct_size: size of the structure holding buffer object datas | |
450 | * | |
451 | * Returns size to account for a buffer object | |
452 | */ | |
453 | size_t ttm_bo_acc_size(struct ttm_bo_device *bdev, | |
454 | unsigned long bo_size, | |
455 | unsigned struct_size); | |
456 | size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev, | |
457 | unsigned long bo_size, | |
458 | unsigned struct_size); | |
459 | ||
ba4e7d97 | 460 | /** |
09855acb | 461 | * ttm_bo_init |
ba4e7d97 TH |
462 | * |
463 | * @bdev: Pointer to a ttm_bo_device struct. | |
464 | * @bo: Pointer to a ttm_buffer_object to be initialized. | |
465 | * @size: Requested size of buffer object. | |
466 | * @type: Requested type of buffer object. | |
467 | * @flags: Initial placement flags. | |
468 | * @page_alignment: Data alignment in pages. | |
469 | * @buffer_start: Virtual address of user space data backing a | |
470 | * user buffer object. | |
471 | * @interruptible: If needing to sleep to wait for GPU resources, | |
472 | * sleep interruptible. | |
5df23979 | 473 | * @persistent_swap_storage: Usually the swap storage is deleted for buffers |
ba4e7d97 | 474 | * pinned in physical memory. If this behaviour is not desired, this member |
5df23979 | 475 | * holds a pointer to a persistent shmem object. Typically, this would |
ba4e7d97 TH |
476 | * point to the shmem object backing a GEM object if TTM is used to back a |
477 | * GEM user interface. | |
478 | * @acc_size: Accounted size for this object. | |
479 | * @destroy: Destroy function. Use NULL for kfree(). | |
480 | * | |
481 | * This function initializes a pre-allocated struct ttm_buffer_object. | |
482 | * As this object may be part of a larger structure, this function, | |
483 | * together with the @destroy function, | |
484 | * enables driver-specific objects derived from a ttm_buffer_object. | |
485 | * On successful return, the object kref and list_kref are set to 1. | |
7dfbbdcf TH |
486 | * If a failure occurs, the function will call the @destroy function, or |
487 | * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is | |
488 | * illegal and will likely cause memory corruption. | |
489 | * | |
ba4e7d97 TH |
490 | * Returns |
491 | * -ENOMEM: Out of memory. | |
492 | * -EINVAL: Invalid placement flags. | |
98ffc415 | 493 | * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources. |
ba4e7d97 TH |
494 | */ |
495 | ||
09855acb JG |
496 | extern int ttm_bo_init(struct ttm_bo_device *bdev, |
497 | struct ttm_buffer_object *bo, | |
498 | unsigned long size, | |
499 | enum ttm_bo_type type, | |
500 | struct ttm_placement *placement, | |
501 | uint32_t page_alignment, | |
502 | unsigned long buffer_start, | |
503 | bool interrubtible, | |
5df23979 | 504 | struct file *persistent_swap_storage, |
09855acb JG |
505 | size_t acc_size, |
506 | void (*destroy) (struct ttm_buffer_object *)); | |
57de4ba9 | 507 | |
ba4e7d97 TH |
508 | /** |
509 | * ttm_bo_synccpu_object_init | |
510 | * | |
511 | * @bdev: Pointer to a ttm_bo_device struct. | |
512 | * @bo: Pointer to a ttm_buffer_object to be initialized. | |
513 | * @size: Requested size of buffer object. | |
514 | * @type: Requested type of buffer object. | |
515 | * @flags: Initial placement flags. | |
516 | * @page_alignment: Data alignment in pages. | |
517 | * @buffer_start: Virtual address of user space data backing a | |
518 | * user buffer object. | |
519 | * @interruptible: If needing to sleep while waiting for GPU resources, | |
520 | * sleep interruptible. | |
5df23979 | 521 | * @persistent_swap_storage: Usually the swap storage is deleted for buffers |
ba4e7d97 | 522 | * pinned in physical memory. If this behaviour is not desired, this member |
5df23979 | 523 | * holds a pointer to a persistent shmem object. Typically, this would |
ba4e7d97 TH |
524 | * point to the shmem object backing a GEM object if TTM is used to back a |
525 | * GEM user interface. | |
526 | * @p_bo: On successful completion *p_bo points to the created object. | |
527 | * | |
09855acb JG |
528 | * This function allocates a ttm_buffer_object, and then calls ttm_bo_init |
529 | * on that object. The destroy function is set to kfree(). | |
ba4e7d97 TH |
530 | * Returns |
531 | * -ENOMEM: Out of memory. | |
532 | * -EINVAL: Invalid placement flags. | |
98ffc415 | 533 | * -ERESTARTSYS: Interrupted by signal while waiting for resources. |
ba4e7d97 TH |
534 | */ |
535 | ||
09855acb JG |
536 | extern int ttm_bo_create(struct ttm_bo_device *bdev, |
537 | unsigned long size, | |
538 | enum ttm_bo_type type, | |
539 | struct ttm_placement *placement, | |
540 | uint32_t page_alignment, | |
541 | unsigned long buffer_start, | |
542 | bool interruptible, | |
5df23979 | 543 | struct file *persistent_swap_storage, |
09855acb | 544 | struct ttm_buffer_object **p_bo); |
ba4e7d97 TH |
545 | |
546 | /** | |
547 | * ttm_bo_check_placement | |
548 | * | |
09855acb JG |
549 | * @bo: the buffer object. |
550 | * @placement: placements | |
ba4e7d97 TH |
551 | * |
552 | * Performs minimal validity checking on an intended change of | |
553 | * placement flags. | |
554 | * Returns | |
555 | * -EINVAL: Intended change is invalid or not allowed. | |
556 | */ | |
ba4e7d97 | 557 | extern int ttm_bo_check_placement(struct ttm_buffer_object *bo, |
09855acb | 558 | struct ttm_placement *placement); |
ba4e7d97 TH |
559 | |
560 | /** | |
561 | * ttm_bo_init_mm | |
562 | * | |
563 | * @bdev: Pointer to a ttm_bo_device struct. | |
564 | * @mem_type: The memory type. | |
ba4e7d97 TH |
565 | * @p_size: size managed area in pages. |
566 | * | |
567 | * Initialize a manager for a given memory type. | |
568 | * Note: if part of driver firstopen, it must be protected from a | |
569 | * potentially racing lastclose. | |
570 | * Returns: | |
571 | * -EINVAL: invalid size or memory type. | |
572 | * -ENOMEM: Not enough memory. | |
573 | * May also return driver-specified errors. | |
574 | */ | |
575 | ||
576 | extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type, | |
ca262a99 | 577 | unsigned long p_size); |
ba4e7d97 TH |
578 | /** |
579 | * ttm_bo_clean_mm | |
580 | * | |
581 | * @bdev: Pointer to a ttm_bo_device struct. | |
582 | * @mem_type: The memory type. | |
583 | * | |
584 | * Take down a manager for a given memory type after first walking | |
585 | * the LRU list to evict any buffers left alive. | |
586 | * | |
587 | * Normally, this function is part of lastclose() or unload(), and at that | |
588 | * point there shouldn't be any buffers left created by user-space, since | |
589 | * there should've been removed by the file descriptor release() method. | |
590 | * However, before this function is run, make sure to signal all sync objects, | |
591 | * and verify that the delayed delete queue is empty. The driver must also | |
592 | * make sure that there are no NO_EVICT buffers present in this memory type | |
593 | * when the call is made. | |
594 | * | |
595 | * If this function is part of a VT switch, the caller must make sure that | |
596 | * there are no appications currently validating buffers before this | |
597 | * function is called. The caller can do that by first taking the | |
598 | * struct ttm_bo_device::ttm_lock in write mode. | |
599 | * | |
600 | * Returns: | |
601 | * -EINVAL: invalid or uninitialized memory type. | |
602 | * -EBUSY: There are still buffers left in this memory type. | |
603 | */ | |
604 | ||
605 | extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type); | |
606 | ||
607 | /** | |
608 | * ttm_bo_evict_mm | |
609 | * | |
610 | * @bdev: Pointer to a ttm_bo_device struct. | |
611 | * @mem_type: The memory type. | |
612 | * | |
613 | * Evicts all buffers on the lru list of the memory type. | |
614 | * This is normally part of a VT switch or an | |
615 | * out-of-memory-space-due-to-fragmentation handler. | |
616 | * The caller must make sure that there are no other processes | |
617 | * currently validating buffers, and can do that by taking the | |
618 | * struct ttm_bo_device::ttm_lock in write mode. | |
619 | * | |
620 | * Returns: | |
621 | * -EINVAL: Invalid or uninitialized memory type. | |
98ffc415 | 622 | * -ERESTARTSYS: The call was interrupted by a signal while waiting to |
ba4e7d97 TH |
623 | * evict a buffer. |
624 | */ | |
625 | ||
626 | extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type); | |
627 | ||
628 | /** | |
629 | * ttm_kmap_obj_virtual | |
630 | * | |
631 | * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap. | |
632 | * @is_iomem: Pointer to an integer that on return indicates 1 if the | |
633 | * virtual map is io memory, 0 if normal memory. | |
634 | * | |
635 | * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap. | |
636 | * If *is_iomem is 1 on return, the virtual address points to an io memory area, | |
637 | * that should strictly be accessed by the iowriteXX() and similar functions. | |
638 | */ | |
639 | ||
640 | static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map, | |
641 | bool *is_iomem) | |
642 | { | |
a0724fcf | 643 | *is_iomem = !!(map->bo_kmap_type & TTM_BO_MAP_IOMEM_MASK); |
ba4e7d97 TH |
644 | return map->virtual; |
645 | } | |
646 | ||
647 | /** | |
648 | * ttm_bo_kmap | |
649 | * | |
650 | * @bo: The buffer object. | |
651 | * @start_page: The first page to map. | |
652 | * @num_pages: Number of pages to map. | |
653 | * @map: pointer to a struct ttm_bo_kmap_obj representing the map. | |
654 | * | |
655 | * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the | |
656 | * data in the buffer object. The ttm_kmap_obj_virtual function can then be | |
657 | * used to obtain a virtual address to the data. | |
658 | * | |
659 | * Returns | |
660 | * -ENOMEM: Out of memory. | |
661 | * -EINVAL: Invalid range. | |
662 | */ | |
663 | ||
664 | extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page, | |
665 | unsigned long num_pages, struct ttm_bo_kmap_obj *map); | |
666 | ||
667 | /** | |
668 | * ttm_bo_kunmap | |
669 | * | |
670 | * @map: Object describing the map to unmap. | |
671 | * | |
672 | * Unmaps a kernel map set up by ttm_bo_kmap. | |
673 | */ | |
674 | ||
675 | extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map); | |
676 | ||
ba4e7d97 TH |
677 | /** |
678 | * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object. | |
679 | * | |
680 | * @vma: vma as input from the fbdev mmap method. | |
681 | * @bo: The bo backing the address space. The address space will | |
682 | * have the same size as the bo, and start at offset 0. | |
683 | * | |
684 | * This function is intended to be called by the fbdev mmap method | |
685 | * if the fbdev address space is to be backed by a bo. | |
686 | */ | |
687 | ||
688 | extern int ttm_fbdev_mmap(struct vm_area_struct *vma, | |
689 | struct ttm_buffer_object *bo); | |
690 | ||
691 | /** | |
692 | * ttm_bo_mmap - mmap out of the ttm device address space. | |
693 | * | |
694 | * @filp: filp as input from the mmap method. | |
695 | * @vma: vma as input from the mmap method. | |
696 | * @bdev: Pointer to the ttm_bo_device with the address space manager. | |
697 | * | |
698 | * This function is intended to be called by the device mmap method. | |
699 | * if the device address space is to be backed by the bo manager. | |
700 | */ | |
701 | ||
702 | extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma, | |
703 | struct ttm_bo_device *bdev); | |
704 | ||
705 | /** | |
706 | * ttm_bo_io | |
707 | * | |
708 | * @bdev: Pointer to the struct ttm_bo_device. | |
709 | * @filp: Pointer to the struct file attempting to read / write. | |
710 | * @wbuf: User-space pointer to address of buffer to write. NULL on read. | |
711 | * @rbuf: User-space pointer to address of buffer to read into. | |
712 | * Null on write. | |
713 | * @count: Number of bytes to read / write. | |
714 | * @f_pos: Pointer to current file position. | |
715 | * @write: 1 for read, 0 for write. | |
716 | * | |
717 | * This function implements read / write into ttm buffer objects, and is | |
718 | * intended to | |
719 | * be called from the fops::read and fops::write method. | |
720 | * Returns: | |
721 | * See man (2) write, man(2) read. In particular, | |
98ffc415 | 722 | * the function may return -ERESTARTSYS if |
ba4e7d97 TH |
723 | * interrupted by a signal. |
724 | */ | |
725 | ||
726 | extern ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp, | |
727 | const char __user *wbuf, char __user *rbuf, | |
728 | size_t count, loff_t *f_pos, bool write); | |
729 | ||
730 | extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev); | |
731 | ||
732 | #endif |