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