[linux-2.6-block.git] / drivers / gpu / drm / nouveau / core / core / notify.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 <core/client.h>
#include <core/event.h>
#include <core/notify.h>

#include <nvif/unpack.h>
#include <nvif/event.h>

static inline void
nvkm_notify_put_locked(struct nvkm_notify *notify)
{
	if (notify->block++ == 0)
		nvkm_event_put(notify->event, notify->types, notify->index);
}

void
nvkm_notify_put(struct nvkm_notify *notify)
{
	struct nvkm_event *event = notify->event;
	unsigned long flags;
	if (likely(event) &&
	    test_and_clear_bit(NVKM_NOTIFY_USER, &notify->flags)) {
		spin_lock_irqsave(&event->refs_lock, flags);
		nvkm_notify_put_locked(notify);
		spin_unlock_irqrestore(&event->refs_lock, flags);
		if (test_bit(NVKM_NOTIFY_WORK, &notify->flags))
			flush_work(&notify->work);
	}
}

static inline void
nvkm_notify_get_locked(struct nvkm_notify *notify)
{
	if (--notify->block == 0)
		nvkm_event_get(notify->event, notify->types, notify->index);
}

void
nvkm_notify_get(struct nvkm_notify *notify)
{
	struct nvkm_event *event = notify->event;
	unsigned long flags;
	if (likely(event) &&
	    !test_and_set_bit(NVKM_NOTIFY_USER, &notify->flags)) {
		spin_lock_irqsave(&event->refs_lock, flags);
		nvkm_notify_get_locked(notify);
		spin_unlock_irqrestore(&event->refs_lock, flags);
	}
}

static inline void
nvkm_notify_func(struct nvkm_notify *notify)
{
	struct nvkm_event *event = notify->event;
	int ret = notify->func(notify);
	unsigned long flags;
	if ((ret == NVKM_NOTIFY_KEEP) ||
	    !test_and_clear_bit(NVKM_NOTIFY_USER, &notify->flags)) {
		spin_lock_irqsave(&event->refs_lock, flags);
		nvkm_notify_get_locked(notify);
		spin_unlock_irqrestore(&event->refs_lock, flags);
	}
}

static void
nvkm_notify_work(struct work_struct *work)
{
	struct nvkm_notify *notify = container_of(work, typeof(*notify), work);
	nvkm_notify_func(notify);
}

void
nvkm_notify_send(struct nvkm_notify *notify, void *data, u32 size)
{
	struct nvkm_event *event = notify->event;
	unsigned long flags;

	assert_spin_locked(&event->list_lock);
	BUG_ON(size != notify->size);

	spin_lock_irqsave(&event->refs_lock, flags);
	if (notify->block) {
		spin_unlock_irqrestore(&event->refs_lock, flags);
		return;
	}
	nvkm_notify_put_locked(notify);
	spin_unlock_irqrestore(&event->refs_lock, flags);

	if (test_bit(NVKM_NOTIFY_WORK, &notify->flags)) {
		memcpy((void *)notify->data, data, size);
		schedule_work(&notify->work);
	} else {
		notify->data = data;
		nvkm_notify_func(notify);
		notify->data = NULL;
	}
}

void
nvkm_notify_fini(struct nvkm_notify *notify)
{
	unsigned long flags;
	if (notify->event) {
		nvkm_notify_put(notify);
		spin_lock_irqsave(&notify->event->list_lock, flags);
		list_del(&notify->head);
		spin_unlock_irqrestore(&notify->event->list_lock, flags);
		kfree((void *)notify->data);
		notify->event = NULL;
	}
}

int
nvkm_notify_init(struct nouveau_object *object, struct nvkm_event *event,
		 int (*func)(struct nvkm_notify *), bool work,
		 void *data, u32 size, u32 reply,
		 struct nvkm_notify *notify)
{
	unsigned long flags;
	int ret = -ENODEV;
	if ((notify->event = event), event->refs) {
		ret = event->func->ctor(object, data, size, notify);
		if (ret == 0 && (ret = -EINVAL, notify->size == reply)) {
			notify->flags = 0;
			notify->block = 1;
			notify->func = func;
			notify->data = NULL;
			if (ret = 0, work) {
				INIT_WORK(&notify->work, nvkm_notify_work);
				set_bit(NVKM_NOTIFY_WORK, &notify->flags);
				notify->data = kmalloc(reply, GFP_KERNEL);
				if (!notify->data)
					ret = -ENOMEM;
			}
		}
		if (ret == 0) {
			spin_lock_irqsave(&event->list_lock, flags);
			list_add_tail(&notify->head, &event->list);
			spin_unlock_irqrestore(&event->list_lock, flags);
		}
	}
	if (ret)
		notify->event = NULL;
	return ret;
}
Commit	Line	Data
79ca2770 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
8ec2a6ec	25	#include <core/client.h>
79ca2770 BS	26	#include <core/event.h>
	27	#include <core/notify.h>
	28
8ec2a6ec BS	29	#include <nvif/unpack.h>
	30	#include <nvif/event.h>
	31
79ca2770 BS	32	static inline void
	33	nvkm_notify_put_locked(struct nvkm_notify *notify)
	34	{
	35	if (notify->block++ == 0)
	36	nvkm_event_put(notify->event, notify->types, notify->index);
	37	}
	38
	39	void
	40	nvkm_notify_put(struct nvkm_notify *notify)
	41	{
	42	struct nvkm_event *event = notify->event;
	43	unsigned long flags;
	44	if (likely(event) &&
	45	test_and_clear_bit(NVKM_NOTIFY_USER, &notify->flags)) {
	46	spin_lock_irqsave(&event->refs_lock, flags);
	47	nvkm_notify_put_locked(notify);
	48	spin_unlock_irqrestore(&event->refs_lock, flags);
	49	if (test_bit(NVKM_NOTIFY_WORK, &notify->flags))
	50	flush_work(&notify->work);
	51	}
	52	}
	53
	54	static inline void
	55	nvkm_notify_get_locked(struct nvkm_notify *notify)
	56	{
	57	if (--notify->block == 0)
	58	nvkm_event_get(notify->event, notify->types, notify->index);
	59	}
	60
	61	void
	62	nvkm_notify_get(struct nvkm_notify *notify)
	63	{
	64	struct nvkm_event *event = notify->event;
	65	unsigned long flags;
	66	if (likely(event) &&
	67	!test_and_set_bit(NVKM_NOTIFY_USER, &notify->flags)) {
	68	spin_lock_irqsave(&event->refs_lock, flags);
	69	nvkm_notify_get_locked(notify);
	70	spin_unlock_irqrestore(&event->refs_lock, flags);
	71	}
	72	}
	73
	74	static inline void
	75	nvkm_notify_func(struct nvkm_notify *notify)
	76	{
	77	struct nvkm_event *event = notify->event;
	78	int ret = notify->func(notify);
	79	unsigned long flags;
	80	if ((ret == NVKM_NOTIFY_KEEP) \|\|
	81	!test_and_clear_bit(NVKM_NOTIFY_USER, &notify->flags)) {
	82	spin_lock_irqsave(&event->refs_lock, flags);
	83	nvkm_notify_get_locked(notify);
	84	spin_unlock_irqrestore(&event->refs_lock, flags);
	85	}
	86	}
	87
	88	static void
	89	nvkm_notify_work(struct work_struct *work)
	90	{
	91	struct nvkm_notify notify = container_of(work, typeof(notify), work);
	92	nvkm_notify_func(notify);
	93	}
	94
	95	void
96	nvkm_notify_send(struct nvkm_notify notify, void data, u32 size)
97	{
98	struct nvkm_event *event = notify->event;
99	unsigned long flags;
100
ff4c0d52	101	assert_spin_locked(&event->list_lock);
79ca2770 BS	102	BUG_ON(size != notify->size);
	103
	104	spin_lock_irqsave(&event->refs_lock, flags);
	105	if (notify->block) {
	106	spin_unlock_irqrestore(&event->refs_lock, flags);
	107	return;
	108	}
	109	nvkm_notify_put_locked(notify);
	110	spin_unlock_irqrestore(&event->refs_lock, flags);
	111
	112	if (test_bit(NVKM_NOTIFY_WORK, &notify->flags)) {
	113	memcpy((void *)notify->data, data, size);
	114	schedule_work(&notify->work);
	115	} else {
	116	notify->data = data;
	117	nvkm_notify_func(notify);
	118	notify->data = NULL;
	119	}
	120	}
	121
	122	void
	123	nvkm_notify_fini(struct nvkm_notify *notify)
	124	{
	125	unsigned long flags;
	126	if (notify->event) {
	127	nvkm_notify_put(notify);
	128	spin_lock_irqsave(&notify->event->list_lock, flags);
	129	list_del(&notify->head);
	130	spin_unlock_irqrestore(&notify->event->list_lock, flags);
	131	kfree((void *)notify->data);
	132	notify->event = NULL;
	133	}
	134	}
	135
	136	int
996f5a08 BS	137	nvkm_notify_init(struct nouveau_object object, struct nvkm_event event,
	138	int (func)(struct nvkm_notify ), bool work,
	139	void *data, u32 size, u32 reply,
79ca2770 BS	140	struct nvkm_notify *notify)
	141	{
	142	unsigned long flags;
	143	int ret = -ENODEV;
	144	if ((notify->event = event), event->refs) {
996f5a08	145	ret = event->func->ctor(object, data, size, notify);
79ca2770 BS	146	if (ret == 0 && (ret = -EINVAL, notify->size == reply)) {
	147	notify->flags = 0;
	148	notify->block = 1;
	149	notify->func = func;
	150	notify->data = NULL;
	151	if (ret = 0, work) {
	152	INIT_WORK(&notify->work, nvkm_notify_work);
	153	set_bit(NVKM_NOTIFY_WORK, &notify->flags);
	154	notify->data = kmalloc(reply, GFP_KERNEL);
	155	if (!notify->data)
	156	ret = -ENOMEM;
	157	}
	158	}
	159	if (ret == 0) {
	160	spin_lock_irqsave(&event->list_lock, flags);
	161	list_add_tail(&notify->head, &event->list);
	162	spin_unlock_irqrestore(&event->list_lock, flags);
	163	}
	164	}
	165	if (ret)
	166	notify->event = NULL;
	167	return ret;
	168	}