drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c

   1 /*
   2  * Copyright 2012 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  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 NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Ben Skeggs
  23  */
  24 #include <core/gpuobj.h>
  25 #include <core/engine.h>
  26
  27 #include <subdev/instmem.h>
  28 #include <subdev/bar.h>
  29 #include <subdev/mmu.h>
  30
  31 /* fast-path, where backend is able to provide direct pointer to memory */
  32 static u32
  33 nvkm_gpuobj_rd32_fast(struct nvkm_gpuobj *gpuobj, u32 offset)
  34 {
  35         return ioread32_native(gpuobj->map + offset);
  36 }
  37
  38 static void
  39 nvkm_gpuobj_wr32_fast(struct nvkm_gpuobj *gpuobj, u32 offset, u32 data)
  40 {
  41         iowrite32_native(data, gpuobj->map + offset);
  42 }
  43
  44 /* accessor functions for gpuobjs allocated directly from instmem */
  45 static u32
  46 nvkm_gpuobj_heap_rd32(struct nvkm_gpuobj *gpuobj, u32 offset)
  47 {
  48         return nvkm_ro32(gpuobj->memory, offset);
  49 }
  50
  51 static void
  52 nvkm_gpuobj_heap_wr32(struct nvkm_gpuobj *gpuobj, u32 offset, u32 data)
  53 {
  54         nvkm_wo32(gpuobj->memory, offset, data);
  55 }
  56
  57 static const struct nvkm_gpuobj_func nvkm_gpuobj_heap;
  58 static void
  59 nvkm_gpuobj_heap_release(struct nvkm_gpuobj *gpuobj)
  60 {
  61         gpuobj->func = &nvkm_gpuobj_heap;
  62         nvkm_done(gpuobj->memory);
  63 }
  64
  65 static const struct nvkm_gpuobj_func
  66 nvkm_gpuobj_heap_fast = {
  67         .release = nvkm_gpuobj_heap_release,
  68         .rd32 = nvkm_gpuobj_rd32_fast,
  69         .wr32 = nvkm_gpuobj_wr32_fast,
  70 };
  71
  72 static const struct nvkm_gpuobj_func
  73 nvkm_gpuobj_heap_slow = {
  74         .release = nvkm_gpuobj_heap_release,
  75         .rd32 = nvkm_gpuobj_heap_rd32,
  76         .wr32 = nvkm_gpuobj_heap_wr32,
  77 };
  78
  79 static void *
  80 nvkm_gpuobj_heap_acquire(struct nvkm_gpuobj *gpuobj)
  81 {
  82         gpuobj->map = nvkm_kmap(gpuobj->memory);
  83         if (likely(gpuobj->map))
  84                 gpuobj->func = &nvkm_gpuobj_heap_fast;
  85         else
  86                 gpuobj->func = &nvkm_gpuobj_heap_slow;
  87         return gpuobj->map;
  88 }
  89
  90 static const struct nvkm_gpuobj_func
  91 nvkm_gpuobj_heap = {
  92         .acquire = nvkm_gpuobj_heap_acquire,
  93 };
  94
  95 /* accessor functions for gpuobjs sub-allocated from a parent gpuobj */
  96 static u32
  97 nvkm_gpuobj_rd32(struct nvkm_gpuobj *gpuobj, u32 offset)
  98 {
  99         return nvkm_ro32(gpuobj->parent, gpuobj->node->offset + offset);
 100 }
 101
 102 static void
 103 nvkm_gpuobj_wr32(struct nvkm_gpuobj *gpuobj, u32 offset, u32 data)
 104 {
 105         nvkm_wo32(gpuobj->parent, gpuobj->node->offset + offset, data);
 106 }
 107
 108 static const struct nvkm_gpuobj_func nvkm_gpuobj_func;
 109 static void
 110 nvkm_gpuobj_release(struct nvkm_gpuobj *gpuobj)
 111 {
 112         gpuobj->func = &nvkm_gpuobj_func;
 113         nvkm_done(gpuobj->parent);
 114 }
 115
 116 static const struct nvkm_gpuobj_func
 117 nvkm_gpuobj_fast = {
 118         .release = nvkm_gpuobj_release,
 119         .rd32 = nvkm_gpuobj_rd32_fast,
 120         .wr32 = nvkm_gpuobj_wr32_fast,
 121 };
 122
 123 static const struct nvkm_gpuobj_func
 124 nvkm_gpuobj_slow = {
 125         .release = nvkm_gpuobj_release,
 126         .rd32 = nvkm_gpuobj_rd32,
 127         .wr32 = nvkm_gpuobj_wr32,
 128 };
 129
 130 static void *
 131 nvkm_gpuobj_acquire(struct nvkm_gpuobj *gpuobj)
 132 {
 133         gpuobj->map = nvkm_kmap(gpuobj->parent);
 134         if (likely(gpuobj->map)) {
 135                 gpuobj->map  = (u8 *)gpuobj->map + gpuobj->node->offset;
 136                 gpuobj->func = &nvkm_gpuobj_fast;
 137         } else {
 138                 gpuobj->func = &nvkm_gpuobj_slow;
 139         }
 140         return gpuobj->map;
 141 }
 142
 143 static const struct nvkm_gpuobj_func
 144 nvkm_gpuobj_func = {
 145         .acquire = nvkm_gpuobj_acquire,
 146 };
 147
 148 static int
 149 nvkm_gpuobj_ctor(struct nvkm_device *device, u32 size, int align, bool zero,
 150                  struct nvkm_gpuobj *parent, struct nvkm_gpuobj *gpuobj)
 151 {
 152         u32 offset;
 153         int ret;
 154
 155         if (parent) {
 156                 if (align >= 0) {
 157                         ret = nvkm_mm_head(&parent->heap, 0, 1, size, size,
 158                                            max(align, 1), &gpuobj->node);
 159                 } else {
 160                         ret = nvkm_mm_tail(&parent->heap, 0, 1, size, size,
 161                                            -align, &gpuobj->node);
 162                 }
 163                 if (ret)
 164                         return ret;
 165
 166                 gpuobj->parent = parent;
 167                 gpuobj->func = &nvkm_gpuobj_func;
 168                 gpuobj->addr = parent->addr + gpuobj->node->offset;
 169                 gpuobj->size = gpuobj->node->length;
 170
 171                 if (zero) {
 172                         nvkm_kmap(gpuobj);
 173                         for (offset = 0; offset < gpuobj->size; offset += 4)
 174                                 nvkm_wo32(gpuobj, offset, 0x00000000);
 175                         nvkm_done(gpuobj);
 176                 }
 177         } else {
 178                 ret = nvkm_memory_new(device, NVKM_MEM_TARGET_INST, size,
 179                                       abs(align), zero, &gpuobj->memory);
 180                 if (ret)
 181                         return ret;
 182
 183                 gpuobj->func = &nvkm_gpuobj_heap;
 184                 gpuobj->addr = nvkm_memory_addr(gpuobj->memory);
 185                 gpuobj->size = nvkm_memory_size(gpuobj->memory);
 186         }
 187
 188         return nvkm_mm_init(&gpuobj->heap, 0, gpuobj->size, 1);
 189 }
 190
 191 void
 192 nvkm_gpuobj_del(struct nvkm_gpuobj **pgpuobj)
 193 {
 194         struct nvkm_gpuobj *gpuobj = *pgpuobj;
 195         if (gpuobj) {
 196                 if (gpuobj->parent)
 197                         nvkm_mm_free(&gpuobj->parent->heap, &gpuobj->node);
 198                 nvkm_mm_fini(&gpuobj->heap);
 199                 nvkm_memory_del(&gpuobj->memory);
 200                 kfree(*pgpuobj);
 201                 *pgpuobj = NULL;
 202         }
 203 }
 204
 205 int
 206 nvkm_gpuobj_new(struct nvkm_device *device, u32 size, int align, bool zero,
 207                 struct nvkm_gpuobj *parent, struct nvkm_gpuobj **pgpuobj)
 208 {
 209         struct nvkm_gpuobj *gpuobj;
 210         int ret;
 211
 212         if (!(gpuobj = *pgpuobj = kzalloc(sizeof(*gpuobj), GFP_KERNEL)))
 213                 return -ENOMEM;
 214
 215         ret = nvkm_gpuobj_ctor(device, size, align, zero, parent, gpuobj);
 216         if (ret)
 217                 nvkm_gpuobj_del(pgpuobj);
 218         return ret;
 219 }
 220
 221 int
 222 nvkm_gpuobj_map(struct nvkm_gpuobj *gpuobj, struct nvkm_vm *vm,
 223                 u32 access, struct nvkm_vma *vma)
 224 {
 225         struct nvkm_memory *memory = gpuobj->memory;
 226         int ret = nvkm_vm_get(vm, gpuobj->size, 12, access, vma);
 227         if (ret == 0)
 228                 nvkm_memory_map(memory, vma, 0);
 229         return ret;
 230 }
 231
 232 void
 233 nvkm_gpuobj_unmap(struct nvkm_vma *vma)
 234 {
 235         if (vma->node) {
 236                 nvkm_vm_unmap(vma);
 237                 nvkm_vm_put(vma);
 238         }
 239 }
 240
 241 /* the below is basically only here to support sharing the paged dma object
 242  * for PCI(E)GART on <=nv4x chipsets, and should *not* be expected to work
 243  * anywhere else.
 244  */
 245
 246 int
 247 nvkm_gpuobj_wrap(struct nvkm_memory *memory, struct nvkm_gpuobj **pgpuobj)
 248 {
 249         if (!(*pgpuobj = kzalloc(sizeof(**pgpuobj), GFP_KERNEL)))
 250                 return -ENOMEM;
 251
 252         (*pgpuobj)->addr = nvkm_memory_addr(memory);
 253         (*pgpuobj)->size = nvkm_memory_size(memory);
 254         return 0;
 255 }
 256
 257 void
 258 nvkm_gpuobj_memcpy_to(struct nvkm_gpuobj *dst, u32 dstoffset, void *src,
 259                       u32 length)
 260 {
 261         int i;
 262
 263         for (i = 0; i < length; i += 4)
 264                 nvkm_wo32(dst, dstoffset + i, *(u32 *)(src + i));
 265 }
 266
 267 void
 268 nvkm_gpuobj_memcpy_from(void *dst, struct nvkm_gpuobj *src, u32 srcoffset,
 269                         u32 length)
 270 {
 271         int i;
 272
 273         for (i = 0; i < length; i += 4)
 274                 ((u32 *)src)[i / 4] = nvkm_ro32(src, srcoffset + i);
 275 }