components/openindiana/drm/drm/sys/drm/drm_mm.h

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