1 /*
2  * Copyright 2014 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 <bskeggs@redhat.com>
23  */
24 
25 #include <nvif/object.h>
26 #include <nvif/client.h>
27 #include <nvif/driver.h>
28 #include <nvif/ioctl.h>
29 
30 int
nvif_object_ioctl(struct nvif_object * object,void * data,u32 size,void ** hack)31 nvif_object_ioctl(struct nvif_object *object, void *data, u32 size, void **hack)
32 {
33 	struct nvif_client *client = object->client;
34 	union {
35 		struct nvif_ioctl_v0 v0;
36 	} *args = data;
37 
38 	if (size >= sizeof(*args) && args->v0.version == 0) {
39 		if (object != &client->object)
40 			args->v0.object = nvif_handle(object);
41 		else
42 			args->v0.object = 0;
43 		args->v0.owner = NVIF_IOCTL_V0_OWNER_ANY;
44 	} else
45 		return -ENOSYS;
46 
47 	return client->driver->ioctl(client->object.priv, data, size, hack);
48 }
49 
50 void
nvif_object_sclass_put(struct nvif_sclass ** psclass)51 nvif_object_sclass_put(struct nvif_sclass **psclass)
52 {
53 	kfree(*psclass);
54 	*psclass = NULL;
55 }
56 
57 int
nvif_object_sclass_get(struct nvif_object * object,struct nvif_sclass ** psclass)58 nvif_object_sclass_get(struct nvif_object *object, struct nvif_sclass **psclass)
59 {
60 	struct {
61 		struct nvif_ioctl_v0 ioctl;
62 		struct nvif_ioctl_sclass_v0 sclass;
63 	} *args = NULL;
64 	int ret, cnt = 0, i;
65 	u32 size;
66 
67 	while (1) {
68 		size = sizeof(*args) + cnt * sizeof(args->sclass.oclass[0]);
69 		if (!(args = kmalloc(size, GFP_KERNEL)))
70 			return -ENOMEM;
71 		args->ioctl.version = 0;
72 		args->ioctl.type = NVIF_IOCTL_V0_SCLASS;
73 		args->sclass.version = 0;
74 		args->sclass.count = cnt;
75 
76 		ret = nvif_object_ioctl(object, args, size, NULL);
77 		if (ret == 0 && args->sclass.count <= cnt)
78 			break;
79 		cnt = args->sclass.count;
80 		kfree(args);
81 		if (ret != 0)
82 			return ret;
83 	}
84 
85 	*psclass = kcalloc(args->sclass.count, sizeof(**psclass), GFP_KERNEL);
86 	if (*psclass) {
87 		for (i = 0; i < args->sclass.count; i++) {
88 			(*psclass)[i].oclass = args->sclass.oclass[i].oclass;
89 			(*psclass)[i].minver = args->sclass.oclass[i].minver;
90 			(*psclass)[i].maxver = args->sclass.oclass[i].maxver;
91 		}
92 		ret = args->sclass.count;
93 	} else {
94 		ret = -ENOMEM;
95 	}
96 
97 	kfree(args);
98 	return ret;
99 }
100 
101 u32
nvif_object_rd(struct nvif_object * object,int size,u64 addr)102 nvif_object_rd(struct nvif_object *object, int size, u64 addr)
103 {
104 	struct {
105 		struct nvif_ioctl_v0 ioctl;
106 		struct nvif_ioctl_rd_v0 rd;
107 	} args = {
108 		.ioctl.type = NVIF_IOCTL_V0_RD,
109 		.rd.size = size,
110 		.rd.addr = addr,
111 	};
112 	int ret = nvif_object_ioctl(object, &args, sizeof(args), NULL);
113 	if (ret) {
114 		/*XXX: warn? */
115 		return 0;
116 	}
117 	return args.rd.data;
118 }
119 
120 void
nvif_object_wr(struct nvif_object * object,int size,u64 addr,u32 data)121 nvif_object_wr(struct nvif_object *object, int size, u64 addr, u32 data)
122 {
123 	struct {
124 		struct nvif_ioctl_v0 ioctl;
125 		struct nvif_ioctl_wr_v0 wr;
126 	} args = {
127 		.ioctl.type = NVIF_IOCTL_V0_WR,
128 		.wr.size = size,
129 		.wr.addr = addr,
130 		.wr.data = data,
131 	};
132 	int ret = nvif_object_ioctl(object, &args, sizeof(args), NULL);
133 	if (ret) {
134 		/*XXX: warn? */
135 	}
136 }
137 
138 int
nvif_object_mthd(struct nvif_object * object,u32 mthd,void * data,u32 size)139 nvif_object_mthd(struct nvif_object *object, u32 mthd, void *data, u32 size)
140 {
141 	struct {
142 		struct nvif_ioctl_v0 ioctl;
143 		struct nvif_ioctl_mthd_v0 mthd;
144 	} *args;
145 	u8 stack[128];
146 	int ret;
147 
148 	if (sizeof(*args) + size > sizeof(stack)) {
149 		if (!(args = kmalloc(sizeof(*args) + size, GFP_KERNEL)))
150 			return -ENOMEM;
151 	} else {
152 		args = (void *)stack;
153 	}
154 	args->ioctl.version = 0;
155 	args->ioctl.type = NVIF_IOCTL_V0_MTHD;
156 	args->mthd.version = 0;
157 	args->mthd.method = mthd;
158 
159 	memcpy(args->mthd.data, data, size);
160 	ret = nvif_object_ioctl(object, args, sizeof(*args) + size, NULL);
161 	memcpy(data, args->mthd.data, size);
162 	if (args != (void *)stack)
163 		kfree(args);
164 	return ret;
165 }
166 
167 void
nvif_object_unmap_handle(struct nvif_object * object)168 nvif_object_unmap_handle(struct nvif_object *object)
169 {
170 	struct {
171 		struct nvif_ioctl_v0 ioctl;
172 		struct nvif_ioctl_unmap unmap;
173 	} args = {
174 		.ioctl.type = NVIF_IOCTL_V0_UNMAP,
175 	};
176 
177 	nvif_object_ioctl(object, &args, sizeof(args), NULL);
178 }
179 
180 int
nvif_object_map_handle(struct nvif_object * object,void * argv,u32 argc,u64 * handle,u64 * length)181 nvif_object_map_handle(struct nvif_object *object, void *argv, u32 argc,
182 		       u64 *handle, u64 *length)
183 {
184 	struct {
185 		struct nvif_ioctl_v0 ioctl;
186 		struct nvif_ioctl_map_v0 map;
187 	} *args;
188 	u32 argn = sizeof(*args) + argc;
189 	int ret, maptype;
190 
191 	if (!(args = kzalloc(argn, GFP_KERNEL)))
192 		return -ENOMEM;
193 	args->ioctl.type = NVIF_IOCTL_V0_MAP;
194 	memcpy(args->map.data, argv, argc);
195 
196 	ret = nvif_object_ioctl(object, args, argn, NULL);
197 	*handle = args->map.handle;
198 	*length = args->map.length;
199 	maptype = args->map.type;
200 	kfree(args);
201 	return ret ? ret : (maptype == NVIF_IOCTL_MAP_V0_IO);
202 }
203 
204 void
nvif_object_unmap(struct nvif_object * object)205 nvif_object_unmap(struct nvif_object *object)
206 {
207 	struct nvif_client *client = object->client;
208 	if (object->map.ptr) {
209 		if (object->map.size) {
210 			client->driver->unmap(client, object->map.ptr,
211 						      object->map.size);
212 			object->map.size = 0;
213 		}
214 		object->map.ptr = NULL;
215 		nvif_object_unmap_handle(object);
216 	}
217 }
218 
219 int
nvif_object_map(struct nvif_object * object,void * argv,u32 argc)220 nvif_object_map(struct nvif_object *object, void *argv, u32 argc)
221 {
222 	struct nvif_client *client = object->client;
223 	u64 handle, length;
224 	int ret = nvif_object_map_handle(object, argv, argc, &handle, &length);
225 	if (ret >= 0) {
226 		if (ret) {
227 			object->map.ptr = client->driver->map(client,
228 							      handle,
229 							      length);
230 			if (ret = -ENOMEM, object->map.ptr) {
231 				object->map.size = length;
232 				return 0;
233 			}
234 		} else {
235 			object->map.ptr = (void *)(unsigned long)handle;
236 			return 0;
237 		}
238 		nvif_object_unmap_handle(object);
239 	}
240 	return ret;
241 }
242 
243 void
nvif_object_dtor(struct nvif_object * object)244 nvif_object_dtor(struct nvif_object *object)
245 {
246 	struct {
247 		struct nvif_ioctl_v0 ioctl;
248 		struct nvif_ioctl_del del;
249 	} args = {
250 		.ioctl.type = NVIF_IOCTL_V0_DEL,
251 	};
252 
253 	if (!object->client)
254 		return;
255 
256 	nvif_object_unmap(object);
257 	nvif_object_ioctl(object, &args, sizeof(args), NULL);
258 	object->client = NULL;
259 }
260 
261 int
nvif_object_ctor(struct nvif_object * parent,const char * name,u32 handle,s32 oclass,void * data,u32 size,struct nvif_object * object)262 nvif_object_ctor(struct nvif_object *parent, const char *name, u32 handle,
263 		 s32 oclass, void *data, u32 size, struct nvif_object *object)
264 {
265 	struct {
266 		struct nvif_ioctl_v0 ioctl;
267 		struct nvif_ioctl_new_v0 new;
268 	} *args;
269 	int ret = 0;
270 
271 	object->client = NULL;
272 	object->name = name ? name : "nvifObject";
273 	object->handle = handle;
274 	object->oclass = oclass;
275 	object->map.ptr = NULL;
276 	object->map.size = 0;
277 
278 	if (parent) {
279 		if (!(args = kmalloc(sizeof(*args) + size, GFP_KERNEL))) {
280 			nvif_object_dtor(object);
281 			return -ENOMEM;
282 		}
283 
284 		object->parent = parent->parent;
285 
286 		args->ioctl.version = 0;
287 		args->ioctl.type = NVIF_IOCTL_V0_NEW;
288 		args->new.version = 0;
289 		args->new.route = parent->client->route;
290 		args->new.token = nvif_handle(object);
291 		args->new.object = nvif_handle(object);
292 		args->new.handle = handle;
293 		args->new.oclass = oclass;
294 
295 		memcpy(args->new.data, data, size);
296 		ret = nvif_object_ioctl(parent, args, sizeof(*args) + size,
297 					&object->priv);
298 		memcpy(data, args->new.data, size);
299 		kfree(args);
300 		if (ret == 0)
301 			object->client = parent->client;
302 	}
303 
304 	if (ret)
305 		nvif_object_dtor(object);
306 	return ret;
307 }
308