sys/dev/drm/include/drm/drm_mm.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  *
  27  **************************************************************************/
  28 /*
  29  * Authors:
  30  * Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
  31  */
  32
  33 #ifndef _DRM_MM_H_
  34 #define _DRM_MM_H_
  35
  36 /*
  37  * Generic range manager structs
  38  */
  39 #include <linux/bug.h>
  40 #include <linux/kernel.h>
  41 #include <linux/list.h>
  42 #include <linux/spinlock.h>
  43 #ifdef CONFIG_DEBUG_FS
  44 #include <linux/seq_file.h>
  45 #endif
  46
  47 enum drm_mm_search_flags {
  48         DRM_MM_SEARCH_DEFAULT =         0,
  49         DRM_MM_SEARCH_BEST =            1 << 0,
  50 };
  51
  52 struct drm_mm_node {
  53         struct list_head node_list;
  54         struct list_head hole_stack;
  55         unsigned hole_follows : 1;
  56         unsigned scanned_block : 1;
  57         unsigned scanned_prev_free : 1;
  58         unsigned scanned_next_free : 1;
  59         unsigned scanned_preceeds_hole : 1;
  60         unsigned allocated : 1;
  61         unsigned long color;
  62         unsigned long start;
  63         unsigned long size;
  64         struct drm_mm *mm;
  65 };
  66
  67 struct drm_mm {
  68         /* List of all memory nodes that immediately precede a free hole. */
  69         struct list_head hole_stack;
  70         /* head_node.node_list is the list of all memory nodes, ordered
  71          * according to the (increasing) start address of the memory node. */
  72         struct drm_mm_node head_node;
  73         struct list_head unused_nodes;
  74         int num_unused;
  75         struct spinlock unused_lock;
  76         unsigned int scan_check_range : 1;
  77         unsigned scan_alignment;
  78         unsigned long scan_color;
  79         unsigned long scan_size;
  80         unsigned long scan_hit_start;
  81         unsigned long scan_hit_end;
  82         unsigned scanned_blocks;
  83         unsigned long scan_start;
  84         unsigned long scan_end;
  85         struct drm_mm_node *prev_scanned_node;
  86
  87         void (*color_adjust)(struct drm_mm_node *node, unsigned long color,
  88                              unsigned long *start, unsigned long *end);
  89 };
  90
  91 static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
  92 {
  93         return node->allocated;
  94 }
  95
  96 static inline bool drm_mm_initialized(struct drm_mm *mm)
  97 {
  98         return mm->hole_stack.next;
  99 }
 100
 101 static inline unsigned long __drm_mm_hole_node_start(struct drm_mm_node *hole_node)
 102 {
 103         return hole_node->start + hole_node->size;
 104 }
 105
 106 static inline unsigned long drm_mm_hole_node_start(struct drm_mm_node *hole_node)
 107 {
 108         BUG_ON(!hole_node->hole_follows);
 109         return __drm_mm_hole_node_start(hole_node);
 110 }
 111
 112 static inline unsigned long __drm_mm_hole_node_end(struct drm_mm_node *hole_node)
 113 {
 114         return list_entry(hole_node->node_list.next,
 115                           struct drm_mm_node, node_list)->start;
 116 }
 117
 118 static inline unsigned long drm_mm_hole_node_end(struct drm_mm_node *hole_node)
 119 {
 120         return __drm_mm_hole_node_end(hole_node);
 121 }
 122
 123 #define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
 124                                                 &(mm)->head_node.node_list, \
 125                                                 node_list)
 126 #define drm_mm_for_each_scanned_node_reverse(entry, n, mm) \
 127         for (entry = (mm)->prev_scanned_node, \
 128                 next = entry ? list_entry(entry->node_list.next, \
 129                         struct drm_mm_node, node_list) : NULL; \
 130              entry != NULL; entry = next, \
 131                 next = entry ? list_entry(entry->node_list.next, \
 132                         struct drm_mm_node, node_list) : NULL) \
 133
 134 /* Note that we need to unroll list_for_each_entry in order to inline
 135  * setting hole_start and hole_end on each iteration and keep the
 136  * macro sane.
 137  */
 138 #define drm_mm_for_each_hole(entry, mm, hole_start, hole_end) \
 139         for (entry = list_entry((mm)->hole_stack.next, struct drm_mm_node, hole_stack); \
 140              &entry->hole_stack != &(mm)->hole_stack ? \
 141              hole_start = drm_mm_hole_node_start(entry), \
 142              hole_end = drm_mm_hole_node_end(entry), \
 143              1 : 0; \
 144              entry = list_entry(entry->hole_stack.next, struct drm_mm_node, hole_stack))
 145
 146 /*
 147  * Basic range manager support (drm_mm.c)
 148  */
 149 extern int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node);
 150 extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node,
 151                                                     unsigned long size,
 152                                                     unsigned alignment,
 153                                                     unsigned long color,
 154                                                     int atomic);
 155 extern struct drm_mm_node *drm_mm_get_block_range_generic(
 156                                                 struct drm_mm_node *node,
 157                                                 unsigned long size,
 158                                                 unsigned alignment,
 159                                                 unsigned long color,
 160                                                 unsigned long start,
 161                                                 unsigned long end,
 162                                                 int atomic);
 163
 164 static inline struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent,
 165                                                    unsigned long size,
 166                                                    unsigned alignment)
 167 {
 168         return drm_mm_get_block_generic(parent, size, alignment, 0, 0);
 169 }
 170 static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent,
 171                                                           unsigned long size,
 172                                                           unsigned alignment)
 173 {
 174         return drm_mm_get_block_generic(parent, size, alignment, 0, 1);
 175 }
 176 static inline struct drm_mm_node *drm_mm_get_block_range(
 177                                                 struct drm_mm_node *parent,
 178                                                 unsigned long size,
 179                                                 unsigned alignment,
 180                                                 unsigned long start,
 181                                                 unsigned long end)
 182 {
 183         return drm_mm_get_block_range_generic(parent, size, alignment, 0,
 184                                               start, end, 0);
 185 }
 186 static inline struct drm_mm_node *drm_mm_get_block_atomic_range(
 187                                                 struct drm_mm_node *parent,
 188                                                 unsigned long size,
 189                                                 unsigned alignment,
 190                                                 unsigned long start,
 191                                                 unsigned long end)
 192 {
 193         return drm_mm_get_block_range_generic(parent, size, alignment, 0,
 194                                                 start, end, 1);
 195 }
 196
 197 extern int drm_mm_insert_node_generic(struct drm_mm *mm,
 198                                       struct drm_mm_node *node,
 199                                       unsigned long size,
 200                                       unsigned alignment,
 201                                       unsigned long color,
 202                                       enum drm_mm_search_flags flags);
 203 static inline int drm_mm_insert_node(struct drm_mm *mm,
 204                                      struct drm_mm_node *node,
 205                                      unsigned long size,
 206                                      unsigned alignment,
 207                                      enum drm_mm_search_flags flags)
 208 {
 209         return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags);
 210 }
 211
 212 extern int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
 213                                        struct drm_mm_node *node,
 214                                        unsigned long size,
 215                                        unsigned alignment,
 216                                        unsigned long color,
 217                                        unsigned long start,
 218                                        unsigned long end,
 219                                        enum drm_mm_search_flags flags);
 220 static inline int drm_mm_insert_node_in_range(struct drm_mm *mm,
 221                                               struct drm_mm_node *node,
 222                                               unsigned long size,
 223                                               unsigned alignment,
 224                                               unsigned long start,
 225                                               unsigned long end,
 226                                               enum drm_mm_search_flags flags)
 227 {
 228         return drm_mm_insert_node_in_range_generic(mm, node, size, alignment,
 229                                                    0, start, end, flags);
 230 }
 231
 232 extern void drm_mm_put_block(struct drm_mm_node *cur);
 233 extern void drm_mm_remove_node(struct drm_mm_node *node);
 234 extern void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new);
 235 extern struct drm_mm_node *drm_mm_search_free_generic(const struct drm_mm *mm,
 236                                                       unsigned long size,
 237                                                       unsigned alignment,
 238                                                       unsigned long color,
 239                                                       enum drm_mm_search_flags flags);
 240 extern struct drm_mm_node *drm_mm_search_free_in_range_generic(
 241                                                 const struct drm_mm *mm,
 242                                                 unsigned long size,
 243                                                 unsigned alignment,
 244                                                 unsigned long color,
 245                                                 unsigned long start,
 246                                                 unsigned long end,
 247                                                 enum drm_mm_search_flags flags);
 248 static inline struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
 249                                                      unsigned long size,
 250                                                      unsigned alignment,
 251                                                      enum drm_mm_search_flags flags)
 252 {
 253         return drm_mm_search_free_generic(mm,size, alignment, 0, flags);
 254 }
 255 static inline  struct drm_mm_node *drm_mm_search_free_in_range(
 256                                                 const struct drm_mm *mm,
 257                                                 unsigned long size,
 258                                                 unsigned alignment,
 259                                                 unsigned long start,
 260                                                 unsigned long end,
 261                                                 enum drm_mm_search_flags flags)
 262 {
 263         return drm_mm_search_free_in_range_generic(mm, size, alignment, 0,
 264                                                    start, end, flags);
 265 }
 266
 267 extern void drm_mm_init(struct drm_mm *mm,
 268                         unsigned long start,
 269                         unsigned long size);
 270 extern void drm_mm_takedown(struct drm_mm *mm);
 271 extern int drm_mm_clean(struct drm_mm *mm);
 272 extern int drm_mm_pre_get(struct drm_mm *mm);
 273
 274 static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
 275 {
 276         return block->mm;
 277 }
 278
 279 void drm_mm_init_scan(struct drm_mm *mm,
 280                       unsigned long size,
 281                       unsigned alignment,
 282                       unsigned long color);
 283 void drm_mm_init_scan_with_range(struct drm_mm *mm,
 284                                  unsigned long size,
 285                                  unsigned alignment,
 286                                  unsigned long color,
 287                                  unsigned long start,
 288                                  unsigned long end);
 289 int drm_mm_scan_add_block(struct drm_mm_node *node);
 290 int drm_mm_scan_remove_block(struct drm_mm_node *node);
 291
 292 extern void drm_mm_debug_table(struct drm_mm *mm, const char *prefix);
 293 #ifdef CONFIG_DEBUG_FS
 294 int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm);
 295 #endif
 296
 297 #endif