| 0,0 → 1,355 |
|---|
| /* |
| * Copyright 2008 Advanced Micro Devices, Inc. |
| * Copyright 2008 Red Hat Inc. |
| * Copyright 2009 Jerome Glisse. |
| * |
| * 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, sublicense, |
| * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 |
| * Alex Deucher |
| * Jerome Glisse |
| */ |
| #ifndef __RADEON_OBJECT_H__ |
| #define __RADEON_OBJECT_H__ |
| |
| //#include <ttm/ttm_bo_api.h> |
| //#include <ttm/ttm_bo_driver.h> |
| //#include <ttm/ttm_placement.h> |
| //#include <ttm/ttm_module.h> |
| |
| /* |
| * TTM. |
| */ |
| //struct radeon_mman { |
| // struct ttm_global_reference mem_global_ref; |
| // bool mem_global_referenced; |
| // struct ttm_bo_device bdev; |
| //}; |
| |
| |
| #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; |
| }; |
| |
| |
| #endif |