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 int
  46 nvkm_gpuobj_heap_map(struct nvkm_gpuobj *gpuobj, u64 offset,
  47                      struct nvkm_vmm *vmm, struct nvkm_vma *vma,
  48                      void *argv, u32 argc)
  49 {
  50         return nvkm_memory_map(gpuobj->memory, offset, vmm, vma, argv, argc);
  51 }
  52
  53 static u32
  54 nvkm_gpuobj_heap_rd32(struct nvkm_gpuobj *gpuobj, u32 offset)
  55 {
  56         return nvkm_ro32(gpuobj->memory, offset);
  57 }
  58
  59 static void
  60 nvkm_gpuobj_heap_wr32(struct nvkm_gpuobj *gpuobj, u32 offset, u32 data)
  61 {
  62         nvkm_wo32(gpuobj->memory, offset, data);
  63 }
  64
  65 static const struct nvkm_gpuobj_func nvkm_gpuobj_heap;
  66 static void
  67 nvkm_gpuobj_heap_release(struct nvkm_gpuobj *gpuobj)
  68 {
  69         gpuobj->func = &nvkm_gpuobj_heap;
  70         nvkm_done(gpuobj->memory);
  71 }
  72
  73 static const struct nvkm_gpuobj_func
  74 nvkm_gpuobj_heap_fast = {
  75         .release = nvkm_gpuobj_heap_release,
  76         .rd32 = nvkm_gpuobj_rd32_fast,
  77         .wr32 = nvkm_gpuobj_wr32_fast,
  78         .map = nvkm_gpuobj_heap_map,
  79 };
  80
  81 static const struct nvkm_gpuobj_func
  82 nvkm_gpuobj_heap_slow = {
  83         .release = nvkm_gpuobj_heap_release,
  84         .rd32 = nvkm_gpuobj_heap_rd32,
  85         .wr32 = nvkm_gpuobj_heap_wr32,
  86         .map = nvkm_gpuobj_heap_map,
  87 };
  88
  89 static void *
  90 nvkm_gpuobj_heap_acquire(struct nvkm_gpuobj *gpuobj)
  91 {
  92         gpuobj->map = nvkm_kmap(gpuobj->memory);
  93         if (likely(gpuobj->map))
  94                 gpuobj->func = &nvkm_gpuobj_heap_fast;
  95         else
  96                 gpuobj->func = &nvkm_gpuobj_heap_slow;
  97         return gpuobj->map;
  98 }
  99
 100 static const struct nvkm_gpuobj_func
 101 nvkm_gpuobj_heap = {
 102         .acquire = nvkm_gpuobj_heap_acquire,
 103         .map = nvkm_gpuobj_heap_map,
 104 };
 105
 106 /* accessor functions for gpuobjs sub-allocated from a parent gpuobj */
 107 static int
 108 nvkm_gpuobj_map(struct nvkm_gpuobj *gpuobj, u64 offset,
 109                 struct nvkm_vmm *vmm, struct nvkm_vma *vma,
 110                 void *argv, u32 argc)
 111 {
 112         return nvkm_memory_map(gpuobj->parent, gpuobj->node->offset + offset,
 113                                vmm, vma, argv, argc);
 114 }
 115
 116 static u32
 117 nvkm_gpuobj_rd32(struct nvkm_gpuobj *gpuobj, u32 offset)
 118 {
 119         return nvkm_ro32(gpuobj->parent, gpuobj->node->offset + offset);
 120 }
 121
 122 static void
 123 nvkm_gpuobj_wr32(struct nvkm_gpuobj *gpuobj, u32 offset, u32 data)
 124 {
 125         nvkm_wo32(gpuobj->parent, gpuobj->node->offset + offset, data);
 126 }
 127
 128 static const struct nvkm_gpuobj_func nvkm_gpuobj_func;
 129 static void
 130 nvkm_gpuobj_release(struct nvkm_gpuobj *gpuobj)
 131 {
 132         gpuobj->func = &nvkm_gpuobj_func;
 133         nvkm_done(gpuobj->parent);
 134 }
 135
 136 static const struct nvkm_gpuobj_func
 137 nvkm_gpuobj_fast = {
 138         .release = nvkm_gpuobj_release,
 139         .rd32 = nvkm_gpuobj_rd32_fast,
 140         .wr32 = nvkm_gpuobj_wr32_fast,
 141         .map = nvkm_gpuobj_map,
 142 };
 143
 144 static const struct nvkm_gpuobj_func
 145 nvkm_gpuobj_slow = {
 146         .release = nvkm_gpuobj_release,
 147         .rd32 = nvkm_gpuobj_rd32,
 148         .wr32 = nvkm_gpuobj_wr32,
 149         .map = nvkm_gpuobj_map,
 150 };
 151
 152 static void *
 153 nvkm_gpuobj_acquire(struct nvkm_gpuobj *gpuobj)
 154 {
 155         gpuobj->map = nvkm_kmap(gpuobj->parent);
 156         if (likely(gpuobj->map)) {
 157                 gpuobj->map  = (u8 *)gpuobj->map + gpuobj->node->offset;
 158                 gpuobj->func = &nvkm_gpuobj_fast;
 159         } else {
 160                 gpuobj->func = &nvkm_gpuobj_slow;
 161         }
 162         return gpuobj->map;
 163 }
 164
 165 static const struct nvkm_gpuobj_func
 166 nvkm_gpuobj_func = {
 167         .acquire = nvkm_gpuobj_acquire,
 168         .map = nvkm_gpuobj_map,
 169 };
 170
 171 static int
 172 nvkm_gpuobj_ctor(struct nvkm_device *device, u32 size, int align, bool zero,
 173                  struct nvkm_gpuobj *parent, struct nvkm_gpuobj *gpuobj)
 174 {
 175         u32 offset;
 176         int ret;
 177
 178         if (parent) {
 179                 if (align >= 0) {
 180                         ret = nvkm_mm_head(&parent->heap, 0, 1, size, size,
 181                                            max(align, 1), &gpuobj->node);
 182                 } else {
 183                         ret = nvkm_mm_tail(&parent->heap, 0, 1, size, size,
 184                                            -align, &gpuobj->node);
 185                 }
 186                 if (ret)
 187                         return ret;
 188
 189                 gpuobj->parent = parent;
 190                 gpuobj->func = &nvkm_gpuobj_func;
 191                 gpuobj->addr = parent->addr + gpuobj->node->offset;
 192                 gpuobj->size = gpuobj->node->length;
 193
 194                 if (zero) {
 195                         nvkm_kmap(gpuobj);
 196                         for (offset = 0; offset < gpuobj->size; offset += 4)
 197                                 nvkm_wo32(gpuobj, offset, 0x00000000);
 198                         nvkm_done(gpuobj);
 199                 }
 200         } else {
 201                 ret = nvkm_memory_new(device, NVKM_MEM_TARGET_INST, size,
 202                                       abs(align), zero, &gpuobj->memory);
 203                 if (ret)
 204                         return ret;
 205
 206                 gpuobj->func = &nvkm_gpuobj_heap;
 207                 gpuobj->addr = nvkm_memory_addr(gpuobj->memory);
 208                 gpuobj->size = nvkm_memory_size(gpuobj->memory);
 209         }
 210
 211         return nvkm_mm_init(&gpuobj->heap, 0, 0, gpuobj->size, 1);
 212 }
 213
 214 void
 215 nvkm_gpuobj_del(struct nvkm_gpuobj **pgpuobj)
 216 {
 217         struct nvkm_gpuobj *gpuobj = *pgpuobj;
 218         if (gpuobj) {
 219                 if (gpuobj->parent)
 220                         nvkm_mm_free(&gpuobj->parent->heap, &gpuobj->node);
 221                 nvkm_mm_fini(&gpuobj->heap);
 222                 nvkm_memory_unref(&gpuobj->memory);
 223                 kfree(*pgpuobj);
 224                 *pgpuobj = NULL;
 225         }
 226 }
 227
 228 int
 229 nvkm_gpuobj_new(struct nvkm_device *device, u32 size, int align, bool zero,
 230                 struct nvkm_gpuobj *parent, struct nvkm_gpuobj **pgpuobj)
 231 {
 232         struct nvkm_gpuobj *gpuobj;
 233         int ret;
 234
 235         if (!(gpuobj = *pgpuobj = kzalloc(sizeof(*gpuobj), GFP_KERNEL)))
 236                 return -ENOMEM;
 237
 238         ret = nvkm_gpuobj_ctor(device, size, align, zero, parent, gpuobj);
 239         if (ret)
 240                 nvkm_gpuobj_del(pgpuobj);
 241         return ret;
 242 }
 243
 244 /* the below is basically only here to support sharing the paged dma object
 245  * for PCI(E)GART on <=nv4x chipsets, and should *not* be expected to work
 246  * anywhere else.
 247  */
 248
 249 int
 250 nvkm_gpuobj_wrap(struct nvkm_memory *memory, struct nvkm_gpuobj **pgpuobj)
 251 {
 252         if (!(*pgpuobj = kzalloc(sizeof(**pgpuobj), GFP_KERNEL)))
 253                 return -ENOMEM;
 254
 255         (*pgpuobj)->addr = nvkm_memory_addr(memory);
 256         (*pgpuobj)->size = nvkm_memory_size(memory);
 257         return 0;
 258 }
 259
 260 void
 261 nvkm_gpuobj_memcpy_to(struct nvkm_gpuobj *dst, u32 dstoffset, void *src,
 262                       u32 length)
 263 {
 264         int i;
 265
 266         for (i = 0; i < length; i += 4)
 267                 nvkm_wo32(dst, dstoffset + i, *(u32 *)(src + i));
 268 }
 269
 270 void
 271 nvkm_gpuobj_memcpy_from(void *dst, struct nvkm_gpuobj *src, u32 srcoffset,
 272                         u32 length)
 273 {
 274         int i;
 275
 276         for (i = 0; i < length; i += 4)
 277                 ((u32 *)src)[i / 4] = nvkm_ro32(src, srcoffset + i);
 278 }