WebSVN – Kolibri OS – Diff – /drivers/include/drm/ttm/ttm_bo_api.h


/**************************************************************************
 *
 * 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 
 */
 
#ifndef _TTM_BO_API_H_
#define _TTM_BO_API_H_
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
struct ttm_bo_device;
 
struct drm_mm_node;
 
/**
 * struct ttm_place
 *
 * @fpfn:	first valid page frame number to put the object
 * @lpfn:	last valid page frame number to put the object
 * @flags:	memory domain and caching flags for the object
 *
 * Structure indicating a possible place to put an object.
 */
struct ttm_place {
	unsigned	fpfn;
	unsigned	lpfn;
	uint32_t	flags;
};
 
/**
 * struct ttm_placement
 *
 * @num_placement:	number of preferred placements
 * @placement:		preferred placements
 * @num_busy_placement:	number of preferred placements when need to evict buffer
 * @busy_placement:	preferred placements when need to evict buffer
 *
 * Structure indicating the placement you request for an object.
 */
struct ttm_placement {
	unsigned		num_placement;
	const struct ttm_place	*placement;
	unsigned		num_busy_placement;
	const struct ttm_place	*busy_placement;
};
 
/**
 * struct ttm_bus_placement
 *
 * @addr:		mapped virtual address
 * @base:		bus base address
 * @is_iomem:		is this io memory ?
 * @size:		size in byte
 * @offset:		offset from the base address
 * @io_reserved_vm:     The VM system has a refcount in @io_reserved_count
 * @io_reserved_count:  Refcounting the numbers of callers to ttm_mem_io_reserve
 *
 * Structure indicating the bus placement of an object.
 */
struct ttm_bus_placement {
	void		*addr;
	unsigned long	base;
	unsigned long	size;
	unsigned long	offset;
	bool		is_iomem;
	bool		io_reserved_vm;
	uint64_t        io_reserved_count;
};
 
 
/**
 * struct ttm_mem_reg
 *
 * @mm_node: Memory manager node.
 * @size: Requested size of memory region.
 * @num_pages: Actual size of memory region in pages.
 * @page_alignment: Page alignment.
 * @placement: Placement flags.
 * @bus: Placement on io bus accessible to the CPU
 *
 * Structure indicating the placement and space resources used by a
 * buffer object.
 */
 
struct ttm_mem_reg {
	void *mm_node;
	unsigned long start;
	unsigned long size;
	unsigned long num_pages;
	uint32_t page_alignment;
	uint32_t mem_type;
	uint32_t placement;
	struct ttm_bus_placement bus;
};
 
/**
 * enum ttm_bo_type
 *
 * @ttm_bo_type_device:	These are 'normal' buffers that can
 * be mmapped by user space. Each of these bos occupy a slot in the
 * device address space, that can be used for normal vm operations.
 *
 * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
 * but they cannot be accessed from user-space. For kernel-only use.
 *
 * @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another
 * driver.
 */
 
enum ttm_bo_type {
	ttm_bo_type_device,
	ttm_bo_type_kernel,
	ttm_bo_type_sg
};
 
struct ttm_tt;
 
/**
 * struct ttm_buffer_object
 *
 * @bdev: Pointer to the buffer object device structure.
 * @type: The bo type.
 * @destroy: Destruction function. If NULL, kfree is used.
 * @num_pages: Actual number of pages.
 * @acc_size: Accounted size for this object.
 * @kref: Reference count of this buffer object. When this refcount reaches
 * zero, the object is put on the delayed delete list.
 * @list_kref: List reference count of this buffer object. This member is
 * used to avoid destruction while the buffer object is still on a list.
 * Lru lists may keep one refcount, the delayed delete list, and kref != 0
 * keeps one refcount. When this refcount reaches zero,
 * the object is destroyed.
 * @mem: structure describing current placement.
 * @persistent_swap_storage: Usually the swap storage is deleted for buffers
 * pinned in physical memory. If this behaviour is not desired, this member
 * holds a pointer to a persistent shmem object.
 * @ttm: TTM structure holding system pages.
 * @evicted: Whether the object was evicted without user-space knowing.
 * @cpu_writes: For synchronization. Number of cpu writers.
 * @lru: List head for the lru list.
 * @ddestroy: List head for the delayed destroy list.
 * @swap: List head for swap LRU list.
 * @priv_flags: Flags describing buffer object internal state.
 * @vma_node: Address space manager node.
 * @offset: The current GPU offset, which can have different meanings
 * depending on the memory type. For SYSTEM type memory, it should be 0.
 * @cur_placement: Hint of current placement.
 * @wu_mutex: Wait unreserved mutex.
 *
 * Base class for TTM buffer object, that deals with data placement and CPU
 * mappings. GPU mappings are really up to the driver, but for simpler GPUs
 * the driver can usually use the placement offset @offset directly as the
 * GPU virtual address. For drivers implementing multiple
 * GPU memory manager contexts, the driver should manage the address space
 * in these contexts separately and use these objects to get the correct
 * placement and caching for these GPU maps. This makes it possible to use
 * these objects for even quite elaborate memory management schemes.
 * The destroy member, the API visibility of this object makes it possible
 * to derive driver specific types.
 */
 
struct ttm_buffer_object {
	/**
	 * Members constant at init.
	 */
 
	struct ttm_bo_global *glob;
	struct ttm_bo_device *bdev;
	enum ttm_bo_type type;
	void (*destroy) (struct ttm_buffer_object *);
	unsigned long num_pages;
	size_t acc_size;
 
	/**
	* Members not needing protection.
	*/
 
	struct kref kref;
	struct kref list_kref;
 
	/**
	 * Members protected by the bo::resv::reserved lock.
	 */
 
	struct ttm_mem_reg mem;
	struct file *persistent_swap_storage;
	struct ttm_tt *ttm;
	bool evicted;
 
	/**
	 * Members protected by the bo::reserved lock only when written to.
	 */
 
	atomic_t cpu_writers;
 
	/**
	 * Members protected by the bdev::lru_lock.
	 */
 
	struct list_head lru;
	struct list_head ddestroy;
	struct list_head swap;
	struct list_head io_reserve_lru;
 
	/**
	 * Members protected by a bo reservation.
	 */
 
	unsigned long priv_flags;
 
	struct drm_vma_offset_node vma_node;
 
	/**
	 * Special members that are protected by the reserve lock
	 * and the bo::lock when written to. Can be read with
	 * either of these locks held.
	 */
 
	uint64_t offset; /* GPU address space is independent of CPU word size */
	uint32_t cur_placement;
 
	struct sg_table *sg;
 
	struct reservation_object *resv;
	struct reservation_object ttm_resv;
	struct mutex wu_mutex;
};
 
/**
 * struct ttm_bo_kmap_obj
 *
 * @virtual: The current kernel virtual address.
 * @page: The page when kmap'ing a single page.
 * @bo_kmap_type: Type of bo_kmap.
 *
 * Object describing a kernel mapping. Since a TTM bo may be located
 * in various memory types with various caching policies, the
 * mapping can either be an ioremap, a vmap, a kmap or part of a
 * premapped region.
 */
 
#define TTM_BO_MAP_IOMEM_MASK 0x80
struct ttm_bo_kmap_obj {
	void *virtual;
	struct page *page;
	enum {
		ttm_bo_map_iomap        = 1 | TTM_BO_MAP_IOMEM_MASK,
		ttm_bo_map_vmap         = 2,
		ttm_bo_map_kmap         = 3,
		ttm_bo_map_premapped    = 4 | TTM_BO_MAP_IOMEM_MASK,
	} bo_kmap_type;
	struct ttm_buffer_object *bo;
};
 
/**
 * ttm_bo_reference - reference a struct ttm_buffer_object
 *
 * @bo: The buffer object.
 *
 * Returns a refcounted pointer to a buffer object.
 */
 
static inline struct ttm_buffer_object *
ttm_bo_reference(struct ttm_buffer_object *bo)
{
	kref_get(&bo->kref);
	return bo;
}
 
/**
 * ttm_bo_wait - wait for buffer idle.
 *
 * @bo:  The buffer object.
 * @interruptible:  Use interruptible wait.
 * @no_wait:  Return immediately if buffer is busy.
 *
 * This function must be called with the bo::mutex held, and makes
 * sure any previous rendering to the buffer is completed.
 * Note: It might be necessary to block validations before the
 * wait by reserving the buffer.
 * Returns -EBUSY if no_wait is true and the buffer is busy.
 * Returns -ERESTARTSYS if interrupted by a signal.
 */
extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
		       bool interruptible, bool no_wait);
 
/**
 * ttm_bo_mem_compat - Check if proposed placement is compatible with a bo
 *
 * @placement:  Return immediately if buffer is busy.
 * @mem:  The struct ttm_mem_reg indicating the region where the bo resides
 * @new_flags: Describes compatible placement found
 *
 * Returns true if the placement is compatible
 */
extern bool ttm_bo_mem_compat(struct ttm_placement *placement,
			      struct ttm_mem_reg *mem,
			      uint32_t *new_flags);
 
/**
 * ttm_bo_validate
 *
 * @bo: The buffer object.
 * @placement: Proposed placement for the buffer object.
 * @interruptible: Sleep interruptible if sleeping.
 * @no_wait_gpu: Return immediately if the GPU is busy.
 *
 * Changes placement and caching policy of the buffer object
 * according proposed placement.
 * Returns
 * -EINVAL on invalid proposed placement.
 * -ENOMEM on out-of-memory condition.
 * -EBUSY if no_wait is true and buffer busy.
 * -ERESTARTSYS if interrupted by a signal.
 */
extern int ttm_bo_validate(struct ttm_buffer_object *bo,
				struct ttm_placement *placement,
				bool interruptible,
				bool no_wait_gpu);
 
/**
 * ttm_bo_unref
 *
 * @bo: The buffer object.
 *
 * Unreference and clear a pointer to a buffer object.
 */
extern void ttm_bo_unref(struct ttm_buffer_object **bo);
 
 
/**
 * ttm_bo_list_ref_sub
 *
 * @bo: The buffer object.
 * @count: The number of references with which to decrease @bo::list_kref;
 * @never_free: The refcount should not reach zero with this operation.
 *
 * Release @count lru list references to this buffer object.
 */
extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count,
				bool never_free);
 
/**
 * ttm_bo_add_to_lru
 *
 * @bo: The buffer object.
 *
 * Add this bo to the relevant mem type lru and, if it's backed by
 * system pages (ttms) to the swap list.
 * This function must be called with struct ttm_bo_global::lru_lock held, and
 * is typically called immediately prior to unreserving a bo.
 */
extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo);
 
/**
 * ttm_bo_del_from_lru
 *
 * @bo: The buffer object.
 *
 * Remove this bo from all lru lists used to lookup and reserve an object.
 * This function must be called with struct ttm_bo_global::lru_lock held,
 * and is usually called just immediately after the bo has been reserved to
 * avoid recursive reservation from lru lists.
 */
extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo);
 
 
/**
 * ttm_bo_lock_delayed_workqueue
 *
 * Prevent the delayed workqueue from running.
 * Returns
 * True if the workqueue was queued at the time
 */
extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev);
 
/**
 * ttm_bo_unlock_delayed_workqueue
 *
 * Allows the delayed workqueue to run.
 */
extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev,
					    int resched);
 
/**
 * ttm_bo_synccpu_write_grab
 *
 * @bo: The buffer object:
 * @no_wait: Return immediately if buffer is busy.
 *
 * Synchronizes a buffer object for CPU RW access. This means
 * command submission that affects the buffer will return -EBUSY
 * until ttm_bo_synccpu_write_release is called.
 *
 * Returns
 * -EBUSY if the buffer is busy and no_wait is true.
 * -ERESTARTSYS if interrupted by a signal.
 */
extern int
ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
 
/**
 * ttm_bo_synccpu_write_release:
 *
 * @bo : The buffer object.
 *
 * Releases a synccpu lock.
 */
extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
 
/**
 * ttm_bo_acc_size
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @bo_size: size of the buffer object in byte.
 * @struct_size: size of the structure holding buffer object datas
 *
 * Returns size to account for a buffer object
 */
size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
		       unsigned long bo_size,
		       unsigned struct_size);
size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
			   unsigned long bo_size,
			   unsigned struct_size);
 
/**
 * ttm_bo_init
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @bo: Pointer to a ttm_buffer_object to be initialized.
 * @size: Requested size of buffer object.
 * @type: Requested type of buffer object.
 * @flags: Initial placement flags.
 * @page_alignment: Data alignment in pages.
 * @interruptible: If needing to sleep to wait for GPU resources,
 * sleep interruptible.
 * @persistent_swap_storage: Usually the swap storage is deleted for buffers
 * pinned in physical memory. If this behaviour is not desired, this member
 * holds a pointer to a persistent shmem object. Typically, this would
 * point to the shmem object backing a GEM object if TTM is used to back a
 * GEM user interface.
 * @acc_size: Accounted size for this object.
 * @resv: Pointer to a reservation_object, or NULL to let ttm allocate one.
 * @destroy: Destroy function. Use NULL for kfree().
 *
 * This function initializes a pre-allocated struct ttm_buffer_object.
 * As this object may be part of a larger structure, this function,
 * together with the @destroy function,
 * enables driver-specific objects derived from a ttm_buffer_object.
 * On successful return, the object kref and list_kref are set to 1.
 * If a failure occurs, the function will call the @destroy function, or
 * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is
 * illegal and will likely cause memory corruption.
 *
 * Returns
 * -ENOMEM: Out of memory.
 * -EINVAL: Invalid placement flags.
 * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.
 */
 
extern int ttm_bo_init(struct ttm_bo_device *bdev,
			struct ttm_buffer_object *bo,
			unsigned long size,
			enum ttm_bo_type type,
			struct ttm_placement *placement,
			uint32_t page_alignment,
			bool interrubtible,
			struct file *persistent_swap_storage,
			size_t acc_size,
			struct sg_table *sg,
			struct reservation_object *resv,
			void (*destroy) (struct ttm_buffer_object *));
 
/**
 * ttm_bo_create
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @size: Requested size of buffer object.
 * @type: Requested type of buffer object.
 * @placement: Initial placement.
 * @page_alignment: Data alignment in pages.
 * @interruptible: If needing to sleep while waiting for GPU resources,
 * sleep interruptible.
 * @persistent_swap_storage: Usually the swap storage is deleted for buffers
 * pinned in physical memory. If this behaviour is not desired, this member
 * holds a pointer to a persistent shmem object. Typically, this would
 * point to the shmem object backing a GEM object if TTM is used to back a
 * GEM user interface.
 * @p_bo: On successful completion *p_bo points to the created object.
 *
 * This function allocates a ttm_buffer_object, and then calls ttm_bo_init
 * on that object. The destroy function is set to kfree().
 * Returns
 * -ENOMEM: Out of memory.
 * -EINVAL: Invalid placement flags.
 * -ERESTARTSYS: Interrupted by signal while waiting for resources.
 */
 
extern int ttm_bo_create(struct ttm_bo_device *bdev,
				unsigned long size,
				enum ttm_bo_type type,
				struct ttm_placement *placement,
				uint32_t page_alignment,
				bool interruptible,
				struct file *persistent_swap_storage,
				struct ttm_buffer_object **p_bo);
 
/**
 * ttm_bo_init_mm
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @mem_type: The memory type.
 * @p_size: size managed area in pages.
 *
 * Initialize a manager for a given memory type.
 * Note: if part of driver firstopen, it must be protected from a
 * potentially racing lastclose.
 * Returns:
 * -EINVAL: invalid size or memory type.
 * -ENOMEM: Not enough memory.
 * May also return driver-specified errors.
 */
 
extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
				unsigned long p_size);
/**
 * ttm_bo_clean_mm
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @mem_type: The memory type.
 *
 * Take down a manager for a given memory type after first walking
 * the LRU list to evict any buffers left alive.
 *
 * Normally, this function is part of lastclose() or unload(), and at that
 * point there shouldn't be any buffers left created by user-space, since
 * there should've been removed by the file descriptor release() method.
 * However, before this function is run, make sure to signal all sync objects,
 * and verify that the delayed delete queue is empty. The driver must also
 * make sure that there are no NO_EVICT buffers present in this memory type
 * when the call is made.
 *
 * If this function is part of a VT switch, the caller must make sure that
 * there are no appications currently validating buffers before this
 * function is called. The caller can do that by first taking the
 * struct ttm_bo_device::ttm_lock in write mode.
 *
 * Returns:
 * -EINVAL: invalid or uninitialized memory type.
 * -EBUSY: There are still buffers left in this memory type.
 */
 
extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
 
/**
 * ttm_bo_evict_mm
 *
 * @bdev: Pointer to a ttm_bo_device struct.
 * @mem_type: The memory type.
 *
 * Evicts all buffers on the lru list of the memory type.
 * This is normally part of a VT switch or an
 * out-of-memory-space-due-to-fragmentation handler.
 * The caller must make sure that there are no other processes
 * currently validating buffers, and can do that by taking the
 * struct ttm_bo_device::ttm_lock in write mode.
 *
 * Returns:
 * -EINVAL: Invalid or uninitialized memory type.
 * -ERESTARTSYS: The call was interrupted by a signal while waiting to
 * evict a buffer.
 */
 
extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
 
/**
 * ttm_kmap_obj_virtual
 *
 * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap.
 * @is_iomem: Pointer to an integer that on return indicates 1 if the
 * virtual map is io memory, 0 if normal memory.
 *
 * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap.
 * If *is_iomem is 1 on return, the virtual address points to an io memory area,
 * that should strictly be accessed by the iowriteXX() and similar functions.
 */
 
static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map,
					 bool *is_iomem)
{
	*is_iomem = !!(map->bo_kmap_type & TTM_BO_MAP_IOMEM_MASK);
	return map->virtual;
}
 
/**
 * ttm_bo_kmap
 *
 * @bo: The buffer object.
 * @start_page: The first page to map.
 * @num_pages: Number of pages to map.
 * @map: pointer to a struct ttm_bo_kmap_obj representing the map.
 *
 * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the
 * data in the buffer object. The ttm_kmap_obj_virtual function can then be
 * used to obtain a virtual address to the data.
 *
 * Returns
 * -ENOMEM: Out of memory.
 * -EINVAL: Invalid range.
 */
 
extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
		       unsigned long num_pages, struct ttm_bo_kmap_obj *map);
 
/**
 * ttm_bo_kunmap
 *
 * @map: Object describing the map to unmap.
 *
 * Unmaps a kernel map set up by ttm_bo_kmap.
 */
 
extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
 
/**
 * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
 *
 * @vma:       vma as input from the fbdev mmap method.
 * @bo:        The bo backing the address space. The address space will
 * have the same size as the bo, and start at offset 0.
 *
 * This function is intended to be called by the fbdev mmap method
 * if the fbdev address space is to be backed by a bo.
 */
 
extern int ttm_fbdev_mmap(struct vm_area_struct *vma,
			  struct ttm_buffer_object *bo);
 
/**
 * ttm_bo_mmap - mmap out of the ttm device address space.
 *
 * @filp:      filp as input from the mmap method.
 * @vma:       vma as input from the mmap method.
 * @bdev:      Pointer to the ttm_bo_device with the address space manager.
 *
 * This function is intended to be called by the device mmap method.
 * if the device address space is to be backed by the bo manager.
 */
 
extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
		       struct ttm_bo_device *bdev);
 
/**
 * ttm_bo_io
 *
 * @bdev:      Pointer to the struct ttm_bo_device.
 * @filp:      Pointer to the struct file attempting to read / write.
 * @wbuf:      User-space pointer to address of buffer to write. NULL on read.
 * @rbuf:      User-space pointer to address of buffer to read into.
 * Null on write.
 * @count:     Number of bytes to read / write.
 * @f_pos:     Pointer to current file position.
 * @write:     1 for read, 0 for write.
 *
 * This function implements read / write into ttm buffer objects, and is
 * intended to
 * be called from the fops::read and fops::write method.
 * Returns:
 * See man (2) write, man(2) read. In particular,
 * the function may return -ERESTARTSYS if
 * interrupted by a signal.
 */
 
extern ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp,
			 const char __user *wbuf, char __user *rbuf,
			 size_t count, loff_t *f_pos, bool write);
 
extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev);
extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo);
#endif

Rev 6082	Rev 6588
1	/**************************************************************************	1	/**************************************************************************
2	*	2	*
3	* Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA	3	* Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
4	* All Rights Reserved.	4	* All Rights Reserved.
5	*	5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a	6	* Permission is hereby granted, free of charge, to any person obtaining a
7	* copy of this software and associated documentation files (the	7	* copy of this software and associated documentation files (the
8	* "Software"), to deal in the Software without restriction, including	8	* "Software"), to deal in the Software without restriction, including
9	* without limitation the rights to use, copy, modify, merge, publish,	9	* without limitation the rights to use, copy, modify, merge, publish,
10	* distribute, sub license, and/or sell copies of the Software, and to	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	11	* permit persons to whom the Software is furnished to do so, subject to
12	* the following conditions:	12	* the following conditions:
13	*	13	*
14	* The above copyright notice and this permission notice (including the	14	* The above copyright notice and this permission notice (including the
15	* next paragraph) shall be included in all copies or substantial portions	15	* next paragraph) shall be included in all copies or substantial portions
16	* of the Software.	16	* of the Software.
17	*	17	*
18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	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,	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL	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,	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	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	23	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24	* USE OR OTHER DEALINGS IN THE SOFTWARE.	24	* USE OR OTHER DEALINGS IN THE SOFTWARE.
25	*	25	*
26	**************************************************************************/	26	**************************************************************************/
27	/*	27	/*
28	* Authors: Thomas Hellstrom	28	* Authors: Thomas Hellstrom
29	*/	29	*/
30		30
31	#ifndef _TTM_BO_API_H_	31	#ifndef _TTM_BO_API_H_
32	#define _TTM_BO_API_H_	32	#define _TTM_BO_API_H_
33		33
34	#include	34	#include
35	#include	35	#include
36	#include	36	#include
37	#include	37	#include
38	#include	38	#include
39	#include	39	#include
40	#include	40	#include
41	#include	41	#include
42	#include	42	#include
43		43
44	struct ttm_bo_device;	44	struct ttm_bo_device;
45		45
46	struct drm_mm_node;	46	struct drm_mm_node;
47		47
48	/**	48	/**
49	* struct ttm_place	49	* struct ttm_place
50	*	50	*
51	* @fpfn: first valid page frame number to put the object	51	* @fpfn: first valid page frame number to put the object
52	* @lpfn: last valid page frame number to put the object	52	* @lpfn: last valid page frame number to put the object
53	* @flags: memory domain and caching flags for the object	53	* @flags: memory domain and caching flags for the object
54	*	54	*
55	* Structure indicating a possible place to put an object.	55	* Structure indicating a possible place to put an object.
56	*/	56	*/
57	struct ttm_place {	57	struct ttm_place {
58	unsigned fpfn;	58	unsigned fpfn;
59	unsigned lpfn;	59	unsigned lpfn;
60	uint32_t flags;	60	uint32_t flags;
61	};	61	};
62		62
63	/**	63	/**
64	* struct ttm_placement	64	* struct ttm_placement
65	*	65	*
66	* @num_placement: number of preferred placements	66	* @num_placement: number of preferred placements
67	* @placement: preferred placements	67	* @placement: preferred placements
68	* @num_busy_placement: number of preferred placements when need to evict buffer	68	* @num_busy_placement: number of preferred placements when need to evict buffer
69	* @busy_placement: preferred placements when need to evict buffer	69	* @busy_placement: preferred placements when need to evict buffer
70	*	70	*
71	* Structure indicating the placement you request for an object.	71	* Structure indicating the placement you request for an object.
72	*/	72	*/
73	struct ttm_placement {	73	struct ttm_placement {
74	unsigned num_placement;	74	unsigned num_placement;
75	const struct ttm_place *placement;	75	const struct ttm_place *placement;
76	unsigned num_busy_placement;	76	unsigned num_busy_placement;
77	const struct ttm_place *busy_placement;	77	const struct ttm_place *busy_placement;
78	};	78	};
79		79
80	/**	80	/**
81	* struct ttm_bus_placement	81	* struct ttm_bus_placement
82	*	82	*
83	* @addr: mapped virtual address	83	* @addr: mapped virtual address
84	* @base: bus base address	84	* @base: bus base address
85	* @is_iomem: is this io memory ?	85	* @is_iomem: is this io memory ?
86	* @size: size in byte	86	* @size: size in byte
87	* @offset: offset from the base address	87	* @offset: offset from the base address
88	* @io_reserved_vm: The VM system has a refcount in @io_reserved_count	88	* @io_reserved_vm: The VM system has a refcount in @io_reserved_count
89	* @io_reserved_count: Refcounting the numbers of callers to ttm_mem_io_reserve	89	* @io_reserved_count: Refcounting the numbers of callers to ttm_mem_io_reserve
90	*	90	*
91	* Structure indicating the bus placement of an object.	91	* Structure indicating the bus placement of an object.
92	*/	92	*/
93	struct ttm_bus_placement {	93	struct ttm_bus_placement {
94	void *addr;	94	void *addr;
95	unsigned long base;	95	unsigned long base;
96	unsigned long size;	96	unsigned long size;
97	unsigned long offset;	97	unsigned long offset;
98	bool is_iomem;	98	bool is_iomem;
99	bool io_reserved_vm;	99	bool io_reserved_vm;
100	uint64_t io_reserved_count;	100	uint64_t io_reserved_count;
101	};	101	};
102		102
103		103
104	/**	104	/**
105	* struct ttm_mem_reg	105	* struct ttm_mem_reg
106	*	106	*
107	* @mm_node: Memory manager node.	107	* @mm_node: Memory manager node.
108	* @size: Requested size of memory region.	108	* @size: Requested size of memory region.
109	* @num_pages: Actual size of memory region in pages.	109	* @num_pages: Actual size of memory region in pages.
110	* @page_alignment: Page alignment.	110	* @page_alignment: Page alignment.
111	* @placement: Placement flags.	111	* @placement: Placement flags.
112	* @bus: Placement on io bus accessible to the CPU	112	* @bus: Placement on io bus accessible to the CPU
113	*	113	*
114	* Structure indicating the placement and space resources used by a	114	* Structure indicating the placement and space resources used by a
115	* buffer object.	115	* buffer object.
116	*/	116	*/
117		117
118	struct ttm_mem_reg {	118	struct ttm_mem_reg {
119	void *mm_node;	119	void *mm_node;
120	unsigned long start;	120	unsigned long start;
121	unsigned long size;	121	unsigned long size;
122	unsigned long num_pages;	122	unsigned long num_pages;
123	uint32_t page_alignment;	123	uint32_t page_alignment;
124	uint32_t mem_type;	124	uint32_t mem_type;
125	uint32_t placement;	125	uint32_t placement;
126	struct ttm_bus_placement bus;	126	struct ttm_bus_placement bus;
127	};	127	};
128		128
129	/**	129	/**
130	* enum ttm_bo_type	130	* enum ttm_bo_type
131	*	131	*
132	* @ttm_bo_type_device: These are 'normal' buffers that can	132	* @ttm_bo_type_device: These are 'normal' buffers that can
133	* be mmapped by user space. Each of these bos occupy a slot in the	133	* be mmapped by user space. Each of these bos occupy a slot in the
134	* device address space, that can be used for normal vm operations.	134	* device address space, that can be used for normal vm operations.
135	*	135	*
136	* @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,	136	* @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
137	* but they cannot be accessed from user-space. For kernel-only use.	137	* but they cannot be accessed from user-space. For kernel-only use.
138	*	138	*
139	* @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another	139	* @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another
140	* driver.	140	* driver.
141	*/	141	*/
142		142
143	enum ttm_bo_type {	143	enum ttm_bo_type {
144	ttm_bo_type_device,	144	ttm_bo_type_device,
145	ttm_bo_type_kernel,	145	ttm_bo_type_kernel,
146	ttm_bo_type_sg	146	ttm_bo_type_sg
147	};	147	};
148		148
149	struct ttm_tt;	149	struct ttm_tt;
150		150
151	/**	151	/**
152	* struct ttm_buffer_object	152	* struct ttm_buffer_object
153	*	153	*
154	* @bdev: Pointer to the buffer object device structure.	154	* @bdev: Pointer to the buffer object device structure.
155	* @type: The bo type.	155	* @type: The bo type.
156	* @destroy: Destruction function. If NULL, kfree is used.	156	* @destroy: Destruction function. If NULL, kfree is used.
157	* @num_pages: Actual number of pages.	157	* @num_pages: Actual number of pages.
158	* @acc_size: Accounted size for this object.	158	* @acc_size: Accounted size for this object.
159	* @kref: Reference count of this buffer object. When this refcount reaches	159	* @kref: Reference count of this buffer object. When this refcount reaches
160	* zero, the object is put on the delayed delete list.	160	* zero, the object is put on the delayed delete list.
161	* @list_kref: List reference count of this buffer object. This member is	161	* @list_kref: List reference count of this buffer object. This member is
162	* used to avoid destruction while the buffer object is still on a list.	162	* used to avoid destruction while the buffer object is still on a list.
163	* Lru lists may keep one refcount, the delayed delete list, and kref != 0	163	* Lru lists may keep one refcount, the delayed delete list, and kref != 0
164	* keeps one refcount. When this refcount reaches zero,	164	* keeps one refcount. When this refcount reaches zero,
165	* the object is destroyed.	165	* the object is destroyed.
166	* @mem: structure describing current placement.	166	* @mem: structure describing current placement.
167	* @persistent_swap_storage: Usually the swap storage is deleted for buffers	167	* @persistent_swap_storage: Usually the swap storage is deleted for buffers
168	* pinned in physical memory. If this behaviour is not desired, this member	168	* pinned in physical memory. If this behaviour is not desired, this member
169	* holds a pointer to a persistent shmem object.	169	* holds a pointer to a persistent shmem object.
170	* @ttm: TTM structure holding system pages.	170	* @ttm: TTM structure holding system pages.
171	* @evicted: Whether the object was evicted without user-space knowing.	171	* @evicted: Whether the object was evicted without user-space knowing.
172	* @cpu_writes: For synchronization. Number of cpu writers.	172	* @cpu_writes: For synchronization. Number of cpu writers.
173	* @lru: List head for the lru list.	173	* @lru: List head for the lru list.
174	* @ddestroy: List head for the delayed destroy list.	174	* @ddestroy: List head for the delayed destroy list.
175	* @swap: List head for swap LRU list.	175	* @swap: List head for swap LRU list.
176	* @priv_flags: Flags describing buffer object internal state.	176	* @priv_flags: Flags describing buffer object internal state.
177	* @vma_node: Address space manager node.	177	* @vma_node: Address space manager node.
178	* @offset: The current GPU offset, which can have different meanings	178	* @offset: The current GPU offset, which can have different meanings
179	* depending on the memory type. For SYSTEM type memory, it should be 0.	179	* depending on the memory type. For SYSTEM type memory, it should be 0.
180	* @cur_placement: Hint of current placement.	180	* @cur_placement: Hint of current placement.
181	* @wu_mutex: Wait unreserved mutex.	181	* @wu_mutex: Wait unreserved mutex.
182	*	182	*
183	* Base class for TTM buffer object, that deals with data placement and CPU	183	* Base class for TTM buffer object, that deals with data placement and CPU
184	* mappings. GPU mappings are really up to the driver, but for simpler GPUs	184	* mappings. GPU mappings are really up to the driver, but for simpler GPUs
185	* the driver can usually use the placement offset @offset directly as the	185	* the driver can usually use the placement offset @offset directly as the
186	* GPU virtual address. For drivers implementing multiple	186	* GPU virtual address. For drivers implementing multiple
187	* GPU memory manager contexts, the driver should manage the address space	187	* GPU memory manager contexts, the driver should manage the address space
188	* in these contexts separately and use these objects to get the correct	188	* in these contexts separately and use these objects to get the correct
189	* placement and caching for these GPU maps. This makes it possible to use	189	* placement and caching for these GPU maps. This makes it possible to use
190	* these objects for even quite elaborate memory management schemes.	190	* these objects for even quite elaborate memory management schemes.
191	* The destroy member, the API visibility of this object makes it possible	191	* The destroy member, the API visibility of this object makes it possible
192	* to derive driver specific types.	192	* to derive driver specific types.
193	*/	193	*/
194		194
195	struct ttm_buffer_object {	195	struct ttm_buffer_object {
196	/**	196	/**
197	* Members constant at init.	197	* Members constant at init.
198	*/	198	*/
199		199
200	struct ttm_bo_global *glob;	200	struct ttm_bo_global *glob;
201	struct ttm_bo_device *bdev;	201	struct ttm_bo_device *bdev;
202	enum ttm_bo_type type;	202	enum ttm_bo_type type;
203	void (destroy) (struct ttm_buffer_object );	203	void (destroy) (struct ttm_buffer_object );
204	unsigned long num_pages;	204	unsigned long num_pages;
205	size_t acc_size;	205	size_t acc_size;
206		206
207	/**	207	/**
208	* Members not needing protection.	208	* Members not needing protection.
209	*/	209	*/
210		210
211	struct kref kref;	211	struct kref kref;
212	struct kref list_kref;	212	struct kref list_kref;
213		213
214	/**	214	/**
215	* Members protected by the bo::resv::reserved lock.	215	* Members protected by the bo::resv::reserved lock.
216	*/	216	*/
217		217
218	struct ttm_mem_reg mem;	218	struct ttm_mem_reg mem;
219	struct file *persistent_swap_storage;	219	struct file *persistent_swap_storage;
220	struct ttm_tt *ttm;	220	struct ttm_tt *ttm;
221	bool evicted;	221	bool evicted;
222		222
223	/**	223	/**
224	* Members protected by the bo::reserved lock only when written to.	224	* Members protected by the bo::reserved lock only when written to.
225	*/	225	*/
226		226
227	atomic_t cpu_writers;	227	atomic_t cpu_writers;
228		228
229	/**	229	/**
230	* Members protected by the bdev::lru_lock.	230	* Members protected by the bdev::lru_lock.
231	*/	231	*/
232		232
233	struct list_head lru;	233	struct list_head lru;
234	struct list_head ddestroy;	234	struct list_head ddestroy;
235	struct list_head swap;	235	struct list_head swap;
236	struct list_head io_reserve_lru;	236	struct list_head io_reserve_lru;
237		237
238	/**	238	/**
239	* Members protected by a bo reservation.	239	* Members protected by a bo reservation.
240	*/	240	*/
241		241
242	unsigned long priv_flags;	242	unsigned long priv_flags;
243		243
244	struct drm_vma_offset_node vma_node;	244	struct drm_vma_offset_node vma_node;
245		245
246	/**	246	/**
247	* Special members that are protected by the reserve lock	247	* Special members that are protected by the reserve lock
248	* and the bo::lock when written to. Can be read with	248	* and the bo::lock when written to. Can be read with
249	* either of these locks held.	249	* either of these locks held.
250	*/	250	*/
251		251
252	uint64_t offset; /* GPU address space is independent of CPU word size */	252	uint64_t offset; /* GPU address space is independent of CPU word size */
253	uint32_t cur_placement;	253	uint32_t cur_placement;
254		254
255	struct sg_table *sg;	255	struct sg_table *sg;
256		256
257	struct reservation_object *resv;	257	struct reservation_object *resv;
258	struct reservation_object ttm_resv;	258	struct reservation_object ttm_resv;
259	struct mutex wu_mutex;	259	struct mutex wu_mutex;
260	};	260	};
261		261
262	/**	262	/**
263	* struct ttm_bo_kmap_obj	263	* struct ttm_bo_kmap_obj
264	*	264	*
265	* @virtual: The current kernel virtual address.	265	* @virtual: The current kernel virtual address.
266	* @page: The page when kmap'ing a single page.	266	* @page: The page when kmap'ing a single page.
267	* @bo_kmap_type: Type of bo_kmap.	267	* @bo_kmap_type: Type of bo_kmap.
268	*	268	*
269	* Object describing a kernel mapping. Since a TTM bo may be located	269	* Object describing a kernel mapping. Since a TTM bo may be located
270	* in various memory types with various caching policies, the	270	* in various memory types with various caching policies, the
271	* mapping can either be an ioremap, a vmap, a kmap or part of a	271	* mapping can either be an ioremap, a vmap, a kmap or part of a
272	* premapped region.	272	* premapped region.
273	*/	273	*/
274		274
275	#define TTM_BO_MAP_IOMEM_MASK 0x80	275	#define TTM_BO_MAP_IOMEM_MASK 0x80
276	struct ttm_bo_kmap_obj {	276	struct ttm_bo_kmap_obj {
277	void *virtual;	277	void *virtual;
278	struct page *page;	278	struct page *page;
279	enum {	279	enum {
280	ttm_bo_map_iomap = 1 \| TTM_BO_MAP_IOMEM_MASK,	280	ttm_bo_map_iomap = 1 \| TTM_BO_MAP_IOMEM_MASK,
281	ttm_bo_map_vmap = 2,	281	ttm_bo_map_vmap = 2,
282	ttm_bo_map_kmap = 3,	282	ttm_bo_map_kmap = 3,
283	ttm_bo_map_premapped = 4 \| TTM_BO_MAP_IOMEM_MASK,	283	ttm_bo_map_premapped = 4 \| TTM_BO_MAP_IOMEM_MASK,
284	} bo_kmap_type;	284	} bo_kmap_type;
285	struct ttm_buffer_object *bo;	285	struct ttm_buffer_object *bo;
286	};	286	};
287		287
288	/**	288	/**
289	* ttm_bo_reference - reference a struct ttm_buffer_object	289	* ttm_bo_reference - reference a struct ttm_buffer_object
290	*	290	*
291	* @bo: The buffer object.	291	* @bo: The buffer object.
292	*	292	*
293	* Returns a refcounted pointer to a buffer object.	293	* Returns a refcounted pointer to a buffer object.
294	*/	294	*/
295		295
296	static inline struct ttm_buffer_object *	296	static inline struct ttm_buffer_object *
297	ttm_bo_reference(struct ttm_buffer_object *bo)	297	ttm_bo_reference(struct ttm_buffer_object *bo)
298	{	298	{
299	kref_get(&bo->kref);	299	kref_get(&bo->kref);
300	return bo;	300	return bo;
301	}	301	}
302		302
303	/**	303	/**
304	* ttm_bo_wait - wait for buffer idle.	304	* ttm_bo_wait - wait for buffer idle.
305	*	305	*
306	* @bo: The buffer object.	306	* @bo: The buffer object.
307	* @interruptible: Use interruptible wait.	307	* @interruptible: Use interruptible wait.
308	* @no_wait: Return immediately if buffer is busy.	308	* @no_wait: Return immediately if buffer is busy.
309	*	309	*
310	* This function must be called with the bo::mutex held, and makes	310	* This function must be called with the bo::mutex held, and makes
311	* sure any previous rendering to the buffer is completed.	311	* sure any previous rendering to the buffer is completed.
312	* Note: It might be necessary to block validations before the	312	* Note: It might be necessary to block validations before the
313	* wait by reserving the buffer.	313	* wait by reserving the buffer.
314	* Returns -EBUSY if no_wait is true and the buffer is busy.	314	* Returns -EBUSY if no_wait is true and the buffer is busy.
315	* Returns -ERESTARTSYS if interrupted by a signal.	315	* Returns -ERESTARTSYS if interrupted by a signal.
316	*/	316	*/
317	extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,	317	extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
318	bool interruptible, bool no_wait);	318	bool interruptible, bool no_wait);
-		319
-		320	/**
-		321	* ttm_bo_mem_compat - Check if proposed placement is compatible with a bo
-		322	*
-		323	* @placement: Return immediately if buffer is busy.
-		324	* @mem: The struct ttm_mem_reg indicating the region where the bo resides
-		325	* @new_flags: Describes compatible placement found
-		326	*
-		327	* Returns true if the placement is compatible
-		328	*/
-		329	extern bool ttm_bo_mem_compat(struct ttm_placement *placement,
-		330	struct ttm_mem_reg *mem,
-		331	uint32_t *new_flags);
-		332
319	/**	333	/**
320	* ttm_bo_validate	334	* ttm_bo_validate
321	*	335	*
322	* @bo: The buffer object.	336	* @bo: The buffer object.
323	* @placement: Proposed placement for the buffer object.	337	* @placement: Proposed placement for the buffer object.
324	* @interruptible: Sleep interruptible if sleeping.	338	* @interruptible: Sleep interruptible if sleeping.
325	* @no_wait_gpu: Return immediately if the GPU is busy.	339	* @no_wait_gpu: Return immediately if the GPU is busy.
326	*	340	*
327	* Changes placement and caching policy of the buffer object	341	* Changes placement and caching policy of the buffer object
328	* according proposed placement.	342	* according proposed placement.
329	* Returns	343	* Returns
330	* -EINVAL on invalid proposed placement.	344	* -EINVAL on invalid proposed placement.
331	* -ENOMEM on out-of-memory condition.	345	* -ENOMEM on out-of-memory condition.
332	* -EBUSY if no_wait is true and buffer busy.	346	* -EBUSY if no_wait is true and buffer busy.
333	* -ERESTARTSYS if interrupted by a signal.	347	* -ERESTARTSYS if interrupted by a signal.
334	*/	348	*/
335	extern int ttm_bo_validate(struct ttm_buffer_object *bo,	349	extern int ttm_bo_validate(struct ttm_buffer_object *bo,
336	struct ttm_placement *placement,	350	struct ttm_placement *placement,
337	bool interruptible,	351	bool interruptible,
338	bool no_wait_gpu);	352	bool no_wait_gpu);
339		353
340	/**	354	/**
341	* ttm_bo_unref	355	* ttm_bo_unref
342	*	356	*
343	* @bo: The buffer object.	357	* @bo: The buffer object.
344	*	358	*
345	* Unreference and clear a pointer to a buffer object.	359	* Unreference and clear a pointer to a buffer object.
346	*/	360	*/
347	extern void ttm_bo_unref(struct ttm_buffer_object **bo);	361	extern void ttm_bo_unref(struct ttm_buffer_object **bo);
348		362
349		363
350	/**	364	/**
351	* ttm_bo_list_ref_sub	365	* ttm_bo_list_ref_sub
352	*	366	*
353	* @bo: The buffer object.	367	* @bo: The buffer object.
354	* @count: The number of references with which to decrease @bo::list_kref;	368	* @count: The number of references with which to decrease @bo::list_kref;
355	* @never_free: The refcount should not reach zero with this operation.	369	* @never_free: The refcount should not reach zero with this operation.
356	*	370	*
357	* Release @count lru list references to this buffer object.	371	* Release @count lru list references to this buffer object.
358	*/	372	*/
359	extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count,	373	extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count,
360	bool never_free);	374	bool never_free);
361		375
362	/**	376	/**
363	* ttm_bo_add_to_lru	377	* ttm_bo_add_to_lru
364	*	378	*
365	* @bo: The buffer object.	379	* @bo: The buffer object.
366	*	380	*
367	* Add this bo to the relevant mem type lru and, if it's backed by	381	* Add this bo to the relevant mem type lru and, if it's backed by
368	* system pages (ttms) to the swap list.	382	* system pages (ttms) to the swap list.
369	* This function must be called with struct ttm_bo_global::lru_lock held, and	383	* This function must be called with struct ttm_bo_global::lru_lock held, and
370	* is typically called immediately prior to unreserving a bo.	384	* is typically called immediately prior to unreserving a bo.
371	*/	385	*/
372	extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo);	386	extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo);
373		387
374	/**	388	/**
375	* ttm_bo_del_from_lru	389	* ttm_bo_del_from_lru
376	*	390	*
377	* @bo: The buffer object.	391	* @bo: The buffer object.
378	*	392	*
379	* Remove this bo from all lru lists used to lookup and reserve an object.	393	* Remove this bo from all lru lists used to lookup and reserve an object.
380	* This function must be called with struct ttm_bo_global::lru_lock held,	394	* This function must be called with struct ttm_bo_global::lru_lock held,
381	* and is usually called just immediately after the bo has been reserved to	395	* and is usually called just immediately after the bo has been reserved to
382	* avoid recursive reservation from lru lists.	396	* avoid recursive reservation from lru lists.
383	*/	397	*/
384	extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo);	398	extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo);
385		399
386		400
387	/**	401	/**
388	* ttm_bo_lock_delayed_workqueue	402	* ttm_bo_lock_delayed_workqueue
389	*	403	*
390	* Prevent the delayed workqueue from running.	404	* Prevent the delayed workqueue from running.
391	* Returns	405	* Returns
392	* True if the workqueue was queued at the time	406	* True if the workqueue was queued at the time
393	*/	407	*/
394	extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev);	408	extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev);
395		409
396	/**	410	/**
397	* ttm_bo_unlock_delayed_workqueue	411	* ttm_bo_unlock_delayed_workqueue
398	*	412	*
399	* Allows the delayed workqueue to run.	413	* Allows the delayed workqueue to run.
400	*/	414	*/
401	extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev,	415	extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev,
402	int resched);	416	int resched);
403		417
404	/**	418	/**
405	* ttm_bo_synccpu_write_grab	419	* ttm_bo_synccpu_write_grab
406	*	420	*
407	* @bo: The buffer object:	421	* @bo: The buffer object:
408	* @no_wait: Return immediately if buffer is busy.	422	* @no_wait: Return immediately if buffer is busy.
409	*	423	*
410	* Synchronizes a buffer object for CPU RW access. This means	424	* Synchronizes a buffer object for CPU RW access. This means
411	* command submission that affects the buffer will return -EBUSY	425	* command submission that affects the buffer will return -EBUSY
412	* until ttm_bo_synccpu_write_release is called.	426	* until ttm_bo_synccpu_write_release is called.
413	*	427	*
414	* Returns	428	* Returns
415	* -EBUSY if the buffer is busy and no_wait is true.	429	* -EBUSY if the buffer is busy and no_wait is true.
416	* -ERESTARTSYS if interrupted by a signal.	430	* -ERESTARTSYS if interrupted by a signal.
417	*/	431	*/
418	extern int	432	extern int
419	ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);	433	ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
420		434
421	/**	435	/**
422	* ttm_bo_synccpu_write_release:	436	* ttm_bo_synccpu_write_release:
423	*	437	*
424	* @bo : The buffer object.	438	* @bo : The buffer object.
425	*	439	*
426	* Releases a synccpu lock.	440	* Releases a synccpu lock.
427	*/	441	*/
428	extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);	442	extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
429		443
430	/**	444	/**
431	* ttm_bo_acc_size	445	* ttm_bo_acc_size
432	*	446	*
433	* @bdev: Pointer to a ttm_bo_device struct.	447	* @bdev: Pointer to a ttm_bo_device struct.
434	* @bo_size: size of the buffer object in byte.	448	* @bo_size: size of the buffer object in byte.
435	* @struct_size: size of the structure holding buffer object datas	449	* @struct_size: size of the structure holding buffer object datas
436	*	450	*
437	* Returns size to account for a buffer object	451	* Returns size to account for a buffer object
438	*/	452	*/
439	size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,	453	size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
440	unsigned long bo_size,	454	unsigned long bo_size,
441	unsigned struct_size);	455	unsigned struct_size);
442	size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,	456	size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
443	unsigned long bo_size,	457	unsigned long bo_size,
444	unsigned struct_size);	458	unsigned struct_size);
445		459
446	/**	460	/**
447	* ttm_bo_init	461	* ttm_bo_init
448	*	462	*
449	* @bdev: Pointer to a ttm_bo_device struct.	463	* @bdev: Pointer to a ttm_bo_device struct.
450	* @bo: Pointer to a ttm_buffer_object to be initialized.	464	* @bo: Pointer to a ttm_buffer_object to be initialized.
451	* @size: Requested size of buffer object.	465	* @size: Requested size of buffer object.
452	* @type: Requested type of buffer object.	466	* @type: Requested type of buffer object.
453	* @flags: Initial placement flags.	467	* @flags: Initial placement flags.
454	* @page_alignment: Data alignment in pages.	468	* @page_alignment: Data alignment in pages.
455	* @interruptible: If needing to sleep to wait for GPU resources,	469	* @interruptible: If needing to sleep to wait for GPU resources,
456	* sleep interruptible.	470	* sleep interruptible.
457	* @persistent_swap_storage: Usually the swap storage is deleted for buffers	471	* @persistent_swap_storage: Usually the swap storage is deleted for buffers
458	* pinned in physical memory. If this behaviour is not desired, this member	472	* pinned in physical memory. If this behaviour is not desired, this member
459	* holds a pointer to a persistent shmem object. Typically, this would	473	* holds a pointer to a persistent shmem object. Typically, this would
460	* point to the shmem object backing a GEM object if TTM is used to back a	474	* point to the shmem object backing a GEM object if TTM is used to back a
461	* GEM user interface.	475	* GEM user interface.
462	* @acc_size: Accounted size for this object.	476	* @acc_size: Accounted size for this object.
463	* @resv: Pointer to a reservation_object, or NULL to let ttm allocate one.	477	* @resv: Pointer to a reservation_object, or NULL to let ttm allocate one.
464	* @destroy: Destroy function. Use NULL for kfree().	478	* @destroy: Destroy function. Use NULL for kfree().
465	*	479	*
466	* This function initializes a pre-allocated struct ttm_buffer_object.	480	* This function initializes a pre-allocated struct ttm_buffer_object.
467	* As this object may be part of a larger structure, this function,	481	* As this object may be part of a larger structure, this function,
468	* together with the @destroy function,	482	* together with the @destroy function,
469	* enables driver-specific objects derived from a ttm_buffer_object.	483	* enables driver-specific objects derived from a ttm_buffer_object.
470	* On successful return, the object kref and list_kref are set to 1.	484	* On successful return, the object kref and list_kref are set to 1.
471	* If a failure occurs, the function will call the @destroy function, or	485	* If a failure occurs, the function will call the @destroy function, or
472	* kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is	486	* kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is
473	* illegal and will likely cause memory corruption.	487	* illegal and will likely cause memory corruption.
474	*	488	*
475	* Returns	489	* Returns
476	* -ENOMEM: Out of memory.	490	* -ENOMEM: Out of memory.
477	* -EINVAL: Invalid placement flags.	491	* -EINVAL: Invalid placement flags.
478	* -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.	492	* -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.
479	*/	493	*/
480		494
481	extern int ttm_bo_init(struct ttm_bo_device *bdev,	495	extern int ttm_bo_init(struct ttm_bo_device *bdev,
482	struct ttm_buffer_object *bo,	496	struct ttm_buffer_object *bo,
483	unsigned long size,	497	unsigned long size,
484	enum ttm_bo_type type,	498	enum ttm_bo_type type,
485	struct ttm_placement *placement,	499	struct ttm_placement *placement,
486	uint32_t page_alignment,	500	uint32_t page_alignment,

Subversion Repositories Kolibri OS

(root)/drivers/include/drm/ttm/ttm_bo_api.h – Rev 6082 → 6588