include/drm/ttm/ttm_resource.h

   1 /*
   2  * Copyright 2020 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Christian König
  23  */
  24
  25 #ifndef _TTM_RESOURCE_H_
  26 #define _TTM_RESOURCE_H_
  27
  28 #include <linux/types.h>
  29 #include <linux/mutex.h>
  30 #include <linux/dma-fence.h>
  31 #include <drm/drm_print.h>
  32
  33 #define TTM_MAX_BO_PRIORITY     4U
  34
  35 struct ttm_bo_device;
  36 struct ttm_resource_manager;
  37 struct ttm_resource;
  38 struct ttm_place;
  39 struct ttm_buffer_object;
  40
  41 struct ttm_resource_manager_func {
  42         /**
  43          * struct ttm_resource_manager_func member alloc
  44          *
  45          * @man: Pointer to a memory type manager.
  46          * @bo: Pointer to the buffer object we're allocating space for.
  47          * @placement: Placement details.
  48          * @flags: Additional placement flags.
  49          * @mem: Pointer to a struct ttm_resource to be filled in.
  50          *
  51          * This function should allocate space in the memory type managed
  52          * by @man. Placement details if
  53          * applicable are given by @placement. If successful,
  54          * @mem::mm_node should be set to a non-null value, and
  55          * @mem::start should be set to a value identifying the beginning
  56          * of the range allocated, and the function should return zero.
  57          * If the memory region accommodate the buffer object, @mem::mm_node
  58          * should be set to NULL, and the function should return 0.
  59          * If a system error occurred, preventing the request to be fulfilled,
  60          * the function should return a negative error code.
  61          *
  62          * Note that @mem::mm_node will only be dereferenced by
  63          * struct ttm_resource_manager functions and optionally by the driver,
  64          * which has knowledge of the underlying type.
  65          *
  66          * This function may not be called from within atomic context, so
  67          * an implementation can and must use either a mutex or a spinlock to
  68          * protect any data structures managing the space.
  69          */
  70         int  (*alloc)(struct ttm_resource_manager *man,
  71                       struct ttm_buffer_object *bo,
  72                       const struct ttm_place *place,
  73                       struct ttm_resource *mem);
  74
  75         /**
  76          * struct ttm_resource_manager_func member free
  77          *
  78          * @man: Pointer to a memory type manager.
  79          * @mem: Pointer to a struct ttm_resource to be filled in.
  80          *
  81          * This function frees memory type resources previously allocated
  82          * and that are identified by @mem::mm_node and @mem::start. May not
  83          * be called from within atomic context.
  84          */
  85         void (*free)(struct ttm_resource_manager *man,
  86                      struct ttm_resource *mem);
  87
  88         /**
  89          * struct ttm_resource_manager_func member debug
  90          *
  91          * @man: Pointer to a memory type manager.
  92          * @printer: Prefix to be used in printout to identify the caller.
  93          *
  94          * This function is called to print out the state of the memory
  95          * type manager to aid debugging of out-of-memory conditions.
  96          * It may not be called from within atomic context.
  97          */
  98         void (*debug)(struct ttm_resource_manager *man,
  99                       struct drm_printer *printer);
 100 };
 101
 102 /**
 103  * struct ttm_resource_manager
 104  *
 105  * @use_type: The memory type is enabled.
 106  * @flags: TTM_MEMTYPE_XX flags identifying the traits of the memory
 107  * managed by this memory type.
 108  * @gpu_offset: If used, the GPU offset of the first managed page of
 109  * fixed memory or the first managed location in an aperture.
 110  * @size: Size of the managed region.
 111  * @available_caching: A mask of available caching types, TTM_PL_FLAG_XX,
 112  * as defined in ttm_placement_common.h
 113  * @default_caching: The default caching policy used for a buffer object
 114  * placed in this memory type if the user doesn't provide one.
 115  * @func: structure pointer implementing the range manager. See above
 116  * @move_lock: lock for move fence
 117  * static information. bdev::driver::io_mem_free is never used.
 118  * @lru: The lru list for this memory type.
 119  * @move: The fence of the last pipelined move operation.
 120  *
 121  * This structure is used to identify and manage memory types for a device.
 122  */
 123 struct ttm_resource_manager {
 124         /*
 125          * No protection. Constant from start.
 126          */
 127         bool use_type;
 128         bool use_tt;
 129         uint64_t size;
 130         uint32_t available_caching;
 131         uint32_t default_caching;
 132         const struct ttm_resource_manager_func *func;
 133         spinlock_t move_lock;
 134
 135         /*
 136          * Protected by the global->lru_lock.
 137          */
 138
 139         struct list_head lru[TTM_MAX_BO_PRIORITY];
 140
 141         /*
 142          * Protected by @move_lock.
 143          */
 144         struct dma_fence *move;
 145 };
 146
 147 /**
 148  * struct ttm_bus_placement
 149  *
 150  * @addr:               mapped virtual address
 151  * @offset:             physical addr
 152  * @is_iomem:           is this io memory ?
 153  *
 154  * Structure indicating the bus placement of an object.
 155  */
 156 struct ttm_bus_placement {
 157         void            *addr;
 158         phys_addr_t     offset;
 159         bool            is_iomem;
 160 };
 161
 162 /**
 163  * struct ttm_resource
 164  *
 165  * @mm_node: Memory manager node.
 166  * @size: Requested size of memory region.
 167  * @num_pages: Actual size of memory region in pages.
 168  * @page_alignment: Page alignment.
 169  * @placement: Placement flags.
 170  * @bus: Placement on io bus accessible to the CPU
 171  *
 172  * Structure indicating the placement and space resources used by a
 173  * buffer object.
 174  */
 175 struct ttm_resource {
 176         void *mm_node;
 177         unsigned long start;
 178         unsigned long size;
 179         unsigned long num_pages;
 180         uint32_t page_alignment;
 181         uint32_t mem_type;
 182         uint32_t placement;
 183         struct ttm_bus_placement bus;
 184 };
 185
 186 /**
 187  * ttm_resource_manager_set_used
 188  *
 189  * @man: A memory manager object.
 190  * @used: usage state to set.
 191  *
 192  * Set the manager in use flag. If disabled the manager is no longer
 193  * used for object placement.
 194  */
 195 static inline void
 196 ttm_resource_manager_set_used(struct ttm_resource_manager *man, bool used)
 197 {
 198         man->use_type = used;
 199 }
 200
 201 /**
 202  * ttm_resource_manager_used
 203  *
 204  * @man: Manager to get used state for
 205  *
 206  * Get the in use flag for a manager.
 207  * Returns:
 208  * true is used, false if not.
 209  */
 210 static inline bool ttm_resource_manager_used(struct ttm_resource_manager *man)
 211 {
 212         return man->use_type;
 213 }
 214
 215 /**
 216  * ttm_resource_manager_cleanup
 217  *
 218  * @man: A memory manager object.
 219  *
 220  * Cleanup the move fences from the memory manager object.
 221  */
 222 static inline void
 223 ttm_resource_manager_cleanup(struct ttm_resource_manager *man)
 224 {
 225         dma_fence_put(man->move);
 226         man->move = NULL;
 227 }
 228
 229 int ttm_resource_alloc(struct ttm_buffer_object *bo,
 230                        const struct ttm_place *place,
 231                        struct ttm_resource *res);
 232 void ttm_resource_free(struct ttm_buffer_object *bo, struct ttm_resource *res);
 233
 234 void ttm_resource_manager_init(struct ttm_resource_manager *man,
 235                                unsigned long p_size);
 236
 237 int ttm_resource_manager_force_list_clean(struct ttm_bo_device *bdev,
 238                                           struct ttm_resource_manager *man);
 239
 240 void ttm_resource_manager_debug(struct ttm_resource_manager *man,
 241                                 struct drm_printer *p);
 242
 243 #endif