[linux-2.6-block.git] / drivers / gpu / drm / nouveau / nouveau_usif.c

/*
 * Copyright 2014 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs <bskeggs@redhat.com>
 */

#include "nouveau_drv.h"
#include "nouveau_usif.h"
#include "nouveau_abi16.h"

#include <nvif/unpack.h>
#include <nvif/client.h>
#include <nvif/ioctl.h>

#include <nvif/class.h>
#include <nvif/cl0080.h>

struct usif_object {
	struct list_head head;
	u8  route;
	u64 token;
};

static void
usif_object_dtor(struct usif_object *object)
{
	list_del(&object->head);
	kfree(object);
}

static int
usif_object_new(struct drm_file *f, void *data, u32 size, void *argv, u32 argc, bool parent_abi16)
{
	struct nouveau_cli *cli = nouveau_cli(f);
	struct nvif_client *client = &cli->base;
	union {
		struct nvif_ioctl_new_v0 v0;
	} *args = data;
	struct usif_object *object;
	int ret = -ENOSYS;

	if ((ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, true)))
		return ret;

	switch (args->v0.oclass) {
	case NV_DMA_FROM_MEMORY:
	case NV_DMA_TO_MEMORY:
	case NV_DMA_IN_MEMORY:
		return -EINVAL;
	case NV_DEVICE: {
		union {
			struct nv_device_v0 v0;
		} *args = data;

		if ((ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, false)))
			return ret;

		args->v0.priv = false;
		break;
	}
	default:
		if (!parent_abi16)
			return -EINVAL;
		break;
	}

	if (!(object = kmalloc(sizeof(*object), GFP_KERNEL)))
		return -ENOMEM;
	list_add(&object->head, &cli->objects);

	object->route = args->v0.route;
	object->token = args->v0.token;
	args->v0.route = NVDRM_OBJECT_USIF;
	args->v0.token = (unsigned long)(void *)object;
	ret = nvif_client_ioctl(client, argv, argc);
	if (ret) {
		usif_object_dtor(object);
		return ret;
	}

	args->v0.token = object->token;
	args->v0.route = object->route;
	return 0;
}

int
usif_ioctl(struct drm_file *filp, void __user *user, u32 argc)
{
	struct nouveau_cli *cli = nouveau_cli(filp);
	struct nvif_client *client = &cli->base;
	void *data = kmalloc(argc, GFP_KERNEL);
	u32   size = argc;
	union {
		struct nvif_ioctl_v0 v0;
	} *argv = data;
	struct usif_object *object;
	bool abi16 = false;
	u8 owner;
	int ret;

	if (ret = -ENOMEM, !argv)
		goto done;
	if (ret = -EFAULT, copy_from_user(argv, user, size))
		goto done;

	if (!(ret = nvif_unpack(-ENOSYS, &data, &size, argv->v0, 0, 0, true))) {
		/* block access to objects not created via this interface */
		owner = argv->v0.owner;
		if (argv->v0.object == 0ULL &&
		    argv->v0.type != NVIF_IOCTL_V0_DEL)
			argv->v0.owner = NVDRM_OBJECT_ANY; /* except client */
		else
			argv->v0.owner = NVDRM_OBJECT_USIF;
	} else
		goto done;

	/* USIF slightly abuses some return-only ioctl members in order
	 * to provide interoperability with the older ABI16 objects
	 */
	mutex_lock(&cli->mutex);
	if (argv->v0.route) {
		if (ret = -EINVAL, argv->v0.route == 0xff)
			ret = nouveau_abi16_usif(filp, argv, argc);
		if (ret) {
			mutex_unlock(&cli->mutex);
			goto done;
		}

		abi16 = true;
	}

	switch (argv->v0.type) {
	case NVIF_IOCTL_V0_NEW:
		ret = usif_object_new(filp, data, size, argv, argc, abi16);
		break;
	case NVIF_IOCTL_V0_NTFY_NEW:
	case NVIF_IOCTL_V0_NTFY_DEL:
	case NVIF_IOCTL_V0_NTFY_GET:
	case NVIF_IOCTL_V0_NTFY_PUT:
		ret = -ENOSYS;
		break;
	default:
		ret = nvif_client_ioctl(client, argv, argc);
		break;
	}
	if (argv->v0.route == NVDRM_OBJECT_USIF) {
		object = (void *)(unsigned long)argv->v0.token;
		argv->v0.route = object->route;
		argv->v0.token = object->token;
		if (ret == 0 && argv->v0.type == NVIF_IOCTL_V0_DEL) {
			list_del(&object->head);
			kfree(object);
		}
	} else {
		argv->v0.route = NVIF_IOCTL_V0_ROUTE_HIDDEN;
		argv->v0.token = 0;
	}
	argv->v0.owner = owner;
	mutex_unlock(&cli->mutex);

	if (copy_to_user(user, argv, argc))
		ret = -EFAULT;
done:
	kfree(argv);
	return ret;
}

void
usif_client_fini(struct nouveau_cli *cli)
{
	struct usif_object *object, *otemp;

	list_for_each_entry_safe(object, otemp, &cli->objects, head) {
		usif_object_dtor(object);
	}
}

void
usif_client_init(struct nouveau_cli *cli)
{
	INIT_LIST_HEAD(&cli->objects);
}
Commit	Line	Data
27111a23 BS	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
4dc28134	25	#include "nouveau_drv.h"
27111a23	26	#include "nouveau_usif.h"
2621a416	27	#include "nouveau_abi16.h"
27111a23	28
27111a23 BS	29	#include <nvif/unpack.h>
27111a23 BS	30	#include <nvif/client.h>
27111a23 BS	31	#include <nvif/ioctl.h>
27111a23 BS	32
148a8653 BS	33	#include <nvif/class.h>
	34	#include <nvif/cl0080.h>
	35
27111a23 BS	36	struct usif_object {
27111a23 BS	37	struct list_head head;
27111a23 BS	38	u8 route;
	39	u64 token;
	40	};
	41
	42	static void
	43	usif_object_dtor(struct usif_object *object)
	44	{
	45	list_del(&object->head);
	46	kfree(object);
	47	}
	48
	49	static int
148a8653	50	usif_object_new(struct drm_file f, void data, u32 size, void *argv, u32 argc, bool parent_abi16)
27111a23 BS	51	{
	52	struct nouveau_cli *cli = nouveau_cli(f);
	53	struct nvif_client *client = &cli->base;
	54	union {
	55	struct nvif_ioctl_new_v0 v0;
	56	} *args = data;
	57	struct usif_object *object;
f01c4e68	58	int ret = -ENOSYS;
27111a23	59
148a8653 BS	60	if ((ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, true)))
	61	return ret;
	62
	63	switch (args->v0.oclass) {
	64	case NV_DMA_FROM_MEMORY:
	65	case NV_DMA_TO_MEMORY:
	66	case NV_DMA_IN_MEMORY:
	67	return -EINVAL;
	68	case NV_DEVICE: {
	69	union {
	70	struct nv_device_v0 v0;
	71	} *args = data;
	72
	73	if ((ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, false)))
	74	return ret;
	75
	76	args->v0.priv = false;
	77	break;
	78	}
	79	default:
	80	if (!parent_abi16)
	81	return -EINVAL;
	82	break;
	83	}
	84
27111a23 BS	85	if (!(object = kmalloc(sizeof(*object), GFP_KERNEL)))
	86	return -ENOMEM;
	87	list_add(&object->head, &cli->objects);
	88
148a8653 BS	89	object->route = args->v0.route;
	90	object->token = args->v0.token;
	91	args->v0.route = NVDRM_OBJECT_USIF;
	92	args->v0.token = (unsigned long)(void *)object;
	93	ret = nvif_client_ioctl(client, argv, argc);
	94	if (ret) {
	95	usif_object_dtor(object);
	96	return ret;
27111a23 BS	97	}
27111a23 BS	98
148a8653 BS	99	args->v0.token = object->token;
	100	args->v0.route = object->route;
	101	return 0;
27111a23 BS	102	}
	103
	104	int
	105	usif_ioctl(struct drm_file filp, void __user user, u32 argc)
	106	{
	107	struct nouveau_cli *cli = nouveau_cli(filp);
	108	struct nvif_client *client = &cli->base;
	109	void *data = kmalloc(argc, GFP_KERNEL);
	110	u32 size = argc;
	111	union {
	112	struct nvif_ioctl_v0 v0;
	113	} *argv = data;
	114	struct usif_object *object;
148a8653	115	bool abi16 = false;
27111a23 BS	116	u8 owner;
	117	int ret;
	118
	119	if (ret = -ENOMEM, !argv)
	120	goto done;
	121	if (ret = -EFAULT, copy_from_user(argv, user, size))
	122	goto done;
	123
f01c4e68	124	if (!(ret = nvif_unpack(-ENOSYS, &data, &size, argv->v0, 0, 0, true))) {
27111a23 BS	125	/* block access to objects not created via this interface */
27111a23 BS	126	owner = argv->v0.owner;
c966b627 BS	127	if (argv->v0.object == 0ULL &&
c966b627 BS	128	argv->v0.type != NVIF_IOCTL_V0_DEL)
f5e55187 BS	129	argv->v0.owner = NVDRM_OBJECT_ANY; /* except client */
	130	else
	131	argv->v0.owner = NVDRM_OBJECT_USIF;
27111a23 BS	132	} else
	133	goto done;
	134
2621a416 BS	135	/* USIF slightly abuses some return-only ioctl members in order
	136	* to provide interoperability with the older ABI16 objects
	137	*/
27111a23	138	mutex_lock(&cli->mutex);
2621a416 BS	139	if (argv->v0.route) {
	140	if (ret = -EINVAL, argv->v0.route == 0xff)
	141	ret = nouveau_abi16_usif(filp, argv, argc);
	142	if (ret) {
	143	mutex_unlock(&cli->mutex);
	144	goto done;
	145	}
148a8653 BS	146
148a8653 BS	147	abi16 = true;
2621a416 BS	148	}
2621a416 BS	149
27111a23 BS	150	switch (argv->v0.type) {
27111a23 BS	151	case NVIF_IOCTL_V0_NEW:
148a8653	152	ret = usif_object_new(filp, data, size, argv, argc, abi16);
27111a23 BS	153	break;
27111a23 BS	154	case NVIF_IOCTL_V0_NTFY_NEW:
27111a23	155	case NVIF_IOCTL_V0_NTFY_DEL:
27111a23	156	case NVIF_IOCTL_V0_NTFY_GET:
27111a23	157	case NVIF_IOCTL_V0_NTFY_PUT:
c4feba47	158	ret = -ENOSYS;
27111a23 BS	159	break;
	160	default:
	161	ret = nvif_client_ioctl(client, argv, argc);
	162	break;
	163	}
	164	if (argv->v0.route == NVDRM_OBJECT_USIF) {
	165	object = (void *)(unsigned long)argv->v0.token;
	166	argv->v0.route = object->route;
	167	argv->v0.token = object->token;
	168	if (ret == 0 && argv->v0.type == NVIF_IOCTL_V0_DEL) {
	169	list_del(&object->head);
	170	kfree(object);
	171	}
	172	} else {
	173	argv->v0.route = NVIF_IOCTL_V0_ROUTE_HIDDEN;
	174	argv->v0.token = 0;
	175	}
	176	argv->v0.owner = owner;
	177	mutex_unlock(&cli->mutex);
	178
	179	if (copy_to_user(user, argv, argc))
	180	ret = -EFAULT;
	181	done:
	182	kfree(argv);
	183	return ret;
	184	}
	185
	186	void
	187	usif_client_fini(struct nouveau_cli *cli)
	188	{
	189	struct usif_object object, otemp;
27111a23 BS	190
	191	list_for_each_entry_safe(object, otemp, &cli->objects, head) {
	192	usif_object_dtor(object);
	193	}
	194	}
	195
	196	void
	197	usif_client_init(struct nouveau_cli *cli)
	198	{
	199	INIT_LIST_HEAD(&cli->objects);
27111a23	200	}