hal/os/linux/kernel/gc_hal_kernel_sync.c - imx-gpu-viv-ko - Git at Google

 /****************************************************************************
 *
 *    The MIT License (MIT)
 *
 *    Copyright (c) 2014 - 2020 Vivante Corporation
 *
 *    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
 *    AUTHORS OR COPYRIGHT HOLDERS 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.
 *
 *****************************************************************************
 *
 *    The GPL License (GPL)
 *
 *    Copyright (C) 2014 - 2020 Vivante Corporation
 *
 *    This program is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU General Public License
 *    as published by the Free Software Foundation; either version 2
 *    of the License, or (at your option) any later version.
 *
 *    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.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software Foundation,
 *    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *****************************************************************************
 *
 *    Note: This software is released under dual MIT and GPL licenses. A
 *    recipient may use this file under the terms of either the MIT license or
 *    GPL License. If you wish to use only one license not the other, you can
 *    indicate your decision by deleting one of the above license notices in your
 *    version of this file.
 *
 *****************************************************************************/


 #include <gc_hal.h>
 #include <gc_hal_base.h>

 #if gcdLINUX_SYNC_FILE

 #include <linux/kernel.h>
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/uaccess.h>
 #include <linux/slab.h>

 #include "gc_hal_kernel_sync.h"
 #include "gc_hal_kernel_linux.h"

 #ifndef CONFIG_SYNC_FILE

 static struct sync_pt * viv_sync_pt_dup(struct sync_pt *sync_pt)
 {
     gceSTATUS status;
     struct viv_sync_pt *pt;
     struct viv_sync_pt *src;
     struct viv_sync_timeline *obj;

     src = (struct viv_sync_pt *)sync_pt;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
     obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
 #else
     obj = (struct viv_sync_timeline *)sync_pt->parent;
 #endif

     /* Create the new sync_pt. */
     pt = (struct viv_sync_pt *)
         sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));

     pt->stamp  = src->stamp;

     /* Reference signal. */
     status = gckOS_MapSignal(obj->os,
                              src->signal,
                              gcvNULL /* (gctHANDLE) _GetProcessID() */,
                              &pt->signal);

     if (gcmIS_ERROR(status)) {
         sync_pt_free((struct sync_pt *)pt);
         return NULL;
     }

     return (struct sync_pt *)pt;
 }

 static int viv_sync_pt_has_signaled(struct sync_pt *sync_pt)
 {
     gceSTATUS status;
     struct viv_sync_pt *pt;
     struct viv_sync_timeline *obj;

     pt  = (struct viv_sync_pt *)sync_pt;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
     obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
 #else
     obj = (struct viv_sync_timeline *)sync_pt->parent;
 #endif

     status = _QuerySignal(obj->os, pt->signal);

     if (gcmIS_ERROR(status)) {
         /* Error. */
         return -1;
     }

     return (int) status;
 }

 static int viv_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
 {
     int ret;
     struct viv_sync_pt *pt1 = (struct viv_sync_pt *)a;
     struct viv_sync_pt *pt2 = (struct viv_sync_pt *)b;

     ret = (pt1->stamp <  pt2->stamp) ? -1
         : (pt1->stamp == pt2->stamp) ?  0
         : 1;

     return ret;
 }

 static void viv_sync_pt_free(struct sync_pt *sync_pt)
 {
     struct viv_sync_pt *pt;
     struct viv_sync_timeline *obj;

     pt  = (struct viv_sync_pt *)sync_pt;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
     obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
 #else
     obj = (struct viv_sync_timeline *)sync_pt->parent;
 #endif

     gckOS_DestroySignal(obj->os, pt->signal);
 }

 static void viv_timeline_value_str(struct sync_timeline *timeline,
                     char *str, int size)
 {
     struct viv_sync_timeline *obj;

     obj = (struct viv_sync_timeline *)timeline;
     snprintf(str, size, "stamp_%llu", obj->stamp);
 }

 static void viv_pt_value_str(struct sync_pt *sync_pt, char *str, int size)
 {
     struct viv_sync_pt *pt;

     pt = (struct viv_sync_pt *)sync_pt;
     snprintf(str, size, "signal_%lu@stamp_%llu",
             (unsigned long)pt->signal, pt->stamp);
 }

 static struct sync_timeline_ops viv_timeline_ops =
 {
     .driver_name = "viv_gpu_sync",
     .dup = viv_sync_pt_dup,
     .has_signaled = viv_sync_pt_has_signaled,
     .compare = viv_sync_pt_compare,
     .free_pt = viv_sync_pt_free,
     .timeline_value_str = viv_timeline_value_str,
     .pt_value_str = viv_pt_value_str,
 };

 struct viv_sync_timeline * viv_sync_timeline_create(const char *name, gckOS os)
 {
     struct viv_sync_timeline * obj;

     obj = (struct viv_sync_timeline *)
         sync_timeline_create(&viv_timeline_ops, sizeof(struct viv_sync_timeline), name);

     obj->os    = os;
     obj->stamp = 0;

     return obj;
 }

 struct sync_pt * viv_sync_pt_create(struct viv_sync_timeline *obj,
                         gctSIGNAL Signal)
 {
     gceSTATUS status;
     struct viv_sync_pt *pt;

     pt = (struct viv_sync_pt *)
         sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));

     pt->stamp = obj->stamp++;

     /* Dup signal. */
     status = gckOS_MapSignal(obj->os,
                              Signal,
                              gcvNULL /* (gctHANDLE) _GetProcessID() */,
                              &pt->signal);

     if (gcmIS_ERROR(status)) {
         sync_pt_free((struct sync_pt *)pt);
         return NULL;
     }

     return (struct sync_pt *)pt;
 }

 #else

 struct viv_sync_timeline * viv_sync_timeline_create(const char *name, gckOS Os)
 {
     struct viv_sync_timeline *timeline;

     timeline = kmalloc(sizeof(struct viv_sync_timeline),
                     gcdNOWARN | GFP_KERNEL);

     if (!timeline)
         return NULL;

     strncpy(timeline->name, name, sizeof(timeline->name) - 1);
     timeline->context = dma_fence_context_alloc(1);
     atomic64_set(&timeline->seqno, 0);
     timeline->os = Os;

     return timeline;
 }

 void viv_sync_timeline_destroy(struct viv_sync_timeline *timeline)
 {
     kfree(timeline);
 }

 static const char * viv_fence_get_driver_name(struct dma_fence *fence)
 {
     return "viv_gpu_sync";
 }

 static const char * viv_fence_get_timeline_name(struct dma_fence *fence)
 {
     struct viv_fence *f = (struct viv_fence *)fence;
     return f->parent->name;
 }

 /* Same as fence_signaled. */
 static inline bool __viv_fence_signaled(struct dma_fence *fence)
 {
     struct viv_fence *f = (struct viv_fence *)fence;
     struct viv_sync_timeline *timeline = f->parent;
     gceSTATUS status;

     status = _QuerySignal(timeline->os, f->signal);

     return (status == gcvSTATUS_TRUE) ? true : false;
 }

 static bool viv_fence_enable_signaling(struct dma_fence *fence)
 {
     /* fence is locked already. */
     return !__viv_fence_signaled(fence);
 }

 static bool viv_fence_signaled(struct dma_fence *fence)
 {
     /* fence could be locked, could be not. */
     return __viv_fence_signaled(fence);
 }

 static void viv_fence_release(struct dma_fence *fence)
 {
     struct viv_fence *f = (struct viv_fence *)fence;
     struct viv_sync_timeline *timeline = f->parent;

     if (f->signal)
         gckOS_DestroySignal(timeline->os, f->signal);

     kfree(fence);
 }

 static struct dma_fence_ops viv_fence_ops =
 {
     .get_driver_name = viv_fence_get_driver_name,
     .get_timeline_name = viv_fence_get_timeline_name,
     .enable_signaling = viv_fence_enable_signaling,
     .signaled = viv_fence_signaled,
     .wait = dma_fence_default_wait,
     .release = viv_fence_release,
 };

 struct dma_fence * viv_fence_create(struct viv_sync_timeline *timeline,
                     gcsSIGNAL *signal)
 {
     gceSTATUS status;
     struct viv_fence *fence;
     struct dma_fence *old_fence = NULL;
     unsigned seqno;

     fence = kzalloc(sizeof(struct viv_fence), gcdNOWARN | GFP_KERNEL);

     if (!fence)
         return NULL;

     /* Reference signal in fence. */
     status = gckOS_MapSignal(timeline->os, (gctSIGNAL)(uintptr_t)signal->id,
                 NULL, &fence->signal);

     if (gcmIS_ERROR(status)) {
         kfree(fence);
         return NULL;
     }

     spin_lock_init(&fence->lock);

     fence->parent = timeline;

     seqno = (unsigned)atomic64_inc_return(&timeline->seqno);

     dma_fence_init((struct dma_fence *)fence, &viv_fence_ops,
             &fence->lock, timeline->context, seqno);

     /*
      * Reference fence in signal.
      * Be aware of recursive reference!!
      */
     spin_lock(&signal->lock);

     if (signal->fence) {
         old_fence = signal->fence;
         signal->fence = NULL;
     }

     if (!signal->done) {
         signal->fence = (struct dma_fence*)fence;

 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,9,68)
         dma_fence_get((struct dma_fence*)fence);
 #endif
     }

     spin_unlock(&signal->lock);

     if (old_fence)
         dma_fence_put(old_fence);

     if (!signal->fence) {
         /* Fence already signaled. */
         gckOS_DestroySignal(timeline->os, fence->signal);
         fence->signal = NULL;

         dma_fence_signal_locked((struct dma_fence*)fence);
     }

     return (struct dma_fence*)fence;
 }

 #endif

 #endif
	/****************************************************************************
	*
	* The MIT License (MIT)
	*
	* Copyright (c) 2014 - 2020 Vivante Corporation
	*
	* 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
	* AUTHORS OR COPYRIGHT HOLDERS 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.
	*
	*****************************************************************************
	*
	* The GPL License (GPL)
	*
	* Copyright (C) 2014 - 2020 Vivante Corporation
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* 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.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*
	*****************************************************************************
	*
	* Note: This software is released under dual MIT and GPL licenses. A
	* recipient may use this file under the terms of either the MIT license or
	* GPL License. If you wish to use only one license not the other, you can
	* indicate your decision by deleting one of the above license notices in your
	* version of this file.
	*
	*****************************************************************************/


	#include <gc_hal.h>
	#include <gc_hal_base.h>

	#if gcdLINUX_SYNC_FILE

	#include <linux/kernel.h>
	#include <linux/file.h>
	#include <linux/fs.h>
	#include <linux/miscdevice.h>
	#include <linux/module.h>
	#include <linux/syscalls.h>
	#include <linux/uaccess.h>
	#include <linux/slab.h>

	#include "gc_hal_kernel_sync.h"
	#include "gc_hal_kernel_linux.h"

	#ifndef CONFIG_SYNC_FILE

	static struct sync_pt * viv_sync_pt_dup(struct sync_pt *sync_pt)
	{
	gceSTATUS status;
	struct viv_sync_pt *pt;
	struct viv_sync_pt *src;
	struct viv_sync_timeline *obj;

	src = (struct viv_sync_pt *)sync_pt;
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
	obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
	#else
	obj = (struct viv_sync_timeline *)sync_pt->parent;
	#endif

	/* Create the new sync_pt. */
	pt = (struct viv_sync_pt *)
	sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));

	pt->stamp = src->stamp;

	/* Reference signal. */
	status = gckOS_MapSignal(obj->os,
	src->signal,
	gcvNULL /* (gctHANDLE) _GetProcessID() */,
	&pt->signal);

	if (gcmIS_ERROR(status)) {
	sync_pt_free((struct sync_pt *)pt);
	return NULL;
	}

	return (struct sync_pt *)pt;
	}

	static int viv_sync_pt_has_signaled(struct sync_pt *sync_pt)
	{
	gceSTATUS status;
	struct viv_sync_pt *pt;
	struct viv_sync_timeline *obj;

	pt = (struct viv_sync_pt *)sync_pt;
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
	obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
	#else
	obj = (struct viv_sync_timeline *)sync_pt->parent;
	#endif

	status = _QuerySignal(obj->os, pt->signal);

	if (gcmIS_ERROR(status)) {
	/* Error. */
	return -1;
	}

	return (int) status;
	}

	static int viv_sync_pt_compare(struct sync_pt a, struct sync_pt b)
	{
	int ret;
	struct viv_sync_pt pt1 = (struct viv_sync_pt )a;
	struct viv_sync_pt pt2 = (struct viv_sync_pt )b;

	ret = (pt1->stamp < pt2->stamp) ? -1
	: (pt1->stamp == pt2->stamp) ? 0
	: 1;

	return ret;
	}

	static void viv_sync_pt_free(struct sync_pt *sync_pt)
	{
	struct viv_sync_pt *pt;
	struct viv_sync_timeline *obj;

	pt = (struct viv_sync_pt *)sync_pt;
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
	obj = (struct viv_sync_timeline *)sync_pt_parent(sync_pt);
	#else
	obj = (struct viv_sync_timeline *)sync_pt->parent;
	#endif

	gckOS_DestroySignal(obj->os, pt->signal);
	}

	static void viv_timeline_value_str(struct sync_timeline *timeline,
	char *str, int size)
	{
	struct viv_sync_timeline *obj;

	obj = (struct viv_sync_timeline *)timeline;
	snprintf(str, size, "stamp_%llu", obj->stamp);
	}

	static void viv_pt_value_str(struct sync_pt sync_pt, char str, int size)
	{
	struct viv_sync_pt *pt;

	pt = (struct viv_sync_pt *)sync_pt;
	snprintf(str, size, "signal_%lu@stamp_%llu",
	(unsigned long)pt->signal, pt->stamp);
	}

	static struct sync_timeline_ops viv_timeline_ops =
	{
	.driver_name = "viv_gpu_sync",
	.dup = viv_sync_pt_dup,
	.has_signaled = viv_sync_pt_has_signaled,
	.compare = viv_sync_pt_compare,
	.free_pt = viv_sync_pt_free,
	.timeline_value_str = viv_timeline_value_str,
	.pt_value_str = viv_pt_value_str,
	};

	struct viv_sync_timeline * viv_sync_timeline_create(const char *name, gckOS os)
	{
	struct viv_sync_timeline * obj;

	obj = (struct viv_sync_timeline *)
	sync_timeline_create(&viv_timeline_ops, sizeof(struct viv_sync_timeline), name);

	obj->os = os;
	obj->stamp = 0;

	return obj;
	}

	struct sync_pt * viv_sync_pt_create(struct viv_sync_timeline *obj,
	gctSIGNAL Signal)
	{
	gceSTATUS status;
	struct viv_sync_pt *pt;

	pt = (struct viv_sync_pt *)
	sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));

	pt->stamp = obj->stamp++;

	/* Dup signal. */
	status = gckOS_MapSignal(obj->os,
	Signal,
	gcvNULL /* (gctHANDLE) _GetProcessID() */,
	&pt->signal);

	if (gcmIS_ERROR(status)) {
	sync_pt_free((struct sync_pt *)pt);
	return NULL;
	}

	return (struct sync_pt *)pt;
	}

	#else

	struct viv_sync_timeline * viv_sync_timeline_create(const char *name, gckOS Os)
	{
	struct viv_sync_timeline *timeline;

	timeline = kmalloc(sizeof(struct viv_sync_timeline),
	gcdNOWARN \| GFP_KERNEL);

	if (!timeline)
	return NULL;

	strncpy(timeline->name, name, sizeof(timeline->name) - 1);
	timeline->context = dma_fence_context_alloc(1);
	atomic64_set(&timeline->seqno, 0);
	timeline->os = Os;

	return timeline;
	}

	void viv_sync_timeline_destroy(struct viv_sync_timeline *timeline)
	{
	kfree(timeline);
	}

	static const char * viv_fence_get_driver_name(struct dma_fence *fence)
	{
	return "viv_gpu_sync";
	}

	static const char * viv_fence_get_timeline_name(struct dma_fence *fence)
	{
	struct viv_fence f = (struct viv_fence )fence;
	return f->parent->name;
	}

	/* Same as fence_signaled. */
	static inline bool __viv_fence_signaled(struct dma_fence *fence)
	{
	struct viv_fence f = (struct viv_fence )fence;
	struct viv_sync_timeline *timeline = f->parent;
	gceSTATUS status;

	status = _QuerySignal(timeline->os, f->signal);

	return (status == gcvSTATUS_TRUE) ? true : false;
	}

	static bool viv_fence_enable_signaling(struct dma_fence *fence)
	{
	/* fence is locked already. */
	return !__viv_fence_signaled(fence);
	}

	static bool viv_fence_signaled(struct dma_fence *fence)
	{
	/* fence could be locked, could be not. */
	return __viv_fence_signaled(fence);
	}

	static void viv_fence_release(struct dma_fence *fence)
	{
	struct viv_fence f = (struct viv_fence )fence;
	struct viv_sync_timeline *timeline = f->parent;

	if (f->signal)
	gckOS_DestroySignal(timeline->os, f->signal);

	kfree(fence);
	}

	static struct dma_fence_ops viv_fence_ops =
	{
	.get_driver_name = viv_fence_get_driver_name,
	.get_timeline_name = viv_fence_get_timeline_name,
	.enable_signaling = viv_fence_enable_signaling,
	.signaled = viv_fence_signaled,
	.wait = dma_fence_default_wait,
	.release = viv_fence_release,
	};

	struct dma_fence * viv_fence_create(struct viv_sync_timeline *timeline,
	gcsSIGNAL *signal)
	{
	gceSTATUS status;
	struct viv_fence *fence;
	struct dma_fence *old_fence = NULL;
	unsigned seqno;

	fence = kzalloc(sizeof(struct viv_fence), gcdNOWARN \| GFP_KERNEL);

	if (!fence)
	return NULL;

	/* Reference signal in fence. */
	status = gckOS_MapSignal(timeline->os, (gctSIGNAL)(uintptr_t)signal->id,
	NULL, &fence->signal);

	if (gcmIS_ERROR(status)) {
	kfree(fence);
	return NULL;
	}

	spin_lock_init(&fence->lock);

	fence->parent = timeline;

	seqno = (unsigned)atomic64_inc_return(&timeline->seqno);

	dma_fence_init((struct dma_fence *)fence, &viv_fence_ops,
	&fence->lock, timeline->context, seqno);

	/*
	* Reference fence in signal.
	* Be aware of recursive reference!!
	*/
	spin_lock(&signal->lock);

	if (signal->fence) {
	old_fence = signal->fence;
	signal->fence = NULL;
	}

	if (!signal->done) {
	signal->fence = (struct dma_fence*)fence;

	#if LINUX_VERSION_CODE < KERNEL_VERSION(4,9,68)
	dma_fence_get((struct dma_fence*)fence);
	#endif
	}

	spin_unlock(&signal->lock);

	if (old_fence)
	dma_fence_put(old_fence);

	if (!signal->fence) {
	/* Fence already signaled. */
	gckOS_DestroySignal(timeline->os, fence->signal);
	fence->signal = NULL;

	dma_fence_signal_locked((struct dma_fence*)fence);
	}

	return (struct dma_fence*)fence;
	}

	#endif

	#endif