umem.c

  1/*
  2 * Copyright 2017 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#include "umem.h"
 23#include "ummu.h"
 24
 25#include <core/client.h>
 26#include <core/memory.h>
 27#include <subdev/bar.h>
 28
 29#include <nvif/class.h>
 30#include <nvif/if000a.h>
 31#include <nvif/unpack.h>
 32
 33static const struct nvkm_object_func nvkm_umem;
 34struct nvkm_memory *
 35nvkm_umem_search(struct nvkm_client *client, u64 handle)
 36{
 37	struct nvkm_client *master = client->object.client;
 38	struct nvkm_memory *memory = NULL;
 39	struct nvkm_object *object;
 40	struct nvkm_umem *umem;
 41
 42	object = nvkm_object_search(client, handle, &nvkm_umem);
 43	if (IS_ERR(object)) {
 44		if (client != master) {
 45			spin_lock(&master->lock);
 46			list_for_each_entry(umem, &master->umem, head) {
 47				if (umem->object.object == handle) {
 48					memory = nvkm_memory_ref(umem->memory);
 49					break;
 50				}
 51			}
 52			spin_unlock(&master->lock);
 53		}
 54	} else {
 55		umem = nvkm_umem(object);
 56		memory = nvkm_memory_ref(umem->memory);
 57	}
 58
 59	return memory ? memory : ERR_PTR(-ENOENT);
 60}
 61
 62static int
 63nvkm_umem_unmap(struct nvkm_object *object)
 64{
 65	struct nvkm_umem *umem = nvkm_umem(object);
 66
 67	if (!umem->map)
 68		return -EEXIST;
 69
 70	if (umem->io) {
 71		if (!IS_ERR(umem->bar)) {
 72			struct nvkm_device *device = umem->mmu->subdev.device;
 73			nvkm_vmm_put(nvkm_bar_bar1_vmm(device), &umem->bar);
 74		} else {
 75			umem->bar = NULL;
 76		}
 77	} else {
 78		vunmap(umem->map);
 79		umem->map = NULL;
 80	}
 81
 82	return 0;
 83}
 84
 85static int
 86nvkm_umem_map(struct nvkm_object *object, void *argv, u32 argc,
 87	      enum nvkm_object_map *type, u64 *handle, u64 *length)
 88{
 89	struct nvkm_umem *umem = nvkm_umem(object);
 90	struct nvkm_mmu *mmu = umem->mmu;
 91
 92	if (!umem->mappable)
 93		return -EINVAL;
 94	if (umem->map)
 95		return -EEXIST;
 96
 97	if ((umem->type & NVKM_MEM_HOST) && !argc) {
 98		int ret = nvkm_mem_map_host(umem->memory, &umem->map);
 99		if (ret)
100			return ret;
101
102		*handle = (unsigned long)(void *)umem->map;
103		*length = nvkm_memory_size(umem->memory);
104		*type = NVKM_OBJECT_MAP_VA;
105		return 0;
106	} else
107	if ((umem->type & NVKM_MEM_VRAM) ||
108	    (umem->type & NVKM_MEM_KIND)) {
109		int ret = mmu->func->mem.umap(mmu, umem->memory, argv, argc,
110					      handle, length, &umem->bar);
111		if (ret)
112			return ret;
113
114		*type = NVKM_OBJECT_MAP_IO;
115	} else {
116		return -EINVAL;
117	}
118
119	umem->io = (*type == NVKM_OBJECT_MAP_IO);
120	return 0;
121}
122
123static void *
124nvkm_umem_dtor(struct nvkm_object *object)
125{
126	struct nvkm_umem *umem = nvkm_umem(object);
127	spin_lock(&umem->object.client->lock);
128	list_del_init(&umem->head);
129	spin_unlock(&umem->object.client->lock);
130	nvkm_memory_unref(&umem->memory);
131	return umem;
132}
133
134static const struct nvkm_object_func
135nvkm_umem = {
136	.dtor = nvkm_umem_dtor,
137	.map = nvkm_umem_map,
138	.unmap = nvkm_umem_unmap,
139};
140
141int
142nvkm_umem_new(const struct nvkm_oclass *oclass, void *argv, u32 argc,
143	      struct nvkm_object **pobject)
144{
145	struct nvkm_mmu *mmu = nvkm_ummu(oclass->parent)->mmu;
146	union {
147		struct nvif_mem_v0 v0;
148	} *args = argv;
149	struct nvkm_umem *umem;
150	int type, ret = -ENOSYS;
151	u8  page;
152	u64 size;
153
154	if (!(ret = nvif_unpack(ret, &argv, &argc, args->v0, 0, 0, true))) {
155		type = args->v0.type;
156		page = args->v0.page;
157		size = args->v0.size;
158	} else
159		return ret;
160
161	if (type >= mmu->type_nr)
162		return -EINVAL;
163
164	if (!(umem = kzalloc(sizeof(*umem), GFP_KERNEL)))
165		return -ENOMEM;
166	nvkm_object_ctor(&nvkm_umem, oclass, &umem->object);
167	umem->mmu = mmu;
168	umem->type = mmu->type[type].type;
169	INIT_LIST_HEAD(&umem->head);
170	*pobject = &umem->object;
171
172	if (mmu->type[type].type & NVKM_MEM_MAPPABLE) {
173		page = max_t(u8, page, PAGE_SHIFT);
174		umem->mappable = true;
175	}
176
177	ret = nvkm_mem_new_type(mmu, type, page, size, argv, argc,
178				&umem->memory);
179	if (ret)
180		return ret;
181
182	spin_lock(&umem->object.client->lock);
183	list_add(&umem->head, &umem->object.client->umem);
184	spin_unlock(&umem->object.client->lock);
185
186	args->v0.page = nvkm_memory_page(umem->memory);
187	args->v0.addr = nvkm_memory_addr(umem->memory);
188	args->v0.size = nvkm_memory_size(umem->memory);
189	return 0;
190}