/* SPDX-License-Identifier: MIT */ /* * Copyright © 2021 Intel Corporation */ #ifndef _XE_BO_H_ #define _XE_BO_H_ #include <drm/ttm/ttm_tt.h> #include "xe_bo_types.h" #include "xe_macros.h" #include "xe_vm_types.h" #include "xe_vm.h" #define XE_DEFAULT_GTT_SIZE_MB … #define XE_BO_FLAG_USER … /* The bits below need to be contiguous, or things break */ #define XE_BO_FLAG_SYSTEM … #define XE_BO_FLAG_VRAM0 … #define XE_BO_FLAG_VRAM1 … #define XE_BO_FLAG_VRAM_MASK … /* -- */ #define XE_BO_FLAG_STOLEN … #define XE_BO_FLAG_VRAM_IF_DGFX(tile) … #define XE_BO_FLAG_GGTT … #define XE_BO_FLAG_IGNORE_MIN_PAGE_SIZE … #define XE_BO_FLAG_PINNED … #define XE_BO_FLAG_NO_RESV_EVICT … #define XE_BO_FLAG_DEFER_BACKING … #define XE_BO_FLAG_SCANOUT … #define XE_BO_FLAG_FIXED_PLACEMENT … #define XE_BO_FLAG_PAGETABLE … #define XE_BO_FLAG_NEEDS_CPU_ACCESS … #define XE_BO_FLAG_NEEDS_UC … #define XE_BO_FLAG_NEEDS_64K … #define XE_BO_FLAG_NEEDS_2M … #define XE_BO_FLAG_GGTT_INVALIDATE … /* this one is trigger internally only */ #define XE_BO_FLAG_INTERNAL_TEST … #define XE_BO_FLAG_INTERNAL_64K … #define XE_PTE_SHIFT … #define XE_PAGE_SIZE … #define XE_PTE_MASK … #define XE_PDE_SHIFT … #define XE_PDES … #define XE_PDE_MASK … #define XE_64K_PTE_SHIFT … #define XE_64K_PAGE_SIZE … #define XE_64K_PTE_MASK … #define XE_64K_PDE_MASK … #define XE_PL_SYSTEM … #define XE_PL_TT … #define XE_PL_VRAM0 … #define XE_PL_VRAM1 … #define XE_PL_STOLEN … #define XE_BO_PROPS_INVALID … struct sg_table; struct xe_bo *xe_bo_alloc(void); void xe_bo_free(struct xe_bo *bo); struct xe_bo *___xe_bo_create_locked(struct xe_device *xe, struct xe_bo *bo, struct xe_tile *tile, struct dma_resv *resv, struct ttm_lru_bulk_move *bulk, size_t size, u16 cpu_caching, enum ttm_bo_type type, u32 flags); struct xe_bo * xe_bo_create_locked_range(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, u64 start, u64 end, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_bo_create_locked(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_bo_create(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_bo_create_user(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, u16 cpu_caching, u32 flags); struct xe_bo *xe_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_bo_create_pin_map_at(struct xe_device *xe, struct xe_tile *tile, struct xe_vm *vm, size_t size, u64 offset, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile, const void *data, size_t size, enum ttm_bo_type type, u32 flags); struct xe_bo *xe_managed_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile, size_t size, u32 flags); struct xe_bo *xe_managed_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile, const void *data, size_t size, u32 flags); int xe_managed_bo_reinit_in_vram(struct xe_device *xe, struct xe_tile *tile, struct xe_bo **src); int xe_bo_placement_for_flags(struct xe_device *xe, struct xe_bo *bo, u32 bo_flags); static inline struct xe_bo *ttm_to_xe_bo(const struct ttm_buffer_object *bo) { … } static inline struct xe_bo *gem_to_xe_bo(const struct drm_gem_object *obj) { … } #define xe_bo_device(bo) … static inline struct xe_bo *xe_bo_get(struct xe_bo *bo) { … } void xe_bo_put(struct xe_bo *bo); static inline void __xe_bo_unset_bulk_move(struct xe_bo *bo) { … } static inline void xe_bo_assert_held(struct xe_bo *bo) { … } int xe_bo_lock(struct xe_bo *bo, bool intr); void xe_bo_unlock(struct xe_bo *bo); static inline void xe_bo_unlock_vm_held(struct xe_bo *bo) { … } int xe_bo_pin_external(struct xe_bo *bo); int xe_bo_pin(struct xe_bo *bo); void xe_bo_unpin_external(struct xe_bo *bo); void xe_bo_unpin(struct xe_bo *bo); int xe_bo_validate(struct xe_bo *bo, struct xe_vm *vm, bool allow_res_evict); static inline bool xe_bo_is_pinned(struct xe_bo *bo) { … } static inline void xe_bo_unpin_map_no_vm(struct xe_bo *bo) { … } bool xe_bo_is_xe_bo(struct ttm_buffer_object *bo); dma_addr_t __xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size); dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size); static inline dma_addr_t xe_bo_main_addr(struct xe_bo *bo, size_t page_size) { … } static inline u32 xe_bo_ggtt_addr(struct xe_bo *bo) { … } int xe_bo_vmap(struct xe_bo *bo); void xe_bo_vunmap(struct xe_bo *bo); bool mem_type_is_vram(u32 mem_type); bool xe_bo_is_vram(struct xe_bo *bo); bool xe_bo_is_stolen(struct xe_bo *bo); bool xe_bo_is_stolen_devmem(struct xe_bo *bo); bool xe_bo_has_single_placement(struct xe_bo *bo); uint64_t vram_region_gpu_offset(struct ttm_resource *res); bool xe_bo_can_migrate(struct xe_bo *bo, u32 mem_type); int xe_bo_migrate(struct xe_bo *bo, u32 mem_type); int xe_bo_evict(struct xe_bo *bo, bool force_alloc); int xe_bo_evict_pinned(struct xe_bo *bo); int xe_bo_restore_pinned(struct xe_bo *bo); extern const struct ttm_device_funcs xe_ttm_funcs; extern const char *const xe_mem_type_to_name[]; int xe_gem_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file); int xe_gem_mmap_offset_ioctl(struct drm_device *dev, void *data, struct drm_file *file); void xe_bo_runtime_pm_release_mmap_offset(struct xe_bo *bo); int xe_bo_dumb_create(struct drm_file *file_priv, struct drm_device *dev, struct drm_mode_create_dumb *args); bool xe_bo_needs_ccs_pages(struct xe_bo *bo); static inline size_t xe_bo_ccs_pages_start(struct xe_bo *bo) { … } static inline bool xe_bo_has_pages(struct xe_bo *bo) { … } void __xe_bo_release_dummy(struct kref *kref); /** * xe_bo_put_deferred() - Put a buffer object with delayed final freeing * @bo: The bo to put. * @deferred: List to which to add the buffer object if we cannot put, or * NULL if the function is to put unconditionally. * * Since the final freeing of an object includes both sleeping and (!) * memory allocation in the dma_resv individualization, it's not ok * to put an object from atomic context nor from within a held lock * tainted by reclaim. In such situations we want to defer the final * freeing until we've exited the restricting context, or in the worst * case to a workqueue. * This function either puts the object if possible without the refcount * reaching zero, or adds it to the @deferred list if that was not possible. * The caller needs to follow up with a call to xe_bo_put_commit() to actually * put the bo iff this function returns true. It's safe to always * follow up with a call to xe_bo_put_commit(). * TODO: It's TTM that is the villain here. Perhaps TTM should add an * interface like this. * * Return: true if @bo was the first object put on the @freed list, * false otherwise. */ static inline bool xe_bo_put_deferred(struct xe_bo *bo, struct llist_head *deferred) { … } void xe_bo_put_commit(struct llist_head *deferred); struct sg_table *xe_bo_sg(struct xe_bo *bo); /* * xe_sg_segment_size() - Provides upper limit for sg segment size. * @dev: device pointer * * Returns the maximum segment size for the 'struct scatterlist' * elements. */ static inline unsigned int xe_sg_segment_size(struct device *dev) { … } #define i915_gem_object_flush_if_display(obj) … #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST) /** * xe_bo_is_mem_type - Whether the bo currently resides in the given * TTM memory type * @bo: The bo to check. * @mem_type: The TTM memory type. * * Return: true iff the bo resides in @mem_type, false otherwise. */ static inline bool xe_bo_is_mem_type(struct xe_bo *bo, u32 mem_type) { … } #endif #endif
Codebase Browser
linux