drivers/gpu/drm/nouveau/nouveau_notifier.c

   1 /*
   2  * Copyright (C) 2007 Ben Skeggs.
   3  *
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a 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, sublicense, 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
  16  * portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  */
  27
  28 #include <drm/drmP.h>
  29 #include "nouveau_drv.h"
  30 #include "nouveau_ramht.h"
  31
  32 int
  33 nouveau_notifier_init_channel(struct nouveau_channel *chan)
  34 {
  35         struct drm_device *dev = chan->dev;
  36         struct drm_nouveau_private *dev_priv = dev->dev_private;
  37         struct nouveau_bo *ntfy = NULL;
  38         uint32_t flags, ttmpl;
  39         int ret;
  40
  41         if (nouveau_vram_notify) {
  42                 flags = NOUVEAU_GEM_DOMAIN_VRAM;
  43                 ttmpl = TTM_PL_FLAG_VRAM;
  44         } else {
  45                 flags = NOUVEAU_GEM_DOMAIN_GART;
  46                 ttmpl = TTM_PL_FLAG_TT;
  47         }
  48
  49         ret = nouveau_gem_new(dev, PAGE_SIZE, 0, flags, 0, 0, &ntfy);
  50         if (ret)
  51                 return ret;
  52
  53         ret = nouveau_bo_pin(ntfy, ttmpl);
  54         if (ret)
  55                 goto out_err;
  56
  57         ret = nouveau_bo_map(ntfy);
  58         if (ret)
  59                 goto out_err;
  60
  61         if (dev_priv->card_type >= NV_50) {
  62                 ret = nouveau_bo_vma_add(ntfy, chan->vm, &chan->notifier_vma);
  63                 if (ret)
  64                         goto out_err;
  65         }
  66
  67         ret = drm_mm_init(&chan->notifier_heap, 0, ntfy->bo.mem.size);
  68         if (ret)
  69                 goto out_err;
  70
  71         chan->notifier_bo = ntfy;
  72 out_err:
  73         if (ret) {
  74                 nouveau_bo_vma_del(ntfy, &chan->notifier_vma);
  75                 drm_gem_object_unreference_unlocked(ntfy->gem);
  76         }
  77
  78         return ret;
  79 }
  80
  81 void
  82 nouveau_notifier_takedown_channel(struct nouveau_channel *chan)
  83 {
  84         struct drm_device *dev = chan->dev;
  85
  86         if (!chan->notifier_bo)
  87                 return;
  88
  89         nouveau_bo_vma_del(chan->notifier_bo, &chan->notifier_vma);
  90         nouveau_bo_unmap(chan->notifier_bo);
  91         mutex_lock(&dev->struct_mutex);
  92         nouveau_bo_unpin(chan->notifier_bo);
  93         mutex_unlock(&dev->struct_mutex);
  94         drm_gem_object_unreference_unlocked(chan->notifier_bo->gem);
  95         drm_mm_takedown(&chan->notifier_heap);
  96 }
  97
  98 static void
  99 nouveau_notifier_gpuobj_dtor(struct drm_device *dev,
 100                              struct nouveau_gpuobj *gpuobj)
 101 {
 102         NV_DEBUG(dev, "\n");
 103
 104         if (gpuobj->priv)
 105                 drm_mm_put_block(gpuobj->priv);
 106 }
 107
 108 int
 109 nouveau_notifier_alloc(struct nouveau_channel *chan, uint32_t handle,
 110                        int size, uint32_t start, uint32_t end,
 111                        uint32_t *b_offset)
 112 {
 113         struct drm_device *dev = chan->dev;
 114         struct drm_nouveau_private *dev_priv = dev->dev_private;
 115         struct nouveau_gpuobj *nobj = NULL;
 116         struct drm_mm_node *mem;
 117         uint64_t offset;
 118         int target, ret;
 119
 120         mem = drm_mm_search_free_in_range(&chan->notifier_heap, size, 0,
 121                                           start, end, 0);
 122         if (mem)
 123                 mem = drm_mm_get_block_range(mem, size, 0, start, end);
 124         if (!mem) {
 125                 NV_ERROR(dev, "Channel %d notifier block full\n", chan->id);
 126                 return -ENOMEM;
 127         }
 128
 129         if (dev_priv->card_type < NV_50) {
 130                 if (chan->notifier_bo->bo.mem.mem_type == TTM_PL_VRAM)
 131                         target = NV_MEM_TARGET_VRAM;
 132                 else
 133                         target = NV_MEM_TARGET_GART;
 134                 offset  = chan->notifier_bo->bo.offset;
 135         } else {
 136                 target = NV_MEM_TARGET_VM;
 137                 offset = chan->notifier_vma.offset;
 138         }
 139         offset += mem->start;
 140
 141         ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, offset,
 142                                      mem->size, NV_MEM_ACCESS_RW, target,
 143                                      &nobj);
 144         if (ret) {
 145                 drm_mm_put_block(mem);
 146                 NV_ERROR(dev, "Error creating notifier ctxdma: %d\n", ret);
 147                 return ret;
 148         }
 149         nobj->dtor = nouveau_notifier_gpuobj_dtor;
 150         nobj->priv = mem;
 151
 152         ret = nouveau_ramht_insert(chan, handle, nobj);
 153         nouveau_gpuobj_ref(NULL, &nobj);
 154         if (ret) {
 155                 drm_mm_put_block(mem);
 156                 NV_ERROR(dev, "Error adding notifier to ramht: %d\n", ret);
 157                 return ret;
 158         }
 159
 160         *b_offset = mem->start;
 161         return 0;
 162 }