hal/os/linux/kernel/allocator/default/gc_hal_kernel_allocator_dmabuf.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_kernel_linux.h"
 #include "gc_hal_kernel_allocator.h"

 #include <linux/pagemap.h>
 #include <linux/seq_file.h>
 #include <linux/mman.h>
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <asm/atomic.h>
 #include <linux/dma-mapping.h>

 #include <linux/dma-buf.h>
 #include <linux/platform_device.h>

 #define _GC_OBJ_ZONE gcvZONE_OS

 /* Descriptor of a dma_buf imported. */
 typedef struct _gcsDMABUF
 {
     struct dma_buf            * dmabuf;
     struct dma_buf_attachment * attachment;
     struct sg_table           * sgt;
     unsigned long             * pagearray;

     int                         npages;
     int                         pid;
     struct list_head            list;
 }
 gcsDMABUF;

 struct allocator_priv
 {
     struct mutex lock;
     struct list_head buf_list;
 };

 /*
 * Debugfs support.
 */
 static int dma_buf_info_show(struct seq_file* m, void* data)
 {
     int ret;
     gcsDMABUF *buf_desc;
     struct dma_buf_attachment *attach_obj;
     int count = 0;
     size_t size = 0;
     int npages = 0;
     const char *exp_name;

     gcsINFO_NODE *node = m->private;
     gckALLOCATOR allocator = node->device;
     struct allocator_priv *priv = allocator->privateData;

     ret = mutex_lock_interruptible(&priv->lock);

     if (ret)
         return ret;

     seq_puts(m, "Attached dma-buf objects:\n");
     seq_puts(m, "   pid     fd    pages     size   exporter attached-devices\n");

     list_for_each_entry(buf_desc, &priv->buf_list, list) {
         struct dma_buf *buf_obj = buf_desc->dmabuf;

         ret = mutex_lock_interruptible(&buf_obj->lock);

         if (ret) {
             seq_puts(m,
                  "ERROR locking buffer object: skipping\n");
             continue;
         }

 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
         exp_name = buf_obj->exp_name;
 #else
         exp_name = "unknown";
 #endif

         seq_printf(m, "%6d %p %8d %8zu %10s",
                 buf_desc->pid,
                 buf_desc->dmabuf,
                 buf_desc->npages,
                 buf_obj->size,
                 exp_name);

         list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
             seq_printf(m, " %s", dev_name(attach_obj->dev));
         }
         seq_puts(m, "\n");

         count++;
         size += buf_obj->size;
         npages += buf_desc->npages;

         mutex_unlock(&buf_obj->lock);
     }

     seq_printf(m, "\nTotal %d objects, %d pages, %zu bytes\n", count, npages, size);

     mutex_unlock(&priv->lock);
     return 0;
 }

 static gcsINFO _InfoList[] =
 {
     {"bufinfo", dma_buf_info_show},
 };

 static void
 _DebugfsInit(
     IN gckALLOCATOR Allocator,
     IN gckDEBUGFS_DIR Root
     )
 {
     gcmkVERIFY_OK(
         gckDEBUGFS_DIR_Init(&Allocator->debugfsDir, Root->root, "dma_buf"));

     gcmkVERIFY_OK(gckDEBUGFS_DIR_CreateFiles(
         &Allocator->debugfsDir,
         _InfoList,
         gcmCOUNTOF(_InfoList),
         Allocator
         ));
 }

 static void
 _DebugfsCleanup(
     IN gckALLOCATOR Allocator
     )
 {
     gcmkVERIFY_OK(gckDEBUGFS_DIR_RemoveFiles(
         &Allocator->debugfsDir,
         _InfoList,
         gcmCOUNTOF(_InfoList)
         ));

     gckDEBUGFS_DIR_Deinit(&Allocator->debugfsDir);
 }

 static gceSTATUS
 _DmabufAttach(
     IN gckALLOCATOR Allocator,
     IN gcsATTACH_DESC_PTR Desc,
     IN PLINUX_MDL Mdl
     )
 {
     gceSTATUS status;

     gckOS os = Allocator->os;

     struct dma_buf *dmabuf = Desc->dmaBuf.dmabuf;
     struct sg_table *sgt = NULL;
     struct dma_buf_attachment *attachment = NULL;
     int npages = 0;
     unsigned long *pagearray = NULL;
     int i, j, k = 0;
     struct scatterlist *s;
     struct allocator_priv *priv = Allocator->privateData;
     gcsDMABUF *buf_desc = NULL;

     gcmkHEADER();

     gcmkVERIFY_OBJECT(os, gcvOBJ_OS);

     if (!dmabuf)
     {
         gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
     }

     get_dma_buf(dmabuf);
     attachment = dma_buf_attach(dmabuf, &os->device->platform->device->dev);

     if (!attachment)
     {
         gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
     }

     sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);

     if (!sgt)
     {
         gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
     }

     /* Prepare page array. */
     /* Get number of pages. */
     for_each_sg(sgt->sgl, s, sgt->orig_nents, i)
     {
         npages += (sg_dma_len(s) + PAGE_SIZE - 1) / PAGE_SIZE;
     }

     /* Allocate page array. */
     gcmkONERROR(gckOS_Allocate(os, npages * gcmSIZEOF(*pagearray), (gctPOINTER *)&pagearray));

     /* Fill page array. */
     for_each_sg(sgt->sgl, s, sgt->orig_nents, i)
     {
         for (j = 0; j < (sg_dma_len(s) + PAGE_SIZE - 1) / PAGE_SIZE; j++)
         {
             pagearray[k++] = sg_dma_address(s) + j * PAGE_SIZE;
         }
     }

     /* Prepare descriptor. */
     gcmkONERROR(gckOS_Allocate(os, sizeof(gcsDMABUF), (gctPOINTER *)&buf_desc));

     buf_desc->dmabuf = dmabuf;
     buf_desc->pagearray = pagearray;
     buf_desc->attachment = attachment;
     buf_desc->sgt = sgt;

     /* Record in buffer list to support debugfs. */
     buf_desc->npages = npages;
     buf_desc->pid    = _GetProcessID();

     mutex_lock(&priv->lock);
     list_add(&buf_desc->list, &priv->buf_list);
     mutex_unlock(&priv->lock);

     /* Record page number. */
     Mdl->numPages = npages;

     Mdl->priv = buf_desc;

     Mdl->contiguous = (sgt->nents == 1) ? gcvTRUE : gcvFALSE;

     gcmkFOOTER_NO();
     return gcvSTATUS_OK;

 OnError:
     if (pagearray)
     {
         gcmkOS_SAFE_FREE(os, pagearray);
     }

     if (sgt)
     {
         dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL);
     }

     gcmkFOOTER();
     return status;
 }


 static void
 _DmabufFree(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl
     )
 {
     gcsDMABUF *buf_desc = Mdl->priv;
     gckOS os = Allocator->os;
     struct allocator_priv *priv = Allocator->privateData;

     mutex_lock(&priv->lock);
     list_del(&buf_desc->list);
     mutex_unlock(&priv->lock);

     dma_buf_unmap_attachment(buf_desc->attachment, buf_desc->sgt, DMA_BIDIRECTIONAL);

     dma_buf_detach(buf_desc->dmabuf, buf_desc->attachment);

     dma_buf_put(buf_desc->dmabuf);

     gckOS_Free(os, buf_desc->pagearray);

     gckOS_Free(os, buf_desc);
 }

 static void
 _DmabufUnmapUser(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN PLINUX_MDL_MAP MdlMap,
     IN gctUINT32 Size
     )
 {
     gcsDMABUF *buf_desc = Mdl->priv;
     gctINT8_PTR userLogical = MdlMap->vmaAddr;

     if (unlikely(current->mm == gcvNULL))
     {
         /* Do nothing if process is exiting. */
         return;
     }

     userLogical -= buf_desc->sgt->sgl->offset;
     vm_munmap((unsigned long)userLogical, Mdl->numPages << PAGE_SHIFT);
 }

 static gceSTATUS
 _DmabufMapUser(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN PLINUX_MDL_MAP MdlMap,
     IN gctBOOL Cacheable
     )
 {
     gcsDMABUF *buf_desc = Mdl->priv;
     gctINT8_PTR userLogical = gcvNULL;
     gceSTATUS status = gcvSTATUS_OK;
     struct file *fd = buf_desc->dmabuf->file;
     unsigned long flag = 0;

     flag |= (fd->f_mode & FMODE_READ ? PROT_READ : 0);
     flag |= (fd->f_mode & FMODE_WRITE ? PROT_WRITE : 0);

     userLogical = (gctINT8_PTR)vm_mmap(fd,
                     0L,
                     Mdl->numPages << PAGE_SHIFT,
                     flag,
                     MAP_SHARED | MAP_NORESERVE,
                     0);

     if (IS_ERR(userLogical))
     {
         gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
     }
     userLogical += buf_desc->sgt->sgl->offset;

     /* To make sure the mapping is created. */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
     if (access_ok(userLogical, 4))
 #else
     if (access_ok(VERIFY_READ, userLogical, 4))
 #endif
     {
         uint32_t mem;
         get_user(mem, (uint32_t *)userLogical);

         (void)mem;
     }

     MdlMap->vmaAddr = (gctPOINTER)userLogical;
     MdlMap->cacheable = Cacheable;

 OnError:
     if (gcmIS_ERROR(status) && MdlMap->vmaAddr)
     {
         _DmabufUnmapUser(Allocator, Mdl, MdlMap, Mdl->numPages << PAGE_SHIFT);
     }
     return status;
 }

 static gceSTATUS
 _DmabufMapKernel(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN gctSIZE_T Offset,
     IN gctSIZE_T Bytes,
     OUT gctPOINTER *Logical
     )
 {
     /* Kernel doesn't acess video memory. */
     return gcvSTATUS_NOT_SUPPORTED;

 }

 static gceSTATUS
 _DmabufUnmapKernel(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN gctPOINTER Logical
     )
 {
     /* Kernel doesn't acess video memory. */
     return gcvSTATUS_NOT_SUPPORTED;
 }

 static gceSTATUS
 _DmabufCache(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN gctSIZE_T Offset,
     IN gctPOINTER Logical,
     IN gctSIZE_T Bytes,
     IN gceCACHEOPERATION Operation
     )
 {
     gcsDMABUF *buf_desc = Mdl->priv;
     struct sg_table *sgt = buf_desc->sgt;
     enum dma_data_direction dir;

     switch (Operation)
     {
     case gcvCACHE_CLEAN:
         dir = DMA_TO_DEVICE;
         dma_sync_sg_for_device(galcore_device, sgt->sgl, sgt->nents, dir);
         break;
     case gcvCACHE_FLUSH:
         dir = DMA_TO_DEVICE;
         dma_sync_sg_for_device(galcore_device, sgt->sgl, sgt->nents, dir);
         dir = DMA_FROM_DEVICE;
         dma_sync_sg_for_cpu(galcore_device, sgt->sgl, sgt->nents, dir);
         break;
     case gcvCACHE_INVALIDATE:
         dir = DMA_FROM_DEVICE;
         dma_sync_sg_for_cpu(galcore_device, sgt->sgl, sgt->nents, dir);
         break;
     default:
         return gcvSTATUS_INVALID_ARGUMENT;
     }

     return gcvSTATUS_OK;
 }


 static gceSTATUS
 _DmabufPhysical(
     IN gckALLOCATOR Allocator,
     IN PLINUX_MDL Mdl,
     IN gctUINT32 Offset,
     OUT gctPHYS_ADDR_T * Physical
     )
 {
     gcsDMABUF *buf_desc = Mdl->priv;
     gctUINT32 offsetInPage = Offset & ~PAGE_MASK;
     gctUINT32 index = Offset / PAGE_SIZE;

     *Physical = buf_desc->pagearray[index] + offsetInPage;


     return gcvSTATUS_OK;
 }

 /* Default allocator operations. */
 static gcsALLOCATOR_OPERATIONS DmabufAllocatorOperations =
 {
     .Attach             = _DmabufAttach,
     .Free               = _DmabufFree,
     .MapUser            = _DmabufMapUser,
     .UnmapUser          = _DmabufUnmapUser,
     .MapKernel          = _DmabufMapKernel,
     .UnmapKernel        = _DmabufUnmapKernel,
     .Cache              = _DmabufCache,
     .Physical           = _DmabufPhysical,
 };

 static void
 _DmabufAllocatorDestructor(
     gcsALLOCATOR *Allocator
     )
 {
     _DebugfsCleanup(Allocator);

     if (Allocator->privateData)
     {
         kfree(Allocator->privateData);
     }

     kfree(Allocator);
 }

 /* Default allocator entry. */
 gceSTATUS
 _DmabufAlloctorInit(
     IN gckOS Os,
     IN gcsDEBUGFS_DIR *Parent,
     OUT gckALLOCATOR * Allocator
     )
 {
     gceSTATUS status;
     gckALLOCATOR allocator;
     struct allocator_priv *priv = NULL;

     priv = kmalloc(sizeof (struct allocator_priv), GFP_KERNEL | gcdNOWARN);

     if (!priv)
     {
         gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
     }

     mutex_init(&priv->lock);
     INIT_LIST_HEAD(&priv->buf_list);

     gcmkONERROR(
         gckALLOCATOR_Construct(Os, &DmabufAllocatorOperations, &allocator));

     allocator->capability = gcvALLOC_FLAG_DMABUF
                           | gcvALLOC_FLAG_DMABUF_EXPORTABLE
                           ;

     /* Register private data. */
     allocator->privateData = priv;
     allocator->destructor  = _DmabufAllocatorDestructor;

     _DebugfsInit(allocator, Parent);

     *Allocator = allocator;

     return gcvSTATUS_OK;

 OnError:
     if (priv)
     {
         kfree(priv);
     }

     return status;
 }
	/****************************************************************************
	*
	* 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_kernel_linux.h"
	#include "gc_hal_kernel_allocator.h"

	#include <linux/pagemap.h>
	#include <linux/seq_file.h>
	#include <linux/mman.h>
	#include <linux/slab.h>
	#include <linux/mutex.h>
	#include <asm/atomic.h>
	#include <linux/dma-mapping.h>

	#include <linux/dma-buf.h>
	#include <linux/platform_device.h>

	#define _GC_OBJ_ZONE gcvZONE_OS

	/* Descriptor of a dma_buf imported. */
	typedef struct _gcsDMABUF
	{
	struct dma_buf * dmabuf;
	struct dma_buf_attachment * attachment;
	struct sg_table * sgt;
	unsigned long * pagearray;

	int npages;
	int pid;
	struct list_head list;
	}
	gcsDMABUF;

	struct allocator_priv
	{
	struct mutex lock;
	struct list_head buf_list;
	};

	/*
	* Debugfs support.
	*/
	static int dma_buf_info_show(struct seq_file* m, void* data)
	{
	int ret;
	gcsDMABUF *buf_desc;
	struct dma_buf_attachment *attach_obj;
	int count = 0;
	size_t size = 0;
	int npages = 0;
	const char *exp_name;

	gcsINFO_NODE *node = m->private;
	gckALLOCATOR allocator = node->device;
	struct allocator_priv *priv = allocator->privateData;

	ret = mutex_lock_interruptible(&priv->lock);

	if (ret)
	return ret;

	seq_puts(m, "Attached dma-buf objects:\n");
	seq_puts(m, " pid fd pages size exporter attached-devices\n");

	list_for_each_entry(buf_desc, &priv->buf_list, list) {
	struct dma_buf *buf_obj = buf_desc->dmabuf;

	ret = mutex_lock_interruptible(&buf_obj->lock);

	if (ret) {
	seq_puts(m,
	"ERROR locking buffer object: skipping\n");
	continue;
	}

	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
	exp_name = buf_obj->exp_name;
	#else
	exp_name = "unknown";
	#endif

	seq_printf(m, "%6d %p %8d %8zu %10s",
	buf_desc->pid,
	buf_desc->dmabuf,
	buf_desc->npages,
	buf_obj->size,
	exp_name);

	list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
	seq_printf(m, " %s", dev_name(attach_obj->dev));
	}
	seq_puts(m, "\n");

	count++;
	size += buf_obj->size;
	npages += buf_desc->npages;

	mutex_unlock(&buf_obj->lock);
	}

	seq_printf(m, "\nTotal %d objects, %d pages, %zu bytes\n", count, npages, size);

	mutex_unlock(&priv->lock);
	return 0;
	}

	static gcsINFO _InfoList[] =
	{
	{"bufinfo", dma_buf_info_show},
	};

	static void
	_DebugfsInit(
	IN gckALLOCATOR Allocator,
	IN gckDEBUGFS_DIR Root
	)
	{
	gcmkVERIFY_OK(
	gckDEBUGFS_DIR_Init(&Allocator->debugfsDir, Root->root, "dma_buf"));

	gcmkVERIFY_OK(gckDEBUGFS_DIR_CreateFiles(
	&Allocator->debugfsDir,
	_InfoList,
	gcmCOUNTOF(_InfoList),
	Allocator
	));
	}

	static void
	_DebugfsCleanup(
	IN gckALLOCATOR Allocator
	)
	{
	gcmkVERIFY_OK(gckDEBUGFS_DIR_RemoveFiles(
	&Allocator->debugfsDir,
	_InfoList,
	gcmCOUNTOF(_InfoList)
	));

	gckDEBUGFS_DIR_Deinit(&Allocator->debugfsDir);
	}

	static gceSTATUS
	_DmabufAttach(
	IN gckALLOCATOR Allocator,
	IN gcsATTACH_DESC_PTR Desc,
	IN PLINUX_MDL Mdl
	)
	{
	gceSTATUS status;

	gckOS os = Allocator->os;

	struct dma_buf *dmabuf = Desc->dmaBuf.dmabuf;
	struct sg_table *sgt = NULL;
	struct dma_buf_attachment *attachment = NULL;
	int npages = 0;
	unsigned long *pagearray = NULL;
	int i, j, k = 0;
	struct scatterlist *s;
	struct allocator_priv *priv = Allocator->privateData;
	gcsDMABUF *buf_desc = NULL;

	gcmkHEADER();

	gcmkVERIFY_OBJECT(os, gcvOBJ_OS);

	if (!dmabuf)
	{
	gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
	}

	get_dma_buf(dmabuf);
	attachment = dma_buf_attach(dmabuf, &os->device->platform->device->dev);

	if (!attachment)
	{
	gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
	}

	sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);

	if (!sgt)
	{
	gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
	}

	/* Prepare page array. */
	/* Get number of pages. */
	for_each_sg(sgt->sgl, s, sgt->orig_nents, i)
	{
	npages += (sg_dma_len(s) + PAGE_SIZE - 1) / PAGE_SIZE;
	}

	/* Allocate page array. */
	gcmkONERROR(gckOS_Allocate(os, npages * gcmSIZEOF(pagearray), (gctPOINTER )&pagearray));

	/* Fill page array. */
	for_each_sg(sgt->sgl, s, sgt->orig_nents, i)
	{
	for (j = 0; j < (sg_dma_len(s) + PAGE_SIZE - 1) / PAGE_SIZE; j++)
	{
	pagearray[k++] = sg_dma_address(s) + j * PAGE_SIZE;
	}
	}

	/* Prepare descriptor. */
	gcmkONERROR(gckOS_Allocate(os, sizeof(gcsDMABUF), (gctPOINTER *)&buf_desc));

	buf_desc->dmabuf = dmabuf;
	buf_desc->pagearray = pagearray;
	buf_desc->attachment = attachment;
	buf_desc->sgt = sgt;

	/* Record in buffer list to support debugfs. */
	buf_desc->npages = npages;
	buf_desc->pid = _GetProcessID();

	mutex_lock(&priv->lock);
	list_add(&buf_desc->list, &priv->buf_list);
	mutex_unlock(&priv->lock);

	/* Record page number. */
	Mdl->numPages = npages;

	Mdl->priv = buf_desc;

	Mdl->contiguous = (sgt->nents == 1) ? gcvTRUE : gcvFALSE;

	gcmkFOOTER_NO();
	return gcvSTATUS_OK;

	OnError:
	if (pagearray)
	{
	gcmkOS_SAFE_FREE(os, pagearray);
	}

	if (sgt)
	{
	dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL);
	}

	gcmkFOOTER();
	return status;
	}


	static void
	_DmabufFree(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl
	)
	{
	gcsDMABUF *buf_desc = Mdl->priv;
	gckOS os = Allocator->os;
	struct allocator_priv *priv = Allocator->privateData;

	mutex_lock(&priv->lock);
	list_del(&buf_desc->list);
	mutex_unlock(&priv->lock);

	dma_buf_unmap_attachment(buf_desc->attachment, buf_desc->sgt, DMA_BIDIRECTIONAL);

	dma_buf_detach(buf_desc->dmabuf, buf_desc->attachment);

	dma_buf_put(buf_desc->dmabuf);

	gckOS_Free(os, buf_desc->pagearray);

	gckOS_Free(os, buf_desc);
	}

	static void
	_DmabufUnmapUser(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN PLINUX_MDL_MAP MdlMap,
	IN gctUINT32 Size
	)
	{
	gcsDMABUF *buf_desc = Mdl->priv;
	gctINT8_PTR userLogical = MdlMap->vmaAddr;

	if (unlikely(current->mm == gcvNULL))
	{
	/* Do nothing if process is exiting. */
	return;
	}

	userLogical -= buf_desc->sgt->sgl->offset;
	vm_munmap((unsigned long)userLogical, Mdl->numPages << PAGE_SHIFT);
	}

	static gceSTATUS
	_DmabufMapUser(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN PLINUX_MDL_MAP MdlMap,
	IN gctBOOL Cacheable
	)
	{
	gcsDMABUF *buf_desc = Mdl->priv;
	gctINT8_PTR userLogical = gcvNULL;
	gceSTATUS status = gcvSTATUS_OK;
	struct file *fd = buf_desc->dmabuf->file;
	unsigned long flag = 0;

	flag \|= (fd->f_mode & FMODE_READ ? PROT_READ : 0);
	flag \|= (fd->f_mode & FMODE_WRITE ? PROT_WRITE : 0);

	userLogical = (gctINT8_PTR)vm_mmap(fd,
	0L,
	Mdl->numPages << PAGE_SHIFT,
	flag,
	MAP_SHARED \| MAP_NORESERVE,
	0);

	if (IS_ERR(userLogical))
	{
	gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
	}
	userLogical += buf_desc->sgt->sgl->offset;

	/* To make sure the mapping is created. */
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
	if (access_ok(userLogical, 4))
	#else
	if (access_ok(VERIFY_READ, userLogical, 4))
	#endif
	{
	uint32_t mem;
	get_user(mem, (uint32_t *)userLogical);

	(void)mem;
	}

	MdlMap->vmaAddr = (gctPOINTER)userLogical;
	MdlMap->cacheable = Cacheable;

	OnError:
	if (gcmIS_ERROR(status) && MdlMap->vmaAddr)
	{
	_DmabufUnmapUser(Allocator, Mdl, MdlMap, Mdl->numPages << PAGE_SHIFT);
	}
	return status;
	}

	static gceSTATUS
	_DmabufMapKernel(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN gctSIZE_T Offset,
	IN gctSIZE_T Bytes,
	OUT gctPOINTER *Logical
	)
	{
	/* Kernel doesn't acess video memory. */
	return gcvSTATUS_NOT_SUPPORTED;

	}

	static gceSTATUS
	_DmabufUnmapKernel(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN gctPOINTER Logical
	)
	{
	/* Kernel doesn't acess video memory. */
	return gcvSTATUS_NOT_SUPPORTED;
	}

	static gceSTATUS
	_DmabufCache(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN gctSIZE_T Offset,
	IN gctPOINTER Logical,
	IN gctSIZE_T Bytes,
	IN gceCACHEOPERATION Operation
	)
	{
	gcsDMABUF *buf_desc = Mdl->priv;
	struct sg_table *sgt = buf_desc->sgt;
	enum dma_data_direction dir;

	switch (Operation)
	{
	case gcvCACHE_CLEAN:
	dir = DMA_TO_DEVICE;
	dma_sync_sg_for_device(galcore_device, sgt->sgl, sgt->nents, dir);
	break;
	case gcvCACHE_FLUSH:
	dir = DMA_TO_DEVICE;
	dma_sync_sg_for_device(galcore_device, sgt->sgl, sgt->nents, dir);
	dir = DMA_FROM_DEVICE;
	dma_sync_sg_for_cpu(galcore_device, sgt->sgl, sgt->nents, dir);
	break;
	case gcvCACHE_INVALIDATE:
	dir = DMA_FROM_DEVICE;
	dma_sync_sg_for_cpu(galcore_device, sgt->sgl, sgt->nents, dir);
	break;
	default:
	return gcvSTATUS_INVALID_ARGUMENT;
	}

	return gcvSTATUS_OK;
	}


	static gceSTATUS
	_DmabufPhysical(
	IN gckALLOCATOR Allocator,
	IN PLINUX_MDL Mdl,
	IN gctUINT32 Offset,
	OUT gctPHYS_ADDR_T * Physical
	)
	{
	gcsDMABUF *buf_desc = Mdl->priv;
	gctUINT32 offsetInPage = Offset & ~PAGE_MASK;
	gctUINT32 index = Offset / PAGE_SIZE;

	*Physical = buf_desc->pagearray[index] + offsetInPage;


	return gcvSTATUS_OK;
	}

	/* Default allocator operations. */
	static gcsALLOCATOR_OPERATIONS DmabufAllocatorOperations =
	{
	.Attach = _DmabufAttach,
	.Free = _DmabufFree,
	.MapUser = _DmabufMapUser,
	.UnmapUser = _DmabufUnmapUser,
	.MapKernel = _DmabufMapKernel,
	.UnmapKernel = _DmabufUnmapKernel,
	.Cache = _DmabufCache,
	.Physical = _DmabufPhysical,
	};

	static void
	_DmabufAllocatorDestructor(
	gcsALLOCATOR *Allocator
	)
	{
	_DebugfsCleanup(Allocator);

	if (Allocator->privateData)
	{
	kfree(Allocator->privateData);
	}

	kfree(Allocator);
	}

	/* Default allocator entry. */
	gceSTATUS
	_DmabufAlloctorInit(
	IN gckOS Os,
	IN gcsDEBUGFS_DIR *Parent,
	OUT gckALLOCATOR * Allocator
	)
	{
	gceSTATUS status;
	gckALLOCATOR allocator;
	struct allocator_priv *priv = NULL;

	priv = kmalloc(sizeof (struct allocator_priv), GFP_KERNEL \| gcdNOWARN);

	if (!priv)
	{
	gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
	}

	mutex_init(&priv->lock);
	INIT_LIST_HEAD(&priv->buf_list);

	gcmkONERROR(
	gckALLOCATOR_Construct(Os, &DmabufAllocatorOperations, &allocator));

	allocator->capability = gcvALLOC_FLAG_DMABUF
	\| gcvALLOC_FLAG_DMABUF_EXPORTABLE
	;

	/* Register private data. */
	allocator->privateData = priv;
	allocator->destructor = _DmabufAllocatorDestructor;

	_DebugfsInit(allocator, Parent);

	*Allocator = allocator;

	return gcvSTATUS_OK;

	OnError:
	if (priv)
	{
	kfree(priv);
	}

	return status;
	}