35,322 → 35,14 |
#include "radeon_drm.h" |
#include "radeon.h" |
#include <drm_mm.h> |
#include "radeon_object.h" |
|
int radeon_gart_bind(struct radeon_device *rdev, unsigned offset, |
int pages, u32_t *pagelist); |
|
|
#define TTM_PL_SYSTEM 0 |
#define TTM_PL_TT 1 |
#define TTM_PL_VRAM 2 |
#define TTM_PL_PRIV0 3 |
#define TTM_PL_PRIV1 4 |
#define TTM_PL_PRIV2 5 |
#define TTM_PL_PRIV3 6 |
#define TTM_PL_PRIV4 7 |
#define TTM_PL_PRIV5 8 |
#define TTM_PL_SWAPPED 15 |
|
#define TTM_PL_FLAG_SYSTEM (1 << TTM_PL_SYSTEM) |
#define TTM_PL_FLAG_TT (1 << TTM_PL_TT) |
#define TTM_PL_FLAG_VRAM (1 << TTM_PL_VRAM) |
#define TTM_PL_FLAG_PRIV0 (1 << TTM_PL_PRIV0) |
#define TTM_PL_FLAG_PRIV1 (1 << TTM_PL_PRIV1) |
#define TTM_PL_FLAG_PRIV2 (1 << TTM_PL_PRIV2) |
#define TTM_PL_FLAG_PRIV3 (1 << TTM_PL_PRIV3) |
#define TTM_PL_FLAG_PRIV4 (1 << TTM_PL_PRIV4) |
#define TTM_PL_FLAG_PRIV5 (1 << TTM_PL_PRIV5) |
#define TTM_PL_FLAG_SWAPPED (1 << TTM_PL_SWAPPED) |
#define TTM_PL_MASK_MEM 0x0000FFFF |
|
|
struct ttm_mem_type_manager { |
|
/* |
* No protection. Constant from start. |
*/ |
|
bool has_type; |
bool use_type; |
uint32_t flags; |
unsigned long gpu_offset; |
unsigned long io_offset; |
unsigned long io_size; |
void *io_addr; |
uint64_t size; |
uint32_t available_caching; |
uint32_t default_caching; |
|
/* |
* Protected by the bdev->lru_lock. |
* TODO: Consider one lru_lock per ttm_mem_type_manager. |
* Plays ill with list removal, though. |
*/ |
|
struct drm_mm manager; |
struct list_head lru; |
}; |
|
struct ttm_bo_driver { |
const uint32_t *mem_type_prio; |
const uint32_t *mem_busy_prio; |
uint32_t num_mem_type_prio; |
uint32_t num_mem_busy_prio; |
|
/** |
* struct ttm_bo_driver member create_ttm_backend_entry |
* |
* @bdev: The buffer object device. |
* |
* Create a driver specific struct ttm_backend. |
*/ |
|
// struct ttm_backend *(*create_ttm_backend_entry)(struct ttm_bo_device *bdev); |
|
/** |
* struct ttm_bo_driver member invalidate_caches |
* |
* @bdev: the buffer object device. |
* @flags: new placement of the rebound buffer object. |
* |
* A previosly evicted buffer has been rebound in a |
* potentially new location. Tell the driver that it might |
* consider invalidating read (texture) caches on the next command |
* submission as a consequence. |
*/ |
|
// int (*invalidate_caches) (struct ttm_bo_device *bdev, uint32_t flags); |
// int (*init_mem_type) (struct ttm_bo_device *bdev, uint32_t type, |
// struct ttm_mem_type_manager *man); |
/** |
* struct ttm_bo_driver member evict_flags: |
* |
* @bo: the buffer object to be evicted |
* |
* Return the bo flags for a buffer which is not mapped to the hardware. |
* These will be placed in proposed_flags so that when the move is |
* finished, they'll end up in bo->mem.flags |
*/ |
|
// uint32_t(*evict_flags) (struct ttm_buffer_object *bo); |
/** |
* struct ttm_bo_driver member move: |
* |
* @bo: the buffer to move |
* @evict: whether this motion is evicting the buffer from |
* the graphics address space |
* @interruptible: Use interruptible sleeps if possible when sleeping. |
* @no_wait: whether this should give up and return -EBUSY |
* if this move would require sleeping |
* @new_mem: the new memory region receiving the buffer |
* |
* Move a buffer between two memory regions. |
*/ |
// int (*move) (struct ttm_buffer_object *bo, |
// bool evict, bool interruptible, |
// bool no_wait, struct ttm_mem_reg *new_mem); |
|
/** |
* struct ttm_bo_driver_member verify_access |
* |
* @bo: Pointer to a buffer object. |
* @filp: Pointer to a struct file trying to access the object. |
* |
* Called from the map / write / read methods to verify that the |
* caller is permitted to access the buffer object. |
* This member may be set to NULL, which will refuse this kind of |
* access for all buffer objects. |
* This function should return 0 if access is granted, -EPERM otherwise. |
*/ |
// int (*verify_access) (struct ttm_buffer_object *bo, |
// struct file *filp); |
|
/** |
* In case a driver writer dislikes the TTM fence objects, |
* the driver writer can replace those with sync objects of |
* his / her own. If it turns out that no driver writer is |
* using these. I suggest we remove these hooks and plug in |
* fences directly. The bo driver needs the following functionality: |
* See the corresponding functions in the fence object API |
* documentation. |
*/ |
|
// bool (*sync_obj_signaled) (void *sync_obj, void *sync_arg); |
// int (*sync_obj_wait) (void *sync_obj, void *sync_arg, |
// bool lazy, bool interruptible); |
// int (*sync_obj_flush) (void *sync_obj, void *sync_arg); |
// void (*sync_obj_unref) (void **sync_obj); |
// void *(*sync_obj_ref) (void *sync_obj); |
}; |
|
#define TTM_NUM_MEM_TYPES 8 |
|
|
struct ttm_bo_device { |
|
/* |
* Constant after bo device init / atomic. |
*/ |
|
// struct ttm_mem_global *mem_glob; |
struct ttm_bo_driver *driver; |
// struct page *dummy_read_page; |
// struct ttm_mem_shrink shrink; |
|
size_t ttm_bo_extra_size; |
size_t ttm_bo_size; |
|
// rwlock_t vm_lock; |
/* |
* Protected by the vm lock. |
*/ |
struct ttm_mem_type_manager man[TTM_NUM_MEM_TYPES]; |
// struct rb_root addr_space_rb; |
struct drm_mm addr_space_mm; |
|
/* |
* Might want to change this to one lock per manager. |
*/ |
// spinlock_t lru_lock; |
/* |
* Protected by the lru lock. |
*/ |
struct list_head ddestroy; |
struct list_head swap_lru; |
|
/* |
* Protected by load / firstopen / lastclose /unload sync. |
*/ |
|
bool nice_mode; |
// struct address_space *dev_mapping; |
|
/* |
* Internal protection. |
*/ |
|
// struct delayed_work wq; |
}; |
|
struct ttm_mem_reg { |
struct drm_mm_node *mm_node; |
unsigned long size; |
unsigned long num_pages; |
uint32_t page_alignment; |
uint32_t mem_type; |
uint32_t placement; |
}; |
|
enum ttm_bo_type { |
ttm_bo_type_device, |
ttm_bo_type_user, |
ttm_bo_type_kernel |
}; |
|
struct ttm_buffer_object { |
/** |
* Members constant at init. |
*/ |
|
struct ttm_bo_device *bdev; |
unsigned long buffer_start; |
enum ttm_bo_type type; |
void (*destroy) (struct ttm_buffer_object *); |
unsigned long num_pages; |
uint64_t addr_space_offset; |
size_t acc_size; |
|
/** |
* Members not needing protection. |
*/ |
|
// struct kref kref; |
// struct kref list_kref; |
// wait_queue_head_t event_queue; |
// spinlock_t lock; |
|
/** |
* Members protected by the bo::reserved lock. |
*/ |
|
uint32_t proposed_placement; |
struct ttm_mem_reg mem; |
// struct file *persistant_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; |
uint32_t val_seq; |
bool seq_valid; |
|
/** |
* Members protected by the bdev::lru_lock |
* only when written to. |
*/ |
|
// atomic_t reserved; |
|
|
/** |
* Members protected by the bo::lock |
*/ |
|
void *sync_obj_arg; |
void *sync_obj; |
unsigned long priv_flags; |
|
/** |
* Members protected by the bdev::vm_lock |
*/ |
|
// struct rb_node vm_rb; |
struct drm_mm_node *vm_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. |
*/ |
|
unsigned long offset; |
uint32_t cur_placement; |
}; |
|
struct radeon_object |
{ |
struct ttm_buffer_object tobj; |
struct list_head list; |
struct radeon_device *rdev; |
// struct drm_gem_object *gobj; |
// struct ttm_bo_kmap_obj kmap; |
|
unsigned pin_count; |
uint64_t gpu_addr; |
void *kptr; |
bool is_iomem; |
|
struct drm_mm_node *mm_node; |
u32_t vm_addr; |
u32_t cpu_addr; |
u32_t flags; |
}; |
|
|
|
|
static struct drm_mm mm_gtt; |
static struct drm_mm mm_vram; |
|