1 /* $NetBSD: nouveau_nvkm_subdev_mmu_umem.c,v 1.3 2021/12/19 10:51:58 riastradh Exp $ */
2
3 /*
4 * Copyright 2017 Red Hat Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24 #include <sys/cdefs.h>
25 __KERNEL_RCSID(0, "$NetBSD: nouveau_nvkm_subdev_mmu_umem.c,v 1.3 2021/12/19 10:51:58 riastradh Exp $");
26
27 #include "umem.h"
28 #include "ummu.h"
29
30 #include <core/client.h>
31 #include <core/memory.h>
32 #include <subdev/bar.h>
33
34 #include <nvif/class.h>
35 #include <nvif/if000a.h>
36 #include <nvif/unpack.h>
37
38 static const struct nvkm_object_func nvkm_umem;
39 struct nvkm_memory *
nvkm_umem_search(struct nvkm_client * client,u64 handle)40 nvkm_umem_search(struct nvkm_client *client, u64 handle)
41 {
42 struct nvkm_client *master = client->object.client;
43 struct nvkm_memory *memory = NULL;
44 struct nvkm_object *object;
45 struct nvkm_umem *umem;
46
47 object = nvkm_object_search(client, handle, &nvkm_umem);
48 if (IS_ERR(object)) {
49 if (client->super && client != master) {
50 spin_lock(&master->lock);
51 list_for_each_entry(umem, &master->umem, head) {
52 if (umem->object.object == handle) {
53 memory = nvkm_memory_ref(umem->memory);
54 break;
55 }
56 }
57 spin_unlock(&master->lock);
58 }
59 } else {
60 umem = nvkm_umem(object);
61 if (!umem->priv || client->super)
62 memory = nvkm_memory_ref(umem->memory);
63 }
64
65 return memory ? memory : ERR_PTR(-ENOENT);
66 }
67
68 static int
nvkm_umem_unmap(struct nvkm_object * object)69 nvkm_umem_unmap(struct nvkm_object *object)
70 {
71 struct nvkm_umem *umem = nvkm_umem(object);
72
73 if (!umem->map)
74 return -EEXIST;
75
76 if (umem->io) {
77 if (!IS_ERR(umem->bar)) {
78 struct nvkm_device *device = umem->mmu->subdev.device;
79 nvkm_vmm_put(nvkm_bar_bar1_vmm(device), &umem->bar);
80 } else {
81 umem->bar = NULL;
82 }
83 } else {
84 #ifdef __NetBSD__
85 bus_dmamem_unmap(umem->dmat, umem->map, umem->size);
86 #else
87 vunmap(umem->map);
88 #endif
89 umem->map = NULL;
90 }
91
92 return 0;
93 }
94
95 static int
96 #ifdef __NetBSD__
nvkm_umem_map(struct nvkm_object * object,void * argv,u32 argc,enum nvkm_object_map * type,bus_space_tag_t * tag,u64 * handle,u64 * length)97 nvkm_umem_map(struct nvkm_object *object, void *argv, u32 argc,
98 enum nvkm_object_map *type,
99 bus_space_tag_t *tag, u64 *handle, u64 *length)
100 #else
101 nvkm_umem_map(struct nvkm_object *object, void *argv, u32 argc,
102 enum nvkm_object_map *type, u64 *handle, u64 *length)
103 #endif
104 {
105 struct nvkm_umem *umem = nvkm_umem(object);
106 struct nvkm_mmu *mmu = umem->mmu;
107
108 if (!umem->mappable)
109 return -EINVAL;
110 if (umem->map)
111 return -EEXIST;
112
113 if ((umem->type & NVKM_MEM_HOST) && !argc) {
114 #ifdef __NetBSD__
115 int ret = nvkm_mem_map_host(umem->memory, &umem->dmat,
116 &umem->map, &umem->size);
117 #else
118 int ret = nvkm_mem_map_host(umem->memory, &umem->map);
119 #endif
120 if (ret)
121 return ret;
122
123 #ifdef __NetBSD__
124 *tag = NULL;
125 #endif
126 *handle = (unsigned long)(void *)umem->map;
127 *length = nvkm_memory_size(umem->memory);
128 *type = NVKM_OBJECT_MAP_VA;
129 return 0;
130 } else
131 if ((umem->type & NVKM_MEM_VRAM) ||
132 (umem->type & NVKM_MEM_KIND)) {
133 #ifdef __NetBSD__
134 int ret = mmu->func->mem.umap(mmu, umem->memory, argv, argc,
135 tag, handle, length, &umem->bar);
136 #else
137 int ret = mmu->func->mem.umap(mmu, umem->memory, argv, argc,
138 handle, length, &umem->bar);
139 #endif
140 if (ret)
141 return ret;
142
143 *type = NVKM_OBJECT_MAP_IO;
144 } else {
145 return -EINVAL;
146 }
147
148 umem->io = (*type == NVKM_OBJECT_MAP_IO);
149 return 0;
150 }
151
152 static void *
nvkm_umem_dtor(struct nvkm_object * object)153 nvkm_umem_dtor(struct nvkm_object *object)
154 {
155 struct nvkm_umem *umem = nvkm_umem(object);
156 spin_lock(&umem->object.client->lock);
157 list_del_init(&umem->head);
158 spin_unlock(&umem->object.client->lock);
159 nvkm_memory_unref(&umem->memory);
160 return umem;
161 }
162
163 static const struct nvkm_object_func
164 nvkm_umem = {
165 .dtor = nvkm_umem_dtor,
166 .map = nvkm_umem_map,
167 .unmap = nvkm_umem_unmap,
168 };
169
170 int
nvkm_umem_new(const struct nvkm_oclass * oclass,void * argv,u32 argc,struct nvkm_object ** pobject)171 nvkm_umem_new(const struct nvkm_oclass *oclass, void *argv, u32 argc,
172 struct nvkm_object **pobject)
173 {
174 struct nvkm_mmu *mmu = nvkm_ummu(oclass->parent)->mmu;
175 union {
176 struct nvif_mem_v0 v0;
177 } *args = argv;
178 struct nvkm_umem *umem;
179 int type, ret = -ENOSYS;
180 u8 page;
181 u64 size;
182
183 if (!(ret = nvif_unpack(ret, &argv, &argc, args->v0, 0, 0, true))) {
184 type = args->v0.type;
185 page = args->v0.page;
186 size = args->v0.size;
187 } else
188 return ret;
189
190 if (type >= mmu->type_nr)
191 return -EINVAL;
192
193 if (!(umem = kzalloc(sizeof(*umem), GFP_KERNEL)))
194 return -ENOMEM;
195 nvkm_object_ctor(&nvkm_umem, oclass, &umem->object);
196 umem->mmu = mmu;
197 umem->type = mmu->type[type].type;
198 umem->priv = oclass->client->super;
199 INIT_LIST_HEAD(&umem->head);
200 *pobject = &umem->object;
201
202 if (mmu->type[type].type & NVKM_MEM_MAPPABLE) {
203 page = max_t(u8, page, PAGE_SHIFT);
204 umem->mappable = true;
205 }
206
207 ret = nvkm_mem_new_type(mmu, type, page, size, argv, argc,
208 &umem->memory);
209 if (ret)
210 return ret;
211
212 spin_lock(&umem->object.client->lock);
213 list_add(&umem->head, &umem->object.client->umem);
214 spin_unlock(&umem->object.client->lock);
215
216 args->v0.page = nvkm_memory_page(umem->memory);
217 args->v0.addr = nvkm_memory_addr(umem->memory);
218 args->v0.size = nvkm_memory_size(umem->memory);
219 return 0;
220 }
221