[mirror_ubuntu-bionic-kernel.git] / drivers / dma-buf / seqno-fence.c

/*
 * seqno-fence, using a dma-buf to synchronize fencing
 *
 * Copyright (C) 2012 Texas Instruments
 * Copyright (C) 2012-2014 Canonical Ltd
 * Authors:
 *   Rob Clark <robdclark@gmail.com>
 *   Maarten Lankhorst <maarten.lankhorst@canonical.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#include <linux/slab.h>
#include <linux/export.h>
#include <linux/seqno-fence.h>

static const char *seqno_fence_get_driver_name(struct dma_fence *fence)
{
	struct seqno_fence *seqno_fence = to_seqno_fence(fence);

	return seqno_fence->ops->get_driver_name(fence);
}

static const char *seqno_fence_get_timeline_name(struct dma_fence *fence)
{
	struct seqno_fence *seqno_fence = to_seqno_fence(fence);

	return seqno_fence->ops->get_timeline_name(fence);
}

static bool seqno_enable_signaling(struct dma_fence *fence)
{
	struct seqno_fence *seqno_fence = to_seqno_fence(fence);

	return seqno_fence->ops->enable_signaling(fence);
}

static bool seqno_signaled(struct dma_fence *fence)
{
	struct seqno_fence *seqno_fence = to_seqno_fence(fence);

	return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence);
}

static void seqno_release(struct dma_fence *fence)
{
	struct seqno_fence *f = to_seqno_fence(fence);

	dma_buf_put(f->sync_buf);
	if (f->ops->release)
		f->ops->release(fence);
	else
		dma_fence_free(&f->base);
}

static signed long seqno_wait(struct dma_fence *fence, bool intr,
			      signed long timeout)
{
	struct seqno_fence *f = to_seqno_fence(fence);

	return f->ops->wait(fence, intr, timeout);
}

const struct dma_fence_ops seqno_fence_ops = {
	.get_driver_name = seqno_fence_get_driver_name,
	.get_timeline_name = seqno_fence_get_timeline_name,
	.enable_signaling = seqno_enable_signaling,
	.signaled = seqno_signaled,
	.wait = seqno_wait,
	.release = seqno_release,
};
EXPORT_SYMBOL(seqno_fence_ops);
Commit	Line	Data
606b23ad ML	1	/*
	2	* seqno-fence, using a dma-buf to synchronize fencing
	3	*
	4	* Copyright (C) 2012 Texas Instruments
	5	* Copyright (C) 2012-2014 Canonical Ltd
	6	* Authors:
	7	* Rob Clark <robdclark@gmail.com>
	8	* Maarten Lankhorst <maarten.lankhorst@canonical.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License version 2 as published by
	12	* the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18	*/
	19
	20	#include <linux/slab.h>
	21	#include <linux/export.h>
	22	#include <linux/seqno-fence.h>
	23
f54d1867	24	static const char seqno_fence_get_driver_name(struct dma_fence fence)
606b23ad ML	25	{
606b23ad ML	26	struct seqno_fence *seqno_fence = to_seqno_fence(fence);
5136629d	27
606b23ad ML	28	return seqno_fence->ops->get_driver_name(fence);
	29	}
	30
f54d1867	31	static const char seqno_fence_get_timeline_name(struct dma_fence fence)
606b23ad ML	32	{
606b23ad ML	33	struct seqno_fence *seqno_fence = to_seqno_fence(fence);
5136629d	34
606b23ad ML	35	return seqno_fence->ops->get_timeline_name(fence);
	36	}
	37
f54d1867	38	static bool seqno_enable_signaling(struct dma_fence *fence)
606b23ad ML	39	{
606b23ad ML	40	struct seqno_fence *seqno_fence = to_seqno_fence(fence);
5136629d	41
606b23ad ML	42	return seqno_fence->ops->enable_signaling(fence);
	43	}
	44
f54d1867	45	static bool seqno_signaled(struct dma_fence *fence)
606b23ad ML	46	{
606b23ad ML	47	struct seqno_fence *seqno_fence = to_seqno_fence(fence);
5136629d	48
606b23ad ML	49	return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence);
	50	}
	51
f54d1867	52	static void seqno_release(struct dma_fence *fence)
606b23ad ML	53	{
	54	struct seqno_fence *f = to_seqno_fence(fence);
	55
	56	dma_buf_put(f->sync_buf);
	57	if (f->ops->release)
	58	f->ops->release(fence);
	59	else
f54d1867	60	dma_fence_free(&f->base);
606b23ad ML	61	}
606b23ad ML	62
f54d1867 CW	63	static signed long seqno_wait(struct dma_fence *fence, bool intr,
f54d1867 CW	64	signed long timeout)
606b23ad ML	65	{
606b23ad ML	66	struct seqno_fence *f = to_seqno_fence(fence);
5136629d	67
606b23ad ML	68	return f->ops->wait(fence, intr, timeout);
	69	}
	70
f54d1867	71	const struct dma_fence_ops seqno_fence_ops = {
606b23ad ML	72	.get_driver_name = seqno_fence_get_driver_name,
	73	.get_timeline_name = seqno_fence_get_timeline_name,
	74	.enable_signaling = seqno_enable_signaling,
	75	.signaled = seqno_signaled,
	76	.wait = seqno_wait,
	77	.release = seqno_release,
	78	};
	79	EXPORT_SYMBOL(seqno_fence_ops);