[linux-2.6-block.git] / drivers / gpu / drm / nouveau / nvkm / core / object.c

/*
 * Copyright 2012 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
 */
#include <core/object.h>
#include <core/client.h>
#include <core/engine.h>

struct nvkm_object *
nvkm_object_search(struct nvkm_client *client, u64 handle,
		   const struct nvkm_object_func *func)
{
	struct nvkm_object *object;
	unsigned long flags;

	if (handle) {
		spin_lock_irqsave(&client->obj_lock, flags);
		struct rb_node *node = client->objroot.rb_node;
		while (node) {
			object = rb_entry(node, typeof(*object), node);
			if (handle < object->object)
				node = node->rb_left;
			else
			if (handle > object->object)
				node = node->rb_right;
			else {
				spin_unlock_irqrestore(&client->obj_lock, flags);
				goto done;
			}
		}
		spin_unlock_irqrestore(&client->obj_lock, flags);
		return ERR_PTR(-ENOENT);
	} else {
		object = &client->object;
	}

done:
	if (unlikely(func && object->func != func))
		return ERR_PTR(-EINVAL);
	return object;
}

void
nvkm_object_remove(struct nvkm_object *object)
{
	unsigned long flags;

	spin_lock_irqsave(&object->client->obj_lock, flags);
	if (!RB_EMPTY_NODE(&object->node))
		rb_erase(&object->node, &object->client->objroot);
	spin_unlock_irqrestore(&object->client->obj_lock, flags);
}

bool
nvkm_object_insert(struct nvkm_object *object)
{
	struct rb_node **ptr;
	struct rb_node *parent = NULL;
	unsigned long flags;

	spin_lock_irqsave(&object->client->obj_lock, flags);
	ptr = &object->client->objroot.rb_node;
	while (*ptr) {
		struct nvkm_object *this = rb_entry(*ptr, typeof(*this), node);
		parent = *ptr;
		if (object->object < this->object) {
			ptr = &parent->rb_left;
		} else if (object->object > this->object) {
			ptr = &parent->rb_right;
		} else {
			spin_unlock_irqrestore(&object->client->obj_lock, flags);
			return false;
		}
	}

	rb_link_node(&object->node, parent, ptr);
	rb_insert_color(&object->node, &object->client->objroot);
	spin_unlock_irqrestore(&object->client->obj_lock, flags);
	return true;
}

int
nvkm_object_mthd(struct nvkm_object *object, u32 mthd, void *data, u32 size)
{
	if (likely(object->func->mthd))
		return object->func->mthd(object, mthd, data, size);
	return -ENODEV;
}

int
nvkm_object_ntfy(struct nvkm_object *object, u32 mthd,
		 struct nvkm_event **pevent)
{
	if (likely(object->func->ntfy))
		return object->func->ntfy(object, mthd, pevent);
	return -ENODEV;
}

int
nvkm_object_map(struct nvkm_object *object, void *argv, u32 argc,
		enum nvkm_object_map *type, u64 *addr, u64 *size)
{
	if (likely(object->func->map))
		return object->func->map(object, argv, argc, type, addr, size);
	return -ENODEV;
}

int
nvkm_object_unmap(struct nvkm_object *object)
{
	if (likely(object->func->unmap))
		return object->func->unmap(object);
	return -ENODEV;
}

int
nvkm_object_rd08(struct nvkm_object *object, u64 addr, u8 *data)
{
	if (likely(object->func->rd08))
		return object->func->rd08(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_rd16(struct nvkm_object *object, u64 addr, u16 *data)
{
	if (likely(object->func->rd16))
		return object->func->rd16(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_rd32(struct nvkm_object *object, u64 addr, u32 *data)
{
	if (likely(object->func->rd32))
		return object->func->rd32(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_wr08(struct nvkm_object *object, u64 addr, u8 data)
{
	if (likely(object->func->wr08))
		return object->func->wr08(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_wr16(struct nvkm_object *object, u64 addr, u16 data)
{
	if (likely(object->func->wr16))
		return object->func->wr16(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_wr32(struct nvkm_object *object, u64 addr, u32 data)
{
	if (likely(object->func->wr32))
		return object->func->wr32(object, addr, data);
	return -ENODEV;
}

int
nvkm_object_bind(struct nvkm_object *object, struct nvkm_gpuobj *gpuobj,
		 int align, struct nvkm_gpuobj **pgpuobj)
{
	if (object->func->bind)
		return object->func->bind(object, gpuobj, align, pgpuobj);
	return -ENODEV;
}

int
nvkm_object_fini(struct nvkm_object *object, bool suspend)
{
	const char *action = suspend ? "suspend" : "fini";
	struct nvkm_object *child;
	s64 time;
	int ret;

	nvif_debug(object, "%s children...\n", action);
	time = ktime_to_us(ktime_get());
	list_for_each_entry_reverse(child, &object->tree, head) {
		ret = nvkm_object_fini(child, suspend);
		if (ret && suspend)
			goto fail_child;
	}

	nvif_debug(object, "%s running...\n", action);
	if (object->func->fini) {
		ret = object->func->fini(object, suspend);
		if (ret) {
			nvif_error(object, "%s failed with %d\n", action, ret);
			if (suspend)
				goto fail;
		}
	}

	time = ktime_to_us(ktime_get()) - time;
	nvif_debug(object, "%s completed in %lldus\n", action, time);
	return 0;

fail:
	if (object->func->init) {
		int rret = object->func->init(object);
		if (rret)
			nvif_fatal(object, "failed to restart, %d\n", rret);
	}
fail_child:
	list_for_each_entry_continue_reverse(child, &object->tree, head) {
		nvkm_object_init(child);
	}
	return ret;
}

int
nvkm_object_init(struct nvkm_object *object)
{
	struct nvkm_object *child;
	s64 time;
	int ret;

	nvif_debug(object, "init running...\n");
	time = ktime_to_us(ktime_get());
	if (object->func->init) {
		ret = object->func->init(object);
		if (ret)
			goto fail;
	}

	nvif_debug(object, "init children...\n");
	list_for_each_entry(child, &object->tree, head) {
		ret = nvkm_object_init(child);
		if (ret)
			goto fail_child;
	}

	time = ktime_to_us(ktime_get()) - time;
	nvif_debug(object, "init completed in %lldus\n", time);
	return 0;

fail_child:
	list_for_each_entry_continue_reverse(child, &object->tree, head)
		nvkm_object_fini(child, false);
fail:
	nvif_error(object, "init failed with %d\n", ret);
	if (object->func->fini)
		object->func->fini(object, false);
	return ret;
}

void *
nvkm_object_dtor(struct nvkm_object *object)
{
	struct nvkm_object *child, *ctemp;
	void *data = object;
	s64 time;

	nvif_debug(object, "destroy children...\n");
	time = ktime_to_us(ktime_get());
	list_for_each_entry_safe(child, ctemp, &object->tree, head) {
		nvkm_object_del(&child);
	}

	nvif_debug(object, "destroy running...\n");
	nvkm_object_unmap(object);
	if (object->func->dtor)
		data = object->func->dtor(object);
	nvkm_engine_unref(&object->engine);
	time = ktime_to_us(ktime_get()) - time;
	nvif_debug(object, "destroy completed in %lldus...\n", time);
	return data;
}

void
nvkm_object_del(struct nvkm_object **pobject)
{
	struct nvkm_object *object = *pobject;
	if (object && !WARN_ON(!object->func)) {
		*pobject = nvkm_object_dtor(object);
		nvkm_object_remove(object);
		list_del(&object->head);
		kfree(*pobject);
		*pobject = NULL;
	}
}

void
nvkm_object_ctor(const struct nvkm_object_func *func,
		 const struct nvkm_oclass *oclass, struct nvkm_object *object)
{
	object->func = func;
	object->client = oclass->client;
	object->engine = nvkm_engine_ref(oclass->engine);
	object->oclass = oclass->base.oclass;
	object->handle = oclass->handle;
	object->route  = oclass->route;
	object->token  = oclass->token;
	object->object = oclass->object;
	INIT_LIST_HEAD(&object->head);
	INIT_LIST_HEAD(&object->tree);
	RB_CLEAR_NODE(&object->node);
	WARN_ON(IS_ERR(object->engine));
}

int
nvkm_object_new_(const struct nvkm_object_func *func,
		 const struct nvkm_oclass *oclass, void *data, u32 size,
		 struct nvkm_object **pobject)
{
	if (size == 0) {
		if (!(*pobject = kzalloc(sizeof(**pobject), GFP_KERNEL)))
			return -ENOMEM;
		nvkm_object_ctor(func, oclass, *pobject);
		return 0;
	}
	return -ENOSYS;
}

static const struct nvkm_object_func
nvkm_object_func = {
};

int
nvkm_object_new(const struct nvkm_oclass *oclass, void *data, u32 size,
		struct nvkm_object **pobject)
{
	const struct nvkm_object_func *func =
		oclass->base.func ? oclass->base.func : &nvkm_object_func;
	return nvkm_object_new_(func, oclass, data, size, pobject);
}
Commit	Line	Data
9274f4a9 BS	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	*/
9274f4a9	24	#include <core/object.h>
fbd58ebd	25	#include <core/client.h>
9274f4a9 BS	26	#include <core/engine.h>
9274f4a9 BS	27
110cccff BS	28	struct nvkm_object *
	29	nvkm_object_search(struct nvkm_client *client, u64 handle,
	30	const struct nvkm_object_func *func)
	31	{
	32	struct nvkm_object *object;
b7cc4ff7	33	unsigned long flags;
110cccff BS	34
110cccff BS	35	if (handle) {
b7cc4ff7	36	spin_lock_irqsave(&client->obj_lock, flags);
110cccff BS	37	struct rb_node *node = client->objroot.rb_node;
	38	while (node) {
	39	object = rb_entry(node, typeof(*object), node);
	40	if (handle < object->object)
	41	node = node->rb_left;
	42	else
	43	if (handle > object->object)
	44	node = node->rb_right;
b7cc4ff7 DA	45	else {
b7cc4ff7 DA	46	spin_unlock_irqrestore(&client->obj_lock, flags);
110cccff	47	goto done;
b7cc4ff7	48	}
110cccff	49	}
b7cc4ff7	50	spin_unlock_irqrestore(&client->obj_lock, flags);
110cccff BS	51	return ERR_PTR(-ENOENT);
	52	} else {
	53	object = &client->object;
	54	}
	55
	56	done:
	57	if (unlikely(func && object->func != func))
	58	return ERR_PTR(-EINVAL);
	59	return object;
	60	}
	61
	62	void
	63	nvkm_object_remove(struct nvkm_object *object)
	64	{
b7cc4ff7 DA	65	unsigned long flags;
	66
	67	spin_lock_irqsave(&object->client->obj_lock, flags);
110cccff BS	68	if (!RB_EMPTY_NODE(&object->node))
110cccff BS	69	rb_erase(&object->node, &object->client->objroot);
b7cc4ff7	70	spin_unlock_irqrestore(&object->client->obj_lock, flags);
110cccff BS	71	}
	72
	73	bool
	74	nvkm_object_insert(struct nvkm_object *object)
	75	{
b7cc4ff7	76	struct rb_node **ptr;
110cccff	77	struct rb_node *parent = NULL;
b7cc4ff7	78	unsigned long flags;
110cccff	79
b7cc4ff7 DA	80	spin_lock_irqsave(&object->client->obj_lock, flags);
b7cc4ff7 DA	81	ptr = &object->client->objroot.rb_node;
110cccff BS	82	while (*ptr) {
	83	struct nvkm_object this = rb_entry(ptr, typeof(*this), node);
	84	parent = *ptr;
b7cc4ff7	85	if (object->object < this->object) {
110cccff	86	ptr = &parent->rb_left;
b7cc4ff7	87	} else if (object->object > this->object) {
110cccff	88	ptr = &parent->rb_right;
b7cc4ff7 DA	89	} else {
b7cc4ff7 DA	90	spin_unlock_irqrestore(&object->client->obj_lock, flags);
110cccff	91	return false;
b7cc4ff7	92	}
110cccff BS	93	}
	94
	95	rb_link_node(&object->node, parent, ptr);
	96	rb_insert_color(&object->node, &object->client->objroot);
b7cc4ff7	97	spin_unlock_irqrestore(&object->client->obj_lock, flags);
110cccff BS	98	return true;
	99	}
	100
cbea21e2 BS	101	int
	102	nvkm_object_mthd(struct nvkm_object object, u32 mthd, void data, u32 size)
	103	{
cbea21e2 BS	104	if (likely(object->func->mthd))
	105	return object->func->mthd(object, mthd, data, size);
	106	return -ENODEV;
	107	}
	108
	109	int
	110	nvkm_object_ntfy(struct nvkm_object *object, u32 mthd,
	111	struct nvkm_event **pevent)
	112	{
cbea21e2 BS	113	if (likely(object->func->ntfy))
	114	return object->func->ntfy(object, mthd, pevent);
	115	return -ENODEV;
	116	}
	117
	118	int
01326050 BS	119	nvkm_object_map(struct nvkm_object object, void argv, u32 argc,
01326050 BS	120	enum nvkm_object_map type, u64 addr, u64 *size)
cbea21e2	121	{
cbea21e2	122	if (likely(object->func->map))
01326050	123	return object->func->map(object, argv, argc, type, addr, size);
cbea21e2 BS	124	return -ENODEV;
	125	}
	126
8e0042d5 BS	127	int
	128	nvkm_object_unmap(struct nvkm_object *object)
	129	{
	130	if (likely(object->func->unmap))
	131	return object->func->unmap(object);
	132	return -ENODEV;
	133	}
	134
cfdc4c44 BS	135	int
	136	nvkm_object_rd08(struct nvkm_object object, u64 addr, u8 data)
	137	{
cbea21e2 BS	138	if (likely(object->func->rd08))
cbea21e2 BS	139	return object->func->rd08(object, addr, data);
cfdc4c44 BS	140	return -ENODEV;
	141	}
	142
	143	int
	144	nvkm_object_rd16(struct nvkm_object object, u64 addr, u16 data)
	145	{
cbea21e2 BS	146	if (likely(object->func->rd16))
cbea21e2 BS	147	return object->func->rd16(object, addr, data);
cfdc4c44 BS	148	return -ENODEV;
	149	}
	150
	151	int
	152	nvkm_object_rd32(struct nvkm_object object, u64 addr, u32 data)
	153	{
cbea21e2 BS	154	if (likely(object->func->rd32))
cbea21e2 BS	155	return object->func->rd32(object, addr, data);
cfdc4c44 BS	156	return -ENODEV;
	157	}
	158
	159	int
	160	nvkm_object_wr08(struct nvkm_object *object, u64 addr, u8 data)
	161	{
cbea21e2 BS	162	if (likely(object->func->wr08))
cbea21e2 BS	163	return object->func->wr08(object, addr, data);
cfdc4c44 BS	164	return -ENODEV;
	165	}
	166
	167	int
	168	nvkm_object_wr16(struct nvkm_object *object, u64 addr, u16 data)
	169	{
cbea21e2 BS	170	if (likely(object->func->wr16))
cbea21e2 BS	171	return object->func->wr16(object, addr, data);
cfdc4c44 BS	172	return -ENODEV;
	173	}
	174
	175	int
	176	nvkm_object_wr32(struct nvkm_object *object, u64 addr, u32 data)
	177	{
cbea21e2 BS	178	if (likely(object->func->wr32))
cbea21e2 BS	179	return object->func->wr32(object, addr, data);
cfdc4c44 BS	180	return -ENODEV;
	181	}
	182
cbea21e2 BS	183	int
	184	nvkm_object_bind(struct nvkm_object object, struct nvkm_gpuobj gpuobj,
	185	int align, struct nvkm_gpuobj **pgpuobj)
	186	{
cbea21e2 BS	187	if (object->func->bind)
	188	return object->func->bind(object, gpuobj, align, pgpuobj);
	189	return -ENODEV;
	190	}
	191
	192	int
	193	nvkm_object_fini(struct nvkm_object *object, bool suspend)
	194	{
fbd58ebd BS	195	const char *action = suspend ? "suspend" : "fini";
	196	struct nvkm_object *child;
	197	s64 time;
	198	int ret;
	199
	200	nvif_debug(object, "%s children...\n", action);
	201	time = ktime_to_us(ktime_get());
83775e15	202	list_for_each_entry_reverse(child, &object->tree, head) {
fbd58ebd BS	203	ret = nvkm_object_fini(child, suspend);
	204	if (ret && suspend)
	205	goto fail_child;
	206	}
	207
	208	nvif_debug(object, "%s running...\n", action);
	209	if (object->func->fini) {
	210	ret = object->func->fini(object, suspend);
	211	if (ret) {
	212	nvif_error(object, "%s failed with %d\n", action, ret);
	213	if (suspend)
	214	goto fail;
	215	}
	216	}
	217
	218	time = ktime_to_us(ktime_get()) - time;
	219	nvif_debug(object, "%s completed in %lldus\n", action, time);
cbea21e2	220	return 0;
fbd58ebd BS	221
	222	fail:
	223	if (object->func->init) {
	224	int rret = object->func->init(object);
	225	if (rret)
	226	nvif_fatal(object, "failed to restart, %d\n", rret);
	227	}
	228	fail_child:
	229	list_for_each_entry_continue_reverse(child, &object->tree, head) {
	230	nvkm_object_init(child);
	231	}
	232	return ret;
cbea21e2 BS	233	}
	234
	235	int
	236	nvkm_object_init(struct nvkm_object *object)
	237	{
fbd58ebd BS	238	struct nvkm_object *child;
	239	s64 time;
	240	int ret;
	241
	242	nvif_debug(object, "init running...\n");
	243	time = ktime_to_us(ktime_get());
	244	if (object->func->init) {
	245	ret = object->func->init(object);
	246	if (ret)
	247	goto fail;
	248	}
	249
	250	nvif_debug(object, "init children...\n");
	251	list_for_each_entry(child, &object->tree, head) {
	252	ret = nvkm_object_init(child);
	253	if (ret)
	254	goto fail_child;
	255	}
	256
	257	time = ktime_to_us(ktime_get()) - time;
	258	nvif_debug(object, "init completed in %lldus\n", time);
cbea21e2	259	return 0;
fbd58ebd BS	260
	261	fail_child:
	262	list_for_each_entry_continue_reverse(child, &object->tree, head)
	263	nvkm_object_fini(child, false);
	264	fail:
	265	nvif_error(object, "init failed with %d\n", ret);
	266	if (object->func->fini)
	267	object->func->fini(object, false);
	268	return ret;
cbea21e2 BS	269	}
cbea21e2 BS	270
fbd58ebd BS	271	void *
	272	nvkm_object_dtor(struct nvkm_object *object)
	273	{
	274	struct nvkm_object child, ctemp;
	275	void *data = object;
	276	s64 time;
	277
	278	nvif_debug(object, "destroy children...\n");
	279	time = ktime_to_us(ktime_get());
	280	list_for_each_entry_safe(child, ctemp, &object->tree, head) {
	281	nvkm_object_del(&child);
	282	}
	283
	284	nvif_debug(object, "destroy running...\n");
8e0042d5	285	nvkm_object_unmap(object);
fbd58ebd BS	286	if (object->func->dtor)
	287	data = object->func->dtor(object);
	288	nvkm_engine_unref(&object->engine);
	289	time = ktime_to_us(ktime_get()) - time;
	290	nvif_debug(object, "destroy completed in %lldus...\n", time);
	291	return data;
	292	}
	293
	294	void
cbea21e2 BS	295	nvkm_object_del(struct nvkm_object **pobject)
	296	{
	297	struct nvkm_object object = pobject;
cbea21e2	298	if (object && !WARN_ON(!object->func)) {
fbd58ebd	299	*pobject = nvkm_object_dtor(object);
110cccff	300	nvkm_object_remove(object);
fbd58ebd	301	list_del(&object->head);
cbea21e2 BS	302	kfree(*pobject);
	303	*pobject = NULL;
	304	}
	305	}
	306
	307	void
	308	nvkm_object_ctor(const struct nvkm_object_func *func,
	309	const struct nvkm_oclass oclass, struct nvkm_object object)
	310	{
	311	object->func = func;
	312	object->client = oclass->client;
6cf813fb	313	object->engine = nvkm_engine_ref(oclass->engine);
68f3f702	314	object->oclass = oclass->base.oclass;
cbea21e2	315	object->handle = oclass->handle;
843faa03 BS	316	object->route = oclass->route;
	317	object->token = oclass->token;
	318	object->object = oclass->object;
fbd58ebd BS	319	INIT_LIST_HEAD(&object->head);
	320	INIT_LIST_HEAD(&object->tree);
	321	RB_CLEAR_NODE(&object->node);
89ed10a5	322	WARN_ON(IS_ERR(object->engine));
cbea21e2 BS	323	}
	324
	325	int
	326	nvkm_object_new_(const struct nvkm_object_func *func,
	327	const struct nvkm_oclass oclass, void data, u32 size,
	328	struct nvkm_object **pobject)
	329	{
	330	if (size == 0) {
	331	if (!(pobject = kzalloc(sizeof(*pobject), GFP_KERNEL)))
	332	return -ENOMEM;
	333	nvkm_object_ctor(func, oclass, *pobject);
	334	return 0;
	335	}
	336	return -ENOSYS;
	337	}
	338
	339	static const struct nvkm_object_func
	340	nvkm_object_func = {
	341	};
	342
	343	int
	344	nvkm_object_new(const struct nvkm_oclass oclass, void data, u32 size,
	345	struct nvkm_object **pobject)
	346	{
	347	const struct nvkm_object_func *func =
	348	oclass->base.func ? oclass->base.func : &nvkm_object_func;
	349	return nvkm_object_new_(func, oclass, data, size, pobject);
	350	}