SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 "drmP.h"
  29 #include "drm.h"
  30 #include "nouveau_drv.h"
  31
  32 int
  33 nouveau_notifier_init_channel(struct nouveau_channel *chan)
  34 {
  35         struct drm_device *dev = chan->dev;
  36         struct nouveau_bo *ntfy = NULL;
  37         uint32_t flags;
  38         int ret;
  39
  40         if (nouveau_vram_notify)
  41                 flags = TTM_PL_FLAG_VRAM;
  42         else
  43                 flags = TTM_PL_FLAG_TT;
  44
  45         ret = nouveau_gem_new(dev, NULL, PAGE_SIZE, 0, flags,
  46                               0, 0x0000, false, true, &ntfy);
  47         if (ret)
  48                 return ret;
  49
  50         ret = nouveau_bo_pin(ntfy, flags);
  51         if (ret)
  52                 goto out_err;
  53
  54         ret = nouveau_bo_map(ntfy);
  55         if (ret)
  56                 goto out_err;
  57
  58         ret = nouveau_mem_init_heap(&chan->notifier_heap, 0, ntfy->bo.mem.size);
  59         if (ret)
  60                 goto out_err;
  61
  62         chan->notifier_bo = ntfy;
  63 out_err:
  64         if (ret) {
  65                 mutex_lock(&dev->struct_mutex);
  66                 drm_gem_object_unreference(ntfy->gem);
  67                 mutex_unlock(&dev->struct_mutex);
  68         }
  69
  70         return ret;
  71 }
  72
  73 void
  74 nouveau_notifier_takedown_channel(struct nouveau_channel *chan)
  75 {
  76         struct drm_device *dev = chan->dev;
  77
  78         if (!chan->notifier_bo)
  79                 return;
  80
  81         nouveau_bo_unmap(chan->notifier_bo);
  82         mutex_lock(&dev->struct_mutex);
  83         nouveau_bo_unpin(chan->notifier_bo);
  84         drm_gem_object_unreference(chan->notifier_bo->gem);
  85         mutex_unlock(&dev->struct_mutex);
  86         nouveau_mem_takedown(&chan->notifier_heap);
  87 }
  88
  89 static void
  90 nouveau_notifier_gpuobj_dtor(struct drm_device *dev,
  91                              struct nouveau_gpuobj *gpuobj)
  92 {
  93         NV_DEBUG(dev, "\n");
  94
  95         if (gpuobj->priv)
  96                 nouveau_mem_free_block(gpuobj->priv);
  97 }
  98
  99 int
 100 nouveau_notifier_alloc(struct nouveau_channel *chan, uint32_t handle,
 101                        int size, uint32_t *b_offset)
 102 {
 103         struct drm_device *dev = chan->dev;
 104         struct drm_nouveau_private *dev_priv = dev->dev_private;
 105         struct nouveau_gpuobj *nobj = NULL;
 106         struct mem_block *mem;
 107         uint32_t offset;
 108         int target, ret;
 109
 110         if (!chan->notifier_heap) {
 111                 NV_ERROR(dev, "Channel %d doesn't have a notifier heap!\n",
 112                          chan->id);
 113                 return -EINVAL;
 114         }
 115
 116         mem = nouveau_mem_alloc_block(chan->notifier_heap, size, 0,
 117                                       (struct drm_file *)-2, 0);
 118         if (!mem) {
 119                 NV_ERROR(dev, "Channel %d notifier block full\n", chan->id);
 120                 return -ENOMEM;
 121         }
 122
 123         offset = chan->notifier_bo->bo.mem.mm_node->start << PAGE_SHIFT;
 124         if (chan->notifier_bo->bo.mem.mem_type == TTM_PL_VRAM) {
 125                 target = NV_DMA_TARGET_VIDMEM;
 126         } else
 127         if (chan->notifier_bo->bo.mem.mem_type == TTM_PL_TT) {
 128                 if (dev_priv->gart_info.type == NOUVEAU_GART_SGDMA &&
 129                     dev_priv->card_type < NV_50) {
 130                         ret = nouveau_sgdma_get_page(dev, offset, &offset);
 131                         if (ret)
 132                                 return ret;
 133                         target = NV_DMA_TARGET_PCI;
 134                 } else {
 135                         target = NV_DMA_TARGET_AGP;
 136                         if (dev_priv->card_type >= NV_50)
 137                                 offset += dev_priv->vm_gart_base;
 138                 }
 139         } else {
 140                 NV_ERROR(dev, "Bad DMA target, mem_type %d!\n",
 141                          chan->notifier_bo->bo.mem.mem_type);
 142                 return -EINVAL;
 143         }
 144         offset += mem->start;
 145
 146         ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, offset,
 147                                      mem->size, NV_DMA_ACCESS_RW, target,
 148                                      &nobj);
 149         if (ret) {
 150                 nouveau_mem_free_block(mem);
 151                 NV_ERROR(dev, "Error creating notifier ctxdma: %d\n", ret);
 152                 return ret;
 153         }
 154         nobj->dtor   = nouveau_notifier_gpuobj_dtor;
 155         nobj->priv   = mem;
 156
 157         ret = nouveau_gpuobj_ref_add(dev, chan, handle, nobj, NULL);
 158         if (ret) {
 159                 nouveau_gpuobj_del(dev, &nobj);
 160                 nouveau_mem_free_block(mem);
 161                 NV_ERROR(dev, "Error referencing notifier ctxdma: %d\n", ret);
 162                 return ret;
 163         }
 164
 165         *b_offset = mem->start;
 166         return 0;
 167 }
 168
 169 int
 170 nouveau_notifier_offset(struct nouveau_gpuobj *nobj, uint32_t *poffset)
 171 {
 172         if (!nobj || nobj->dtor != nouveau_notifier_gpuobj_dtor)
 173                 return -EINVAL;
 174
 175         if (poffset) {
 176                 struct mem_block *mem = nobj->priv;
 177
 178                 if (*poffset >= mem->size)
 179                         return false;
 180
 181                 *poffset += mem->start;
 182         }
 183
 184         return 0;
 185 }
 186
 187 int
 188 nouveau_ioctl_notifier_alloc(struct drm_device *dev, void *data,
 189                              struct drm_file *file_priv)
 190 {
 191         struct drm_nouveau_notifierobj_alloc *na = data;
 192         struct nouveau_channel *chan;
 193         int ret;
 194
 195         NOUVEAU_CHECK_INITIALISED_WITH_RETURN;
 196         NOUVEAU_GET_USER_CHANNEL_WITH_RETURN(na->channel, file_priv, chan);
 197
 198         ret = nouveau_notifier_alloc(chan, na->handle, na->size, &na->offset);
 199         if (ret)
 200                 return ret;
 201
 202         return 0;
 203 }