| /drivers/include/drm/ttm/ttm_execbuf_util.h |
|---|
| 0,0 → 1,109 |
| /************************************************************************** |
| * |
| * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| **************************************************************************/ |
| /* |
| * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> |
| */ |
| #ifndef _TTM_EXECBUF_UTIL_H_ |
| #define _TTM_EXECBUF_UTIL_H_ |
| #include <ttm/ttm_bo_api.h> |
| #include <linux/list.h> |
| /** |
| * struct ttm_validate_buffer |
| * |
| * @head: list head for thread-private list. |
| * @bo: refcounted buffer object pointer. |
| * @reserved: Indicates whether @bo has been reserved for validation. |
| * @removed: Indicates whether @bo has been removed from lru lists. |
| * @put_count: Number of outstanding references on bo::list_kref. |
| * @old_sync_obj: Pointer to a sync object about to be unreferenced |
| */ |
| struct ttm_validate_buffer { |
| struct list_head head; |
| struct ttm_buffer_object *bo; |
| bool reserved; |
| bool removed; |
| int put_count; |
| void *old_sync_obj; |
| }; |
| /** |
| * function ttm_eu_backoff_reservation |
| * |
| * @list: thread private list of ttm_validate_buffer structs. |
| * |
| * Undoes all buffer validation reservations for bos pointed to by |
| * the list entries. |
| */ |
| extern void ttm_eu_backoff_reservation(struct list_head *list); |
| /** |
| * function ttm_eu_reserve_buffers |
| * |
| * @list: thread private list of ttm_validate_buffer structs. |
| * |
| * Tries to reserve bos pointed to by the list entries for validation. |
| * If the function returns 0, all buffers are marked as "unfenced", |
| * taken off the lru lists and are not synced for write CPU usage. |
| * |
| * If the function detects a deadlock due to multiple threads trying to |
| * reserve the same buffers in reverse order, all threads except one will |
| * back off and retry. This function may sleep while waiting for |
| * CPU write reservations to be cleared, and for other threads to |
| * unreserve their buffers. |
| * |
| * This function may return -ERESTART or -EAGAIN if the calling process |
| * receives a signal while waiting. In that case, no buffers on the list |
| * will be reserved upon return. |
| * |
| * Buffers reserved by this function should be unreserved by |
| * a call to either ttm_eu_backoff_reservation() or |
| * ttm_eu_fence_buffer_objects() when command submission is complete or |
| * has failed. |
| */ |
| extern int ttm_eu_reserve_buffers(struct list_head *list); |
| /** |
| * function ttm_eu_fence_buffer_objects. |
| * |
| * @list: thread private list of ttm_validate_buffer structs. |
| * @sync_obj: The new sync object for the buffers. |
| * |
| * This function should be called when command submission is complete, and |
| * it will add a new sync object to bos pointed to by entries on @list. |
| * It also unreserves all buffers, putting them on lru lists. |
| * |
| */ |
| extern void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj); |
| #endif |
| /drivers/include/drm/ttm/ttm_lock.h |
|---|
| 0,0 → 1,247 |
| /************************************************************************** |
| * |
| * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| **************************************************************************/ |
| /* |
| * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> |
| */ |
| /** @file ttm_lock.h |
| * This file implements a simple replacement for the buffer manager use |
| * of the DRM heavyweight hardware lock. |
| * The lock is a read-write lock. Taking it in read mode and write mode |
| * is relatively fast, and intended for in-kernel use only. |
| * |
| * The vt mode is used only when there is a need to block all |
| * user-space processes from validating buffers. |
| * It's allowed to leave kernel space with the vt lock held. |
| * If a user-space process dies while having the vt-lock, |
| * it will be released during the file descriptor release. The vt lock |
| * excludes write lock and read lock. |
| * |
| * The suspend mode is used to lock out all TTM users when preparing for |
| * and executing suspend operations. |
| * |
| */ |
| #ifndef _TTM_LOCK_H_ |
| #define _TTM_LOCK_H_ |
| #include <ttm/ttm_object.h> |
| #include <linux/wait.h> |
| #include <linux/atomic.h> |
| /** |
| * struct ttm_lock |
| * |
| * @base: ttm base object used solely to release the lock if the client |
| * holding the lock dies. |
| * @queue: Queue for processes waiting for lock change-of-status. |
| * @lock: Spinlock protecting some lock members. |
| * @rw: Read-write lock counter. Protected by @lock. |
| * @flags: Lock state. Protected by @lock. |
| * @kill_takers: Boolean whether to kill takers of the lock. |
| * @signal: Signal to send when kill_takers is true. |
| */ |
| struct ttm_lock { |
| struct ttm_base_object base; |
| wait_queue_head_t queue; |
| spinlock_t lock; |
| int32_t rw; |
| uint32_t flags; |
| bool kill_takers; |
| int signal; |
| struct ttm_object_file *vt_holder; |
| }; |
| /** |
| * ttm_lock_init |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * Initializes the lock. |
| */ |
| extern void ttm_lock_init(struct ttm_lock *lock); |
| /** |
| * ttm_read_unlock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Releases a read lock. |
| */ |
| extern void ttm_read_unlock(struct ttm_lock *lock); |
| /** |
| * ttm_read_lock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @interruptible: Interruptible sleeping while waiting for a lock. |
| * |
| * Takes the lock in read mode. |
| * Returns: |
| * -ERESTARTSYS If interrupted by a signal and interruptible is true. |
| */ |
| extern int ttm_read_lock(struct ttm_lock *lock, bool interruptible); |
| /** |
| * ttm_read_trylock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @interruptible: Interruptible sleeping while waiting for a lock. |
| * |
| * Tries to take the lock in read mode. If the lock is already held |
| * in write mode, the function will return -EBUSY. If the lock is held |
| * in vt or suspend mode, the function will sleep until these modes |
| * are unlocked. |
| * |
| * Returns: |
| * -EBUSY The lock was already held in write mode. |
| * -ERESTARTSYS If interrupted by a signal and interruptible is true. |
| */ |
| extern int ttm_read_trylock(struct ttm_lock *lock, bool interruptible); |
| /** |
| * ttm_write_unlock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Releases a write lock. |
| */ |
| extern void ttm_write_unlock(struct ttm_lock *lock); |
| /** |
| * ttm_write_lock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @interruptible: Interruptible sleeping while waiting for a lock. |
| * |
| * Takes the lock in write mode. |
| * Returns: |
| * -ERESTARTSYS If interrupted by a signal and interruptible is true. |
| */ |
| extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible); |
| /** |
| * ttm_lock_downgrade |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Downgrades a write lock to a read lock. |
| */ |
| extern void ttm_lock_downgrade(struct ttm_lock *lock); |
| /** |
| * ttm_suspend_lock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Takes the lock in suspend mode. Excludes read and write mode. |
| */ |
| extern void ttm_suspend_lock(struct ttm_lock *lock); |
| /** |
| * ttm_suspend_unlock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Releases a suspend lock |
| */ |
| extern void ttm_suspend_unlock(struct ttm_lock *lock); |
| /** |
| * ttm_vt_lock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @interruptible: Interruptible sleeping while waiting for a lock. |
| * @tfile: Pointer to a struct ttm_object_file to register the lock with. |
| * |
| * Takes the lock in vt mode. |
| * Returns: |
| * -ERESTARTSYS If interrupted by a signal and interruptible is true. |
| * -ENOMEM: Out of memory when locking. |
| */ |
| extern int ttm_vt_lock(struct ttm_lock *lock, bool interruptible, |
| struct ttm_object_file *tfile); |
| /** |
| * ttm_vt_unlock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Releases a vt lock. |
| * Returns: |
| * -EINVAL If the lock was not held. |
| */ |
| extern int ttm_vt_unlock(struct ttm_lock *lock); |
| /** |
| * ttm_write_unlock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * |
| * Releases a write lock. |
| */ |
| extern void ttm_write_unlock(struct ttm_lock *lock); |
| /** |
| * ttm_write_lock |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @interruptible: Interruptible sleeping while waiting for a lock. |
| * |
| * Takes the lock in write mode. |
| * Returns: |
| * -ERESTARTSYS If interrupted by a signal and interruptible is true. |
| */ |
| extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible); |
| /** |
| * ttm_lock_set_kill |
| * |
| * @lock: Pointer to a struct ttm_lock |
| * @val: Boolean whether to kill processes taking the lock. |
| * @signal: Signal to send to the process taking the lock. |
| * |
| * The kill-when-taking-lock functionality is used to kill processes that keep |
| * on using the TTM functionality when its resources has been taken down, for |
| * example when the X server exits. A typical sequence would look like this: |
| * - X server takes lock in write mode. |
| * - ttm_lock_set_kill() is called with @val set to true. |
| * - As part of X server exit, TTM resources are taken down. |
| * - X server releases the lock on file release. |
| * - Another dri client wants to render, takes the lock and is killed. |
| * |
| */ |
| static inline void ttm_lock_set_kill(struct ttm_lock *lock, bool val, |
| int signal) |
| { |
| lock->kill_takers = val; |
| if (val) |
| lock->signal = signal; |
| } |
| #endif |
| /drivers/include/drm/ttm/ttm_object.h |
|---|
| 0,0 → 1,275 |
| /************************************************************************** |
| * |
| * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| **************************************************************************/ |
| /* |
| * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> |
| */ |
| /** @file ttm_object.h |
| * |
| * Base- and reference object implementation for the various |
| * ttm objects. Implements reference counting, minimal security checks |
| * and release on file close. |
| */ |
| #ifndef _TTM_OBJECT_H_ |
| #define _TTM_OBJECT_H_ |
| #include <linux/list.h> |
| #include <drm/drm_hashtab.h> |
| #include <linux/kref.h> |
| #include <linux/rcupdate.h> |
| #include <ttm/ttm_memory.h> |
| /** |
| * enum ttm_ref_type |
| * |
| * Describes what type of reference a ref object holds. |
| * |
| * TTM_REF_USAGE is a simple refcount on a base object. |
| * |
| * TTM_REF_SYNCCPU_READ is a SYNCCPU_READ reference on a |
| * buffer object. |
| * |
| * TTM_REF_SYNCCPU_WRITE is a SYNCCPU_WRITE reference on a |
| * buffer object. |
| * |
| */ |
| enum ttm_ref_type { |
| TTM_REF_USAGE, |
| TTM_REF_SYNCCPU_READ, |
| TTM_REF_SYNCCPU_WRITE, |
| TTM_REF_NUM |
| }; |
| /** |
| * enum ttm_object_type |
| * |
| * One entry per ttm object type. |
| * Device-specific types should use the |
| * ttm_driver_typex types. |
| */ |
| enum ttm_object_type { |
| ttm_fence_type, |
| ttm_buffer_type, |
| ttm_lock_type, |
| ttm_driver_type0 = 256, |
| ttm_driver_type1, |
| ttm_driver_type2, |
| ttm_driver_type3, |
| ttm_driver_type4, |
| ttm_driver_type5 |
| }; |
| struct ttm_object_file; |
| struct ttm_object_device; |
| /** |
| * struct ttm_base_object |
| * |
| * @hash: hash entry for the per-device object hash. |
| * @type: derived type this object is base class for. |
| * @shareable: Other ttm_object_files can access this object. |
| * |
| * @tfile: Pointer to ttm_object_file of the creator. |
| * NULL if the object was not created by a user request. |
| * (kernel object). |
| * |
| * @refcount: Number of references to this object, not |
| * including the hash entry. A reference to a base object can |
| * only be held by a ref object. |
| * |
| * @refcount_release: A function to be called when there are |
| * no more references to this object. This function should |
| * destroy the object (or make sure destruction eventually happens), |
| * and when it is called, the object has |
| * already been taken out of the per-device hash. The parameter |
| * "base" should be set to NULL by the function. |
| * |
| * @ref_obj_release: A function to be called when a reference object |
| * with another ttm_ref_type than TTM_REF_USAGE is deleted. |
| * This function may, for example, release a lock held by a user-space |
| * process. |
| * |
| * This struct is intended to be used as a base struct for objects that |
| * are visible to user-space. It provides a global name, race-safe |
| * access and refcounting, minimal access contol and hooks for unref actions. |
| */ |
| struct ttm_base_object { |
| struct rcu_head rhead; |
| struct drm_hash_item hash; |
| enum ttm_object_type object_type; |
| bool shareable; |
| struct ttm_object_file *tfile; |
| struct kref refcount; |
| void (*refcount_release) (struct ttm_base_object **base); |
| void (*ref_obj_release) (struct ttm_base_object *base, |
| enum ttm_ref_type ref_type); |
| }; |
| /** |
| * ttm_base_object_init |
| * |
| * @tfile: Pointer to a struct ttm_object_file. |
| * @base: The struct ttm_base_object to initialize. |
| * @shareable: This object is shareable with other applcations. |
| * (different @tfile pointers.) |
| * @type: The object type. |
| * @refcount_release: See the struct ttm_base_object description. |
| * @ref_obj_release: See the struct ttm_base_object description. |
| * |
| * Initializes a struct ttm_base_object. |
| */ |
| extern int ttm_base_object_init(struct ttm_object_file *tfile, |
| struct ttm_base_object *base, |
| bool shareable, |
| enum ttm_object_type type, |
| void (*refcount_release) (struct ttm_base_object |
| **), |
| void (*ref_obj_release) (struct ttm_base_object |
| *, |
| enum ttm_ref_type |
| ref_type)); |
| /** |
| * ttm_base_object_lookup |
| * |
| * @tfile: Pointer to a struct ttm_object_file. |
| * @key: Hash key |
| * |
| * Looks up a struct ttm_base_object with the key @key. |
| * Also verifies that the object is visible to the application, by |
| * comparing the @tfile argument and checking the object shareable flag. |
| */ |
| extern struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file |
| *tfile, uint32_t key); |
| /** |
| * ttm_base_object_unref |
| * |
| * @p_base: Pointer to a pointer referencing a struct ttm_base_object. |
| * |
| * Decrements the base object refcount and clears the pointer pointed to by |
| * p_base. |
| */ |
| extern void ttm_base_object_unref(struct ttm_base_object **p_base); |
| /** |
| * ttm_ref_object_add. |
| * |
| * @tfile: A struct ttm_object_file representing the application owning the |
| * ref_object. |
| * @base: The base object to reference. |
| * @ref_type: The type of reference. |
| * @existed: Upon completion, indicates that an identical reference object |
| * already existed, and the refcount was upped on that object instead. |
| * |
| * Adding a ref object to a base object is basically like referencing the |
| * base object, but a user-space application holds the reference. When the |
| * file corresponding to @tfile is closed, all its reference objects are |
| * deleted. A reference object can have different types depending on what |
| * it's intended for. It can be refcounting to prevent object destruction, |
| * When user-space takes a lock, it can add a ref object to that lock to |
| * make sure the lock is released if the application dies. A ref object |
| * will hold a single reference on a base object. |
| */ |
| extern int ttm_ref_object_add(struct ttm_object_file *tfile, |
| struct ttm_base_object *base, |
| enum ttm_ref_type ref_type, bool *existed); |
| /** |
| * ttm_ref_object_base_unref |
| * |
| * @key: Key representing the base object. |
| * @ref_type: Ref type of the ref object to be dereferenced. |
| * |
| * Unreference a ref object with type @ref_type |
| * on the base object identified by @key. If there are no duplicate |
| * references, the ref object will be destroyed and the base object |
| * will be unreferenced. |
| */ |
| extern int ttm_ref_object_base_unref(struct ttm_object_file *tfile, |
| unsigned long key, |
| enum ttm_ref_type ref_type); |
| /** |
| * ttm_object_file_init - initialize a struct ttm_object file |
| * |
| * @tdev: A struct ttm_object device this file is initialized on. |
| * @hash_order: Order of the hash table used to hold the reference objects. |
| * |
| * This is typically called by the file_ops::open function. |
| */ |
| extern struct ttm_object_file *ttm_object_file_init(struct ttm_object_device |
| *tdev, |
| unsigned int hash_order); |
| /** |
| * ttm_object_file_release - release data held by a ttm_object_file |
| * |
| * @p_tfile: Pointer to pointer to the ttm_object_file object to release. |
| * *p_tfile will be set to NULL by this function. |
| * |
| * Releases all data associated by a ttm_object_file. |
| * Typically called from file_ops::release. The caller must |
| * ensure that there are no concurrent users of tfile. |
| */ |
| extern void ttm_object_file_release(struct ttm_object_file **p_tfile); |
| /** |
| * ttm_object device init - initialize a struct ttm_object_device |
| * |
| * @hash_order: Order of hash table used to hash the base objects. |
| * |
| * This function is typically called on device initialization to prepare |
| * data structures needed for ttm base and ref objects. |
| */ |
| extern struct ttm_object_device *ttm_object_device_init |
| (struct ttm_mem_global *mem_glob, unsigned int hash_order); |
| /** |
| * ttm_object_device_release - release data held by a ttm_object_device |
| * |
| * @p_tdev: Pointer to pointer to the ttm_object_device object to release. |
| * *p_tdev will be set to NULL by this function. |
| * |
| * Releases all data associated by a ttm_object_device. |
| * Typically called from driver::unload before the destruction of the |
| * device private data structure. |
| */ |
| extern void ttm_object_device_release(struct ttm_object_device **p_tdev); |
| #define ttm_base_object_kfree(__object, __base)\ |
| kfree_rcu(__object, __base.rhead) |
| #endif |
| /drivers/include/drm/ttm/ttm_page_alloc.h |
|---|
| 0,0 → 1,99 |
| /* |
| * Copyright (c) Red Hat Inc. |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sub license, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: Dave Airlie <airlied@redhat.com> |
| * Jerome Glisse <jglisse@redhat.com> |
| */ |
| #ifndef TTM_PAGE_ALLOC |
| #define TTM_PAGE_ALLOC |
| #include <drm/ttm/ttm_bo_driver.h> |
| #include <drm/ttm/ttm_memory.h> |
| /** |
| * Initialize pool allocator. |
| */ |
| int ttm_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages); |
| /** |
| * Free pool allocator. |
| */ |
| void ttm_page_alloc_fini(void); |
| /** |
| * ttm_pool_populate: |
| * |
| * @ttm: The struct ttm_tt to contain the backing pages. |
| * |
| * Add backing pages to all of @ttm |
| */ |
| extern int ttm_pool_populate(struct ttm_tt *ttm); |
| /** |
| * ttm_pool_unpopulate: |
| * |
| * @ttm: The struct ttm_tt which to free backing pages. |
| * |
| * Free all pages of @ttm |
| */ |
| extern void ttm_pool_unpopulate(struct ttm_tt *ttm); |
| /** |
| * Output the state of pools to debugfs file |
| */ |
| extern int ttm_page_alloc_debugfs(struct seq_file *m, void *data); |
| #ifdef CONFIG_SWIOTLB |
| /** |
| * Initialize pool allocator. |
| */ |
| int ttm_dma_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages); |
| /** |
| * Free pool allocator. |
| */ |
| void ttm_dma_page_alloc_fini(void); |
| /** |
| * Output the state of pools to debugfs file |
| */ |
| extern int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data); |
| extern int ttm_dma_populate(struct ttm_dma_tt *ttm_dma, struct device *dev); |
| extern void ttm_dma_unpopulate(struct ttm_dma_tt *ttm_dma, struct device *dev); |
| #else |
| static inline int ttm_dma_page_alloc_init(struct ttm_mem_global *glob, |
| unsigned max_pages) |
| { |
| return -ENODEV; |
| } |
| static inline void ttm_dma_page_alloc_fini(void) { return; } |
| static inline int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data) |
| { |
| return 0; |
| } |
| #endif |
| #endif |