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