drivers/gpu/drm/radeon/radeon_sa.c

   1 /*
   2  * Copyright 2011 Red Hat Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  16  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  17  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  18  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  19  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  *
  21  * The above copyright notice and this permission notice (including the
  22  * next paragraph) shall be included in all copies or substantial portions
  23  * of the Software.
  24  *
  25  */
  26 /*
  27  * Authors:
  28  *    Jerome Glisse <glisse@freedesktop.org>
  29  */
  30 #include "drmP.h"
  31 #include "drm.h"
  32 #include "radeon.h"
  33
  34 int radeon_sa_bo_manager_init(struct radeon_device *rdev,
  35                               struct radeon_sa_manager *sa_manager,
  36                               unsigned size, u32 domain)
  37 {
  38         int r;
  39
  40         spin_lock_init(&sa_manager->lock);
  41         sa_manager->bo = NULL;
  42         sa_manager->size = size;
  43         sa_manager->domain = domain;
  44         INIT_LIST_HEAD(&sa_manager->sa_bo);
  45
  46         r = radeon_bo_create(rdev, size, RADEON_GPU_PAGE_SIZE, true,
  47                              RADEON_GEM_DOMAIN_CPU, &sa_manager->bo);
  48         if (r) {
  49                 dev_err(rdev->dev, "(%d) failed to allocate bo for manager\n", r);
  50                 return r;
  51         }
  52
  53         return r;
  54 }
  55
  56 void radeon_sa_bo_manager_fini(struct radeon_device *rdev,
  57                                struct radeon_sa_manager *sa_manager)
  58 {
  59         struct radeon_sa_bo *sa_bo, *tmp;
  60
  61         if (!list_empty(&sa_manager->sa_bo)) {
  62                 dev_err(rdev->dev, "sa_manager is not empty, clearing anyway\n");
  63         }
  64         list_for_each_entry_safe(sa_bo, tmp, &sa_manager->sa_bo, list) {
  65                 list_del_init(&sa_bo->list);
  66         }
  67         radeon_bo_unref(&sa_manager->bo);
  68         sa_manager->size = 0;
  69 }
  70
  71 int radeon_sa_bo_manager_start(struct radeon_device *rdev,
  72                                struct radeon_sa_manager *sa_manager)
  73 {
  74         int r;
  75
  76         if (sa_manager->bo == NULL) {
  77                 dev_err(rdev->dev, "no bo for sa manager\n");
  78                 return -EINVAL;
  79         }
  80
  81         /* map the buffer */
  82         r = radeon_bo_reserve(sa_manager->bo, false);
  83         if (r) {
  84                 dev_err(rdev->dev, "(%d) failed to reserve manager bo\n", r);
  85                 return r;
  86         }
  87         r = radeon_bo_pin(sa_manager->bo, sa_manager->domain, &sa_manager->gpu_addr);
  88         if (r) {
  89                 radeon_bo_unreserve(sa_manager->bo);
  90                 dev_err(rdev->dev, "(%d) failed to pin manager bo\n", r);
  91                 return r;
  92         }
  93         r = radeon_bo_kmap(sa_manager->bo, &sa_manager->cpu_ptr);
  94         radeon_bo_unreserve(sa_manager->bo);
  95         return r;
  96 }
  97
  98 int radeon_sa_bo_manager_suspend(struct radeon_device *rdev,
  99                                  struct radeon_sa_manager *sa_manager)
 100 {
 101         int r;
 102
 103         if (sa_manager->bo == NULL) {
 104                 dev_err(rdev->dev, "no bo for sa manager\n");
 105                 return -EINVAL;
 106         }
 107
 108         r = radeon_bo_reserve(sa_manager->bo, false);
 109         if (!r) {
 110                 radeon_bo_kunmap(sa_manager->bo);
 111                 radeon_bo_unpin(sa_manager->bo);
 112                 radeon_bo_unreserve(sa_manager->bo);
 113         }
 114         return r;
 115 }
 116
 117 /*
 118  * Principe is simple, we keep a list of sub allocation in offset
 119  * order (first entry has offset == 0, last entry has the highest
 120  * offset).
 121  *
 122  * When allocating new object we first check if there is room at
 123  * the end total_size - (last_object_offset + last_object_size) >=
 124  * alloc_size. If so we allocate new object there.
 125  *
 126  * When there is not enough room at the end, we start waiting for
 127  * each sub object until we reach object_offset+object_size >=
 128  * alloc_size, this object then become the sub object we return.
 129  *
 130  * Alignment can't be bigger than page size
 131  */
 132 int radeon_sa_bo_new(struct radeon_device *rdev,
 133                      struct radeon_sa_manager *sa_manager,
 134                      struct radeon_sa_bo **sa_bo,
 135                      unsigned size, unsigned align)
 136 {
 137         struct radeon_sa_bo *tmp;
 138         struct list_head *head;
 139         unsigned offset = 0, wasted = 0;
 140
 141         BUG_ON(align > RADEON_GPU_PAGE_SIZE);
 142         BUG_ON(size > sa_manager->size);
 143
 144         *sa_bo = kmalloc(sizeof(struct radeon_sa_bo), GFP_KERNEL);
 145
 146         spin_lock(&sa_manager->lock);
 147
 148         /* no one ? */
 149         head = sa_manager->sa_bo.prev;
 150         if (list_empty(&sa_manager->sa_bo)) {
 151                 goto out;
 152         }
 153
 154         /* look for a hole big enough */
 155         offset = 0;
 156         list_for_each_entry(tmp, &sa_manager->sa_bo, list) {
 157                 /* room before this object ? */
 158                 if (offset < tmp->soffset && (tmp->soffset - offset) >= size) {
 159                         head = tmp->list.prev;
 160                         goto out;
 161                 }
 162                 offset = tmp->eoffset;
 163                 wasted = offset % align;
 164                 if (wasted) {
 165                         wasted = align - wasted;
 166                 }
 167                 offset += wasted;
 168         }
 169         /* room at the end ? */
 170         head = sa_manager->sa_bo.prev;
 171         tmp = list_entry(head, struct radeon_sa_bo, list);
 172         offset = tmp->eoffset;
 173         wasted = offset % align;
 174         if (wasted) {
 175                 wasted = align - wasted;
 176         }
 177         offset += wasted;
 178         if ((sa_manager->size - offset) < size) {
 179                 /* failed to find somethings big enough */
 180                 spin_unlock(&sa_manager->lock);
 181                 kfree(*sa_bo);
 182                 *sa_bo = NULL;
 183                 return -ENOMEM;
 184         }
 185
 186 out:
 187         (*sa_bo)->manager = sa_manager;
 188         (*sa_bo)->soffset = offset;
 189         (*sa_bo)->eoffset = offset + size;
 190         list_add(&(*sa_bo)->list, head);
 191         spin_unlock(&sa_manager->lock);
 192         return 0;
 193 }
 194
 195 void radeon_sa_bo_free(struct radeon_device *rdev, struct radeon_sa_bo **sa_bo)
 196 {
 197         if (!sa_bo || !*sa_bo)
 198                 return;
 199
 200         spin_lock(&(*sa_bo)->manager->lock);
 201         list_del_init(&(*sa_bo)->list);
 202         spin_unlock(&(*sa_bo)->manager->lock);
 203         kfree(*sa_bo);
 204         *sa_bo = NULL;
 205 }
 206
 207 #if defined(CONFIG_DEBUG_FS)
 208 void radeon_sa_bo_dump_debug_info(struct radeon_sa_manager *sa_manager,
 209                                   struct seq_file *m)
 210 {
 211         struct radeon_sa_bo *i;
 212
 213         spin_lock(&sa_manager->lock);
 214         list_for_each_entry(i, &sa_manager->sa_bo, list) {
 215                 seq_printf(m, "[%08x %08x] size %4d [%p]\n",
 216                            i->soffset, i->eoffset, i->eoffset - i->soffset, i);
 217         }
 218         spin_unlock(&sa_manager->lock);
 219 }
 220 #endif