sys/dev/drm/drm_sman.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Bismarck., ND., 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  *
  27  * __FBSDID("$FreeBSD: src/sys/dev/drm/drm_sman.c,v 1.1 2010/01/31 14:25:29 rnoland Exp $");
  28  **************************************************************************/
  29
  30 /*
  31  * Simple memory manager interface that keeps track on allocate regions on a
  32  * per "owner" basis. All regions associated with an "owner" can be released
  33  * with a simple call. Typically if the "owner" exists. The owner is any
  34  * "unsigned long" identifier. Can typically be a pointer to a file private
  35  * struct or a context identifier.
  36  *
  37  * Authors:
  38  * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  39  */
  40
  41 #include "dev/drm/drmP.h"
  42 #include "dev/drm/drm_sman.h"
  43
  44 struct drm_owner_item {
  45         struct drm_hash_item owner_hash;
  46         struct list_head sman_list;
  47         struct list_head mem_blocks;
  48 };
  49
  50 void drm_sman_takedown(struct drm_sman * sman)
  51 {
  52         drm_ht_remove(&sman->user_hash_tab);
  53         drm_ht_remove(&sman->owner_hash_tab);
  54         if (sman->mm)
  55                 drm_free(sman->mm, sman->num_managers * sizeof(*sman->mm),
  56                     DRM_MEM_MM);
  57 }
  58
  59 int
  60 drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  61               unsigned int user_order, unsigned int owner_order)
  62 {
  63         int ret = 0;
  64
  65         sman->mm = (struct drm_sman_mm *) drm_calloc(num_managers,
  66             sizeof(*sman->mm), DRM_MEM_MM);
  67         if (!sman->mm) {
  68                 ret = -ENOMEM;
  69                 goto out;
  70         }
  71         sman->num_managers = num_managers;
  72         INIT_LIST_HEAD(&sman->owner_items);
  73         ret = drm_ht_create(&sman->owner_hash_tab, owner_order);
  74         if (ret)
  75                 goto out1;
  76         ret = drm_ht_create(&sman->user_hash_tab, user_order);
  77         if (!ret)
  78                 goto out;
  79
  80         drm_ht_remove(&sman->owner_hash_tab);
  81 out1:
  82         drm_free(sman->mm, num_managers * sizeof(*sman->mm), DRM_MEM_MM);
  83 out:
  84         return ret;
  85 }
  86
  87 static void *drm_sman_mm_allocate(void *private, unsigned long size,
  88                                   unsigned alignment)
  89 {
  90         struct drm_mm *mm = (struct drm_mm *) private;
  91         struct drm_mm_node *tmp;
  92
  93         tmp = drm_mm_search_free(mm, size, alignment, 1);
  94         if (!tmp) {
  95                 return NULL;
  96         }
  97         tmp = drm_mm_get_block(tmp, size, alignment);
  98         return tmp;
  99 }
 100
 101 static void drm_sman_mm_free(void *private, void *ref)
 102 {
 103         struct drm_mm_node *node = (struct drm_mm_node *) ref;
 104
 105         drm_mm_put_block(node);
 106 }
 107
 108 static void drm_sman_mm_destroy(void *private)
 109 {
 110         struct drm_mm *mm = (struct drm_mm *) private;
 111         drm_mm_takedown(mm);
 112         drm_free(mm, sizeof(*mm), DRM_MEM_MM);
 113 }
 114
 115 static unsigned long drm_sman_mm_offset(void *private, void *ref)
 116 {
 117         struct drm_mm_node *node = (struct drm_mm_node *) ref;
 118         return node->start;
 119 }
 120
 121 int
 122 drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
 123                    unsigned long start, unsigned long size)
 124 {
 125         struct drm_sman_mm *sman_mm;
 126         struct drm_mm *mm;
 127         int ret;
 128
 129         KASSERT(manager < sman->num_managers, ("Invalid manager"));
 130
 131         sman_mm = &sman->mm[manager];
 132         mm = malloc(sizeof(*mm), DRM_MEM_MM, M_WAITOK | M_ZERO);
 133         if (!mm) {
 134                 return -ENOMEM;
 135         }
 136         sman_mm->private = mm;
 137         ret = drm_mm_init(mm, start, size);
 138
 139         if (ret) {
 140                 drm_free(mm, sizeof(*mm), DRM_MEM_MM);
 141                 return ret;
 142         }
 143
 144         sman_mm->allocate = drm_sman_mm_allocate;
 145         sman_mm->free = drm_sman_mm_free;
 146         sman_mm->destroy = drm_sman_mm_destroy;
 147         sman_mm->offset = drm_sman_mm_offset;
 148
 149         return 0;
 150 }
 151
 152 int
 153 drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
 154                      struct drm_sman_mm * allocator)
 155 {
 156         KASSERT(manager < sman->num_managers, ("Invalid manager"));
 157         sman->mm[manager] = *allocator;
 158
 159         return 0;
 160 }
 161
 162 static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
 163                                                  unsigned long owner)
 164 {
 165         int ret;
 166         struct drm_hash_item *owner_hash_item;
 167         struct drm_owner_item *owner_item;
 168
 169         ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
 170         if (!ret) {
 171                 return drm_hash_entry(owner_hash_item, struct drm_owner_item,
 172                                       owner_hash);
 173         }
 174
 175         owner_item = malloc(sizeof(*owner_item), DRM_MEM_MM, M_WAITOK | M_ZERO);
 176         if (!owner_item)
 177                 goto out;
 178
 179         INIT_LIST_HEAD(&owner_item->mem_blocks);
 180         owner_item->owner_hash.key = owner;
 181         DRM_DEBUG("owner_item = %p, mem_blocks = %p\n", owner_item, &owner_item->mem_blocks);
 182         if (drm_ht_insert_item(&sman->owner_hash_tab, &owner_item->owner_hash))
 183                 goto out1;
 184
 185         list_add_tail(&owner_item->sman_list, &sman->owner_items);
 186         return owner_item;
 187
 188 out1:
 189         drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
 190 out:
 191         return NULL;
 192 }
 193
 194 struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int manager,
 195                                     unsigned long size, unsigned alignment,
 196                                     unsigned long owner)
 197 {
 198         void *tmp;
 199         struct drm_sman_mm *sman_mm;
 200         struct drm_owner_item *owner_item;
 201         struct drm_memblock_item *memblock;
 202
 203         KASSERT(manager < sman->num_managers, ("Invalid manager"));
 204
 205         sman_mm = &sman->mm[manager];
 206         tmp = sman_mm->allocate(sman_mm->private, size, alignment);
 207
 208         if (!tmp) {
 209                 return NULL;
 210         }
 211
 212         memblock = malloc(sizeof(*memblock), DRM_MEM_MM, M_WAITOK | M_ZERO);
 213         DRM_DEBUG("allocated mem_block %p\n", memblock);
 214         if (!memblock)
 215                 goto out;
 216
 217         memblock->mm_info = tmp;
 218         memblock->mm = sman_mm;
 219         memblock->sman = sman;
 220         INIT_LIST_HEAD(&memblock->owner_list);
 221
 222         if (drm_ht_just_insert_please
 223             (&sman->user_hash_tab, &memblock->user_hash,
 224              (unsigned long)memblock, 32, 0, 0))
 225                 goto out1;
 226
 227         owner_item = drm_sman_get_owner_item(sman, owner);
 228         if (!owner_item)
 229                 goto out2;
 230
 231         DRM_DEBUG("owner_item = %p, mem_blocks = %p\n", owner_item, &owner_item->mem_blocks);
 232         DRM_DEBUG("owner_list.prev = %p, mem_blocks.prev = %p\n", memblock->owner_list.prev, owner_item->mem_blocks.prev);
 233         DRM_DEBUG("owner_list.next = %p, mem_blocks.next = %p\n", memblock->owner_list.next, owner_item->mem_blocks.next);
 234         list_add_tail(&memblock->owner_list, &owner_item->mem_blocks);
 235
 236         DRM_DEBUG("Complete\n");
 237         return memblock;
 238
 239 out2:
 240         drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
 241 out1:
 242         drm_free(memblock, sizeof(*memblock), DRM_MEM_MM);
 243 out:
 244         sman_mm->free(sman_mm->private, tmp);
 245
 246         return NULL;
 247 }
 248
 249 static void drm_sman_free(struct drm_memblock_item *item)
 250 {
 251         struct drm_sman *sman = item->sman;
 252
 253         list_del(&item->owner_list);
 254         drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
 255         item->mm->free(item->mm->private, item->mm_info);
 256         drm_free(item, sizeof(*item), DRM_MEM_MM);
 257 }
 258
 259 int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
 260 {
 261         struct drm_hash_item *hash_item;
 262         struct drm_memblock_item *memblock_item;
 263
 264         if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
 265                 return -EINVAL;
 266
 267         memblock_item = drm_hash_entry(hash_item, struct drm_memblock_item,
 268                                        user_hash);
 269         drm_sman_free(memblock_item);
 270         return 0;
 271 }
 272
 273 static void drm_sman_remove_owner(struct drm_sman *sman,
 274                                   struct drm_owner_item *owner_item)
 275 {
 276         list_del(&owner_item->sman_list);
 277         drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
 278         drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
 279 }
 280
 281 int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
 282 {
 283
 284         struct drm_hash_item *hash_item;
 285         struct drm_owner_item *owner_item;
 286
 287         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
 288                 return -1;
 289         }
 290
 291         owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
 292         DRM_DEBUG("cleaning owner_item %p\n", owner_item);
 293         if (owner_item->mem_blocks.next == &owner_item->mem_blocks) {
 294                 drm_sman_remove_owner(sman, owner_item);
 295                 return -1;
 296         }
 297
 298         return 0;
 299 }
 300
 301 static void drm_sman_do_owner_cleanup(struct drm_sman *sman,
 302                                       struct drm_owner_item *owner_item)
 303 {
 304         struct drm_memblock_item *entry, *next;
 305
 306         list_for_each_entry_safe(entry, next, &owner_item->mem_blocks,
 307                                  owner_list) {
 308                 DRM_DEBUG("freeing mem_block %p\n", entry);
 309                 drm_sman_free(entry);
 310         }
 311         drm_sman_remove_owner(sman, owner_item);
 312 }
 313
 314 void drm_sman_owner_cleanup(struct drm_sman *sman, unsigned long owner)
 315 {
 316
 317         struct drm_hash_item *hash_item;
 318         struct drm_owner_item *owner_item;
 319
 320         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
 321
 322                 return;
 323         }
 324
 325         owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
 326         drm_sman_do_owner_cleanup(sman, owner_item);
 327 }
 328
 329 void drm_sman_cleanup(struct drm_sman *sman)
 330 {
 331         struct drm_owner_item *entry, *next;
 332         unsigned int i;
 333         struct drm_sman_mm *sman_mm;
 334
 335         DRM_DEBUG("sman = %p, owner_items = %p\n",
 336             sman, &sman->owner_items);
 337         list_for_each_entry_safe(entry, next, &sman->owner_items, sman_list) {
 338                 DRM_DEBUG("cleaning owner_item = %p\n", entry);
 339                 drm_sman_do_owner_cleanup(sman, entry);
 340         }
 341         if (sman->mm) {
 342                 for (i = 0; i < sman->num_managers; ++i) {
 343                         sman_mm = &sman->mm[i];
 344                         if (sman_mm->private) {
 345                                 sman_mm->destroy(sman_mm->private);
 346                                 sman_mm->private = NULL;
 347                         }
 348                 }
 349         }
 350 }