drivers/gpu/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  **************************************************************************/
  28 /*
  29  * Simple memory manager interface that keeps track on allocate regions on a
  30  * per "owner" basis. All regions associated with an "owner" can be released
  31  * with a simple call. Typically if the "owner" exists. The owner is any
  32  * "unsigned long" identifier. Can typically be a pointer to a file private
  33  * struct or a context identifier.
  34  *
  35  * Authors:
  36  * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  37  */
  38
  39 #include "drm_sman.h"
  40
  41 struct drm_owner_item {
  42         struct drm_hash_item owner_hash;
  43         struct list_head sman_list;
  44         struct list_head mem_blocks;
  45 };
  46
  47 void drm_sman_takedown(struct drm_sman * sman)
  48 {
  49         drm_ht_remove(&sman->user_hash_tab);
  50         drm_ht_remove(&sman->owner_hash_tab);
  51         kfree(sman->mm);
  52 }
  53
  54 EXPORT_SYMBOL(drm_sman_takedown);
  55
  56 int
  57 drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  58               unsigned int user_order, unsigned int owner_order)
  59 {
  60         int ret = 0;
  61
  62         sman->mm = kcalloc(num_managers, sizeof(*sman->mm), GFP_KERNEL);
  63         if (!sman->mm) {
  64                 ret = -ENOMEM;
  65                 goto out;
  66         }
  67         sman->num_managers = num_managers;
  68         INIT_LIST_HEAD(&sman->owner_items);
  69         ret = drm_ht_create(&sman->owner_hash_tab, owner_order);
  70         if (ret)
  71                 goto out1;
  72         ret = drm_ht_create(&sman->user_hash_tab, user_order);
  73         if (!ret)
  74                 goto out;
  75
  76         drm_ht_remove(&sman->owner_hash_tab);
  77 out1:
  78         kfree(sman->mm);
  79 out:
  80         return ret;
  81 }
  82
  83 EXPORT_SYMBOL(drm_sman_init);
  84
  85 static void *drm_sman_mm_allocate(void *private, unsigned long size,
  86                                   unsigned alignment)
  87 {
  88         struct drm_mm *mm = (struct drm_mm *) private;
  89         struct drm_mm_node *tmp;
  90
  91         tmp = drm_mm_search_free(mm, size, alignment, 1);
  92         if (!tmp) {
  93                 return NULL;
  94         }
  95         tmp = drm_mm_get_block(tmp, size, alignment);
  96         return tmp;
  97 }
  98
  99 static void drm_sman_mm_free(void *private, void *ref)
 100 {
 101         struct drm_mm_node *node = (struct drm_mm_node *) ref;
 102
 103         drm_mm_put_block(node);
 104 }
 105
 106 static void drm_sman_mm_destroy(void *private)
 107 {
 108         struct drm_mm *mm = (struct drm_mm *) private;
 109         drm_mm_takedown(mm);
 110         kfree(mm);
 111 }
 112
 113 static unsigned long drm_sman_mm_offset(void *private, void *ref)
 114 {
 115         struct drm_mm_node *node = (struct drm_mm_node *) ref;
 116         return node->start;
 117 }
 118
 119 int
 120 drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
 121                    unsigned long start, unsigned long size)
 122 {
 123         struct drm_sman_mm *sman_mm;
 124         struct drm_mm *mm;
 125         int ret;
 126
 127         BUG_ON(manager >= sman->num_managers);
 128
 129         sman_mm = &sman->mm[manager];
 130         mm = kzalloc(sizeof(*mm), GFP_KERNEL);
 131         if (!mm) {
 132                 return -ENOMEM;
 133         }
 134         sman_mm->private = mm;
 135         ret = drm_mm_init(mm, start, size);
 136
 137         if (ret) {
 138                 kfree(mm);
 139                 return ret;
 140         }
 141
 142         sman_mm->allocate = drm_sman_mm_allocate;
 143         sman_mm->free = drm_sman_mm_free;
 144         sman_mm->destroy = drm_sman_mm_destroy;
 145         sman_mm->offset = drm_sman_mm_offset;
 146
 147         return 0;
 148 }
 149
 150 EXPORT_SYMBOL(drm_sman_set_range);
 151
 152 int
 153 drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
 154                      struct drm_sman_mm * allocator)
 155 {
 156         BUG_ON(manager >= sman->num_managers);
 157         sman->mm[manager] = *allocator;
 158
 159         return 0;
 160 }
 161 EXPORT_SYMBOL(drm_sman_set_manager);
 162
 163 static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
 164                                                  unsigned long owner)
 165 {
 166         int ret;
 167         struct drm_hash_item *owner_hash_item;
 168         struct drm_owner_item *owner_item;
 169
 170         ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
 171         if (!ret) {
 172                 return drm_hash_entry(owner_hash_item, struct drm_owner_item,
 173                                       owner_hash);
 174         }
 175
 176         owner_item = kzalloc(sizeof(*owner_item), GFP_KERNEL);
 177         if (!owner_item)
 178                 goto out;
 179
 180         INIT_LIST_HEAD(&owner_item->mem_blocks);
 181         owner_item->owner_hash.key = owner;
 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         kfree(owner_item);
 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         BUG_ON(manager >= sman->num_managers);
 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 = kzalloc(sizeof(*memblock), GFP_KERNEL);
 213
 214         if (!memblock)
 215                 goto out;
 216
 217         memblock->mm_info = tmp;
 218         memblock->mm = sman_mm;
 219         memblock->sman = sman;
 220
 221         if (drm_ht_just_insert_please
 222             (&sman->user_hash_tab, &memblock->user_hash,
 223              (unsigned long)memblock, 32, 0, 0))
 224                 goto out1;
 225
 226         owner_item = drm_sman_get_owner_item(sman, owner);
 227         if (!owner_item)
 228                 goto out2;
 229
 230         list_add_tail(&memblock->owner_list, &owner_item->mem_blocks);
 231
 232         return memblock;
 233
 234 out2:
 235         drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
 236 out1:
 237         kfree(memblock);
 238 out:
 239         sman_mm->free(sman_mm->private, tmp);
 240
 241         return NULL;
 242 }
 243
 244 EXPORT_SYMBOL(drm_sman_alloc);
 245
 246 static void drm_sman_free(struct drm_memblock_item *item)
 247 {
 248         struct drm_sman *sman = item->sman;
 249
 250         list_del(&item->owner_list);
 251         drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
 252         item->mm->free(item->mm->private, item->mm_info);
 253         kfree(item);
 254 }
 255
 256 int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
 257 {
 258         struct drm_hash_item *hash_item;
 259         struct drm_memblock_item *memblock_item;
 260
 261         if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
 262                 return -EINVAL;
 263
 264         memblock_item = drm_hash_entry(hash_item, struct drm_memblock_item,
 265                                        user_hash);
 266         drm_sman_free(memblock_item);
 267         return 0;
 268 }
 269
 270 EXPORT_SYMBOL(drm_sman_free_key);
 271
 272 static void drm_sman_remove_owner(struct drm_sman *sman,
 273                                   struct drm_owner_item *owner_item)
 274 {
 275         list_del(&owner_item->sman_list);
 276         drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
 277         kfree(owner_item);
 278 }
 279
 280 int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
 281 {
 282
 283         struct drm_hash_item *hash_item;
 284         struct drm_owner_item *owner_item;
 285
 286         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
 287                 return -1;
 288         }
 289
 290         owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
 291         if (owner_item->mem_blocks.next == &owner_item->mem_blocks) {
 292                 drm_sman_remove_owner(sman, owner_item);
 293                 return -1;
 294         }
 295
 296         return 0;
 297 }
 298
 299 EXPORT_SYMBOL(drm_sman_owner_clean);
 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_sman_free(entry);
 309         }
 310         drm_sman_remove_owner(sman, owner_item);
 311 }
 312
 313 void drm_sman_owner_cleanup(struct drm_sman *sman, unsigned long owner)
 314 {
 315
 316         struct drm_hash_item *hash_item;
 317         struct drm_owner_item *owner_item;
 318
 319         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
 320
 321                 return;
 322         }
 323
 324         owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
 325         drm_sman_do_owner_cleanup(sman, owner_item);
 326 }
 327
 328 EXPORT_SYMBOL(drm_sman_owner_cleanup);
 329
 330 void drm_sman_cleanup(struct drm_sman *sman)
 331 {
 332         struct drm_owner_item *entry, *next;
 333         unsigned int i;
 334         struct drm_sman_mm *sman_mm;
 335
 336         list_for_each_entry_safe(entry, next, &sman->owner_items, sman_list) {
 337                 drm_sman_do_owner_cleanup(sman, entry);
 338         }
 339         if (sman->mm) {
 340                 for (i = 0; i < sman->num_managers; ++i) {
 341                         sman_mm = &sman->mm[i];
 342                         if (sman_mm->private) {
 343                                 sman_mm->destroy(sman_mm->private);
 344                                 sman_mm->private = NULL;
 345                         }
 346                 }
 347         }
 348 }
 349
 350 EXPORT_SYMBOL(drm_sman_cleanup);