Subversion Repositories Kolibri OS

//#include 

//#include 

//#include 

/*

 * 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;

     * struct ttm_bo_driver member create_ttm_backend_entry

     *

    /**

    /**

     *

     * @bo: the buffer object to be evicted

     *

     * finished, they'll end up in bo->mem.flags

     */

    /**

     * struct ttm_bo_driver member move:

     *

     * @bo: the buffer to move

     * @evict: whether this motion is evicting the buffer from

     * the graphics address space

     * @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.

     * 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;

    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

     */

    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;