hal/os/linux/kernel/gc_hal_kernel_linux.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"

 #define _GC_OBJ_ZONE    gcvZONE_KERNEL

 /******************************************************************************\
 ******************************* gckKERNEL API Code ******************************
 \******************************************************************************/

 /*******************************************************************************
 **
 **  gckKERNEL_QueryVideoMemory
 **
 **  Query the amount of video memory.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **  OUTPUT:
 **
 **      gcsHAL_INTERFACE * Interface
 **          Pointer to an gcsHAL_INTERFACE structure that will be filled in with
 **          the memory information.
 */
 gceSTATUS
 gckKERNEL_QueryVideoMemory(
     IN gckKERNEL Kernel,
     OUT gcsHAL_INTERFACE * Interface
     )
 {
     gckGALDEVICE device;

     gcmkHEADER_ARG("Kernel=%p", Kernel);

     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
     gcmkVERIFY_ARGUMENT(Interface != NULL);

     /* Extract the pointer to the gckGALDEVICE class. */
     device = (gckGALDEVICE) Kernel->context;

     /* Get internal memory size and physical address. */
     Interface->u.QueryVideoMemory.internalSize = device->internalSize;
     Interface->u.QueryVideoMemory.internalPhysName = device->internalPhysName;

     /* Get external memory size and physical address. */
     Interface->u.QueryVideoMemory.externalSize = device->externalSize;
     Interface->u.QueryVideoMemory.externalPhysName = device->externalPhysName;

     /* Get contiguous memory size and physical address. */
     Interface->u.QueryVideoMemory.contiguousSize = device->contiguousSize;
     Interface->u.QueryVideoMemory.contiguousPhysName = device->contiguousPhysName;

     /* Success. */
     gcmkFOOTER_NO();
     return gcvSTATUS_OK;
 }

 /*******************************************************************************
 **
 **  gckKERNEL_GetVideoMemoryPool
 **
 **  Get the gckVIDMEM object belonging to the specified pool.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gcePOOL Pool
 **          Pool to query gckVIDMEM object for.
 **
 **  OUTPUT:
 **
 **      gckVIDMEM * VideoMemory
 **          Pointer to a variable that will hold the pointer to the gckVIDMEM
 **          object belonging to the requested pool.
 */
 gceSTATUS
 gckKERNEL_GetVideoMemoryPool(
     IN gckKERNEL Kernel,
     IN gcePOOL Pool,
     OUT gckVIDMEM * VideoMemory
     )
 {
     gckGALDEVICE device;
     gckVIDMEM videoMemory;

     gcmkHEADER_ARG("Kernel=%p Pool=%d", Kernel, Pool);

     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
     gcmkVERIFY_ARGUMENT(VideoMemory != NULL);

     /* Extract the pointer to the gckGALDEVICE class. */
     device = (gckGALDEVICE) Kernel->context;

     /* Dispatch on pool. */
     switch (Pool)
     {
     case gcvPOOL_LOCAL_INTERNAL:
         /* Internal memory. */
         videoMemory = device->internalVidMem;
         break;

     case gcvPOOL_LOCAL_EXTERNAL:
         /* External memory. */
         videoMemory = device->externalVidMem;
         break;

     case gcvPOOL_SYSTEM:
         /* System memory. */
         videoMemory = device->contiguousVidMem;
         break;

     case gcvPOOL_INTERNAL_SRAM:
         /* Internal SRAM memory. */
         videoMemory = Kernel->sRAMVidMem[Kernel->sRAMIndex];
         break;

     case gcvPOOL_EXTERNAL_SRAM:
         /* External SRAM memory. */
         videoMemory = device->extSRAMVidMem[Kernel->extSRAMIndex];
         break;

     default:
         /* Unknown pool. */
         videoMemory = NULL;
     }

     /* Return pointer to the gckVIDMEM object. */
     *VideoMemory = videoMemory;

     /* Return status. */
     gcmkFOOTER_ARG("*VideoMemory=%p", *VideoMemory);
     return (videoMemory == NULL) ? gcvSTATUS_OUT_OF_MEMORY : gcvSTATUS_OK;
 }

 /*******************************************************************************
 **
 **  gckKERNEL_MapMemory
 **
 **  Map video memory into the current process space.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gctPHYS_ADDR Physical
 **          Physical address of video memory to map.
 **
 **      gctSIZE_T Bytes
 **          Number of bytes to map.
 **
 **  OUTPUT:
 **
 **      gctPOINTER * Logical
 **          Pointer to a variable that will hold the base address of the mapped
 **          memory region.
 */
 gceSTATUS
 gckKERNEL_MapMemory(
     IN gckKERNEL Kernel,
     IN gctPHYS_ADDR Physical,
     IN gctSIZE_T Bytes,
     OUT gctPOINTER * Logical
     )
 {
     gckKERNEL kernel = Kernel;
     gctPHYS_ADDR physical = gcmNAME_TO_PTR(Physical);

     return gckOS_MapMemory(Kernel->os, physical, Bytes, Logical);
 }

 /*******************************************************************************
 **
 **  gckKERNEL_UnmapMemory
 **
 **  Unmap video memory from the current process space.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gctPHYS_ADDR Physical
 **          Physical address of video memory to map.
 **
 **      gctSIZE_T Bytes
 **          Number of bytes to map.
 **
 **      gctPOINTER Logical
 **          Base address of the mapped memory region.
 **
 **  OUTPUT:
 **
 **      Nothing.
 */
 gceSTATUS
 gckKERNEL_UnmapMemory(
     IN gckKERNEL Kernel,
     IN gctPHYS_ADDR Physical,
     IN gctSIZE_T Bytes,
     IN gctPOINTER Logical,
     IN gctUINT32 ProcessID
     )
 {
     gckKERNEL kernel = Kernel;
     gctPHYS_ADDR physical = gcmNAME_TO_PTR(Physical);

     return gckOS_UnmapMemoryEx(Kernel->os, physical, Bytes, Logical, ProcessID);
 }

 /****************************************************************************
 **
 **  gckKERNEL_DestroyProcessReservedUserMap
 **
 **  Destroy process reserved memory
 **
 **  INPUT:
 **
 **      gctPHYS_ADDR Physical
 **          Physical address of video memory to map.
 **
 **      gctUINT32 Pid
 **          Process ID.
 */
 gceSTATUS
 gckKERNEL_DestroyProcessReservedUserMap(
     IN gckKERNEL Kernel,
     IN gctUINT32 Pid
     )
 {
     gceSTATUS status      = gcvSTATUS_OK;
     gckGALDEVICE device   = gcvNULL;
     gctSIZE_T bytes       = 0;
     gctPHYS_ADDR physHandle = gcvNULL;
     /* when unmap reserved memory, we don't need real logical*/
     gctPOINTER Logical = (gctPOINTER)0xFFFFFFFF;
     gctINT i;
     gcmkHEADER_ARG("Logical=0x%08x pid=%u",
                    Logical, Pid);
     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
     /* Extract the pointer to the gckGALDEVICE class. */
     device = (gckGALDEVICE) Kernel->context;

     physHandle = (PLINUX_MDL)device->internalPhysical;
     bytes = device->internalSize;
     if (bytes)
     {
         gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
     }

     physHandle = (PLINUX_MDL)device->externalPhysical;
     bytes = device->externalSize;
     if (bytes)
     {
         gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
     }

     /* System memory. */
     physHandle = (PLINUX_MDL)device->contiguousPhysical;
     bytes = device->contiguousSize;
     if (bytes)
     {
         gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
     }

     /* External shared SRAM memory. */
     for(i = 0; i < gcvSRAM_EXT_COUNT; i++)
     {
         physHandle = (PLINUX_MDL)device->extSRAMPhysical[i];
         bytes = device->extSRAMSizes[i];
         if (bytes)
         {
             gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
         }
     }

     /* Per core SRAM reserved usage. */
     for(i = 0; i < gcvSRAM_INTER_COUNT; i++)
     {
         if (!Kernel->sRAMPhysFaked[i])
         {
             physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[i];
             bytes = Kernel->sRAMSizes[i];
             if (bytes)
             {
                 gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
             }
         }
     }

     /* Retunn the status. */
     gcmkFOOTER_NO();
     return status;
 }

 /*******************************************************************************
 **
 **  gckKERNEL_MapVideoMemory
 **
 **  Get the logical address for a hardware specific memory address for the
 **  current process.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gctBOOL InUserSpace
 **          gcvTRUE to map the memory into the user space.
 **
 **      gcePOOL Pool
 **          Specify pool type.
 **
 **      gctUINT32 Offset
 **          Offset to pool start.
 **
 **      gctUINT32 Bytes
 **          Number of bytes to map.
 **
 **  OUTPUT:
 **
 **      gctPOINTER * Logical
 **          Pointer to a variable that will hold the logical address of the
 **          specified memory address.
 */
 gceSTATUS
 gckKERNEL_MapVideoMemory(
     IN gckKERNEL Kernel,
     IN gctBOOL InUserSpace,
     IN gcePOOL Pool,
     IN gctPHYS_ADDR Physical,
     IN gctUINT32 Offset,
     IN gctUINT32 Bytes,
     OUT gctPOINTER * Logical
     )
 {
     gckGALDEVICE device   = gcvNULL;
     gctSIZE_T bytes       = 0;
     gctPHYS_ADDR physHandle = gcvNULL;
     gceSTATUS status      = gcvSTATUS_OK;
     gctPOINTER logical    = gcvNULL;
     gctUINT64 mappingInOne  = 1;

     gcmkHEADER_ARG("Kernel=%p InUserSpace=%d Pool=%d Offset=%X Bytes=%X",
                    Kernel, InUserSpace, Pool, Offset, Bytes);

     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
     gcmkVERIFY_ARGUMENT(Logical != NULL);

     if (Physical)
     {
         gcmkONERROR(gckOS_QueryOption(Kernel->os, "allMapInOne", &mappingInOne));
     }

     if (mappingInOne)
     {
         /* Extract the pointer to the gckGALDEVICE class. */
         device = (gckGALDEVICE) Kernel->context;

         /* Dispatch on pool. */
         switch (Pool)
         {
         case gcvPOOL_LOCAL_INTERNAL:
             physHandle = (PLINUX_MDL)device->internalPhysical;
             bytes = device->internalSize;
             break;

         case gcvPOOL_LOCAL_EXTERNAL:
             physHandle = (PLINUX_MDL)device->externalPhysical;
             bytes = device->externalSize;
             break;

         case gcvPOOL_SYSTEM:
             /* System memory. */
             physHandle = (PLINUX_MDL)device->contiguousPhysical;
             bytes = device->contiguousSize;
             break;

         case gcvPOOL_EXTERNAL_SRAM:
             /* External shared SRAM memory. */
             physHandle = (PLINUX_MDL)device->extSRAMPhysical[Kernel->extSRAMIndex];
             bytes = device->extSRAMSizes[Kernel->extSRAMIndex];
             break;

         case gcvPOOL_INTERNAL_SRAM:
             /* Per core SRAM reserved usage. */
             if (Kernel->sRAMPhysFaked[Kernel->sRAMIndex])
             {
                 *Logical = gcvNULL;

                 gcmkFOOTER_NO();
                 return gcvSTATUS_OK;
             }
             /* Per core SRAM memory block. */
             else
             {
                 physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[Kernel->sRAMIndex];
                 bytes = Kernel->sRAMSizes[Kernel->sRAMIndex];
                 break;
             }

         default:
             /* Invalid memory pool. */
             gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
         }

     }
     else
     {
         physHandle = (PLINUX_MDL)Physical;
         bytes = Bytes;
         Offset = 0;
     }

     gcmkONERROR(gckOS_LockPages(Kernel->os, physHandle, bytes, gcvFALSE, &logical));
     /* Build logical address of specified address. */
     *Logical = (gctPOINTER)((gctUINT8_PTR)logical + Offset);
 OnError:
     /* Retunn the status. */
     gcmkFOOTER_ARG("*Logical=%p", gcmOPT_POINTER(Logical));
     return status;
 }


 /*******************************************************************************
 **
 **  gckKERNEL_UnmapVideoMemory
 **
 **  Unmap video memory for the current process.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gcePOOL Pool
 **          Specify pool type.

 **      gctUINT32 Address
 **          Hardware specific memory address.
 **
 **      gctUINT32 Pid
 **          Process ID of the current process.
 **
 **      gctSIZE_T Bytes
 **          Number of bytes to map.
 **
 **  OUTPUT:
 **
 **      Nothing.
 */
 gceSTATUS
 gckKERNEL_UnmapVideoMemory(
     IN gckKERNEL Kernel,
     IN gcePOOL Pool,
     IN gctPHYS_ADDR Physical,
     IN gctPOINTER Logical,
     IN gctUINT32 Pid,
     IN gctSIZE_T Bytes
     )
 {
     gceSTATUS status      = gcvSTATUS_OK;
     gckGALDEVICE device   = gcvNULL;
     gctSIZE_T bytes       = 0;
     gctPHYS_ADDR physHandle = gcvNULL;
     gctUINT64 mappingInOne  = 1;

     gcmkHEADER_ARG("Logical=0x%08x pid=%u Bytes=%u",
                    Logical, Pid, Bytes);

     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);

     if (Logical == gcvNULL)
     {
         return gcvSTATUS_OK;
     }

     if (Physical)
     {
         gcmkONERROR(gckOS_QueryOption(Kernel->os, "allMapInOne", &mappingInOne));
     }

     if (mappingInOne)
     {
         /* Extract the pointer to the gckGALDEVICE class. */
         device = (gckGALDEVICE) Kernel->context;

         /* Dispatch on pool. */
         switch (Pool)
         {
         case gcvPOOL_LOCAL_INTERNAL:
             physHandle = (PLINUX_MDL)device->internalPhysical;
             bytes = device->internalSize;
             break;

         case gcvPOOL_LOCAL_EXTERNAL:
             physHandle = (PLINUX_MDL)device->externalPhysical;
             bytes = device->externalSize;
             break;

         case gcvPOOL_SYSTEM:
             /* System memory. */
             physHandle = (PLINUX_MDL)device->contiguousPhysical;
             bytes = device->contiguousSize;
             break;

         case gcvPOOL_EXTERNAL_SRAM:
             /* External shared SRAM memory. */
             physHandle = (PLINUX_MDL)device->extSRAMPhysical[Kernel->extSRAMIndex];
             bytes = device->extSRAMSizes[Kernel->extSRAMIndex];
             break;

         case gcvPOOL_INTERNAL_SRAM:
             /* Per core SRAM reserved usage. */
             if (Kernel->sRAMPhysFaked[Kernel->sRAMIndex])
             {
                 gcmkFOOTER_NO();
                 return gcvSTATUS_OK;
             }
             /* Per core SRAM memory block. */
             else
             {
                 physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[Kernel->sRAMIndex];
                 bytes = Kernel->sRAMSizes[Kernel->sRAMIndex];
                 break;
             }

         default:
             /* Invalid memory pool. */
             gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
         }
     }
     else
     {
         physHandle = (PLINUX_MDL)Physical;
         bytes = Bytes;
     }

     gcmkONERROR(gckOS_UnlockPages(Kernel->os, physHandle, bytes, Logical));

 OnError:
     /* Retunn the status. */
     gcmkFOOTER_NO();
     return status;

 }

 /*******************************************************************************
 **
 **  gckKERNEL_Notify
 **
 **  This function iscalled by clients to notify the gckKERNRL object of an event.
 **
 **  INPUT:
 **
 **      gckKERNEL Kernel
 **          Pointer to an gckKERNEL object.
 **
 **      gceNOTIFY Notification
 **          Notification event.
 **
 **  OUTPUT:
 **
 **      Nothing.
 */
 gceSTATUS
 gckKERNEL_Notify(
     IN gckKERNEL Kernel,
     IN gceNOTIFY Notification
     )
 {
     gceSTATUS status = gcvSTATUS_OK;

     gcmkHEADER_ARG("Kernel=%p Notification=%d", Kernel, Notification);

     /* Verify the arguments. */
     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);

     /* Dispatch on notifcation. */
     switch (Notification)
     {
     case gcvNOTIFY_INTERRUPT:
         /* Process the interrupt. */
 #if COMMAND_PROCESSOR_VERSION > 1
         status = gckINTERRUPT_Notify(Kernel->interrupt, 0);
 #else
         status = gckHARDWARE_Notify(Kernel->hardware);
 #endif
         break;

     default:
         break;
     }

     /* Success. */
     gcmkFOOTER();
     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"

	#define _GC_OBJ_ZONE gcvZONE_KERNEL

	/******************************************************************************\
	***************************** gckKERNEL API Code ****************************
	\******************************************************************************/

	/*******************************************************************************
	**
	** gckKERNEL_QueryVideoMemory
	**
	** Query the amount of video memory.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** OUTPUT:
	**
	** gcsHAL_INTERFACE * Interface
	** Pointer to an gcsHAL_INTERFACE structure that will be filled in with
	** the memory information.
	*/
	gceSTATUS
	gckKERNEL_QueryVideoMemory(
	IN gckKERNEL Kernel,
	OUT gcsHAL_INTERFACE * Interface
	)
	{
	gckGALDEVICE device;

	gcmkHEADER_ARG("Kernel=%p", Kernel);

	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
	gcmkVERIFY_ARGUMENT(Interface != NULL);

	/* Extract the pointer to the gckGALDEVICE class. */
	device = (gckGALDEVICE) Kernel->context;

	/* Get internal memory size and physical address. */
	Interface->u.QueryVideoMemory.internalSize = device->internalSize;
	Interface->u.QueryVideoMemory.internalPhysName = device->internalPhysName;

	/* Get external memory size and physical address. */
	Interface->u.QueryVideoMemory.externalSize = device->externalSize;
	Interface->u.QueryVideoMemory.externalPhysName = device->externalPhysName;

	/* Get contiguous memory size and physical address. */
	Interface->u.QueryVideoMemory.contiguousSize = device->contiguousSize;
	Interface->u.QueryVideoMemory.contiguousPhysName = device->contiguousPhysName;

	/* Success. */
	gcmkFOOTER_NO();
	return gcvSTATUS_OK;
	}

	/*******************************************************************************
	**
	** gckKERNEL_GetVideoMemoryPool
	**
	** Get the gckVIDMEM object belonging to the specified pool.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gcePOOL Pool
	** Pool to query gckVIDMEM object for.
	**
	** OUTPUT:
	**
	** gckVIDMEM * VideoMemory
	** Pointer to a variable that will hold the pointer to the gckVIDMEM
	** object belonging to the requested pool.
	*/
	gceSTATUS
	gckKERNEL_GetVideoMemoryPool(
	IN gckKERNEL Kernel,
	IN gcePOOL Pool,
	OUT gckVIDMEM * VideoMemory
	)
	{
	gckGALDEVICE device;
	gckVIDMEM videoMemory;

	gcmkHEADER_ARG("Kernel=%p Pool=%d", Kernel, Pool);

	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
	gcmkVERIFY_ARGUMENT(VideoMemory != NULL);

	/* Extract the pointer to the gckGALDEVICE class. */
	device = (gckGALDEVICE) Kernel->context;

	/* Dispatch on pool. */
	switch (Pool)
	{
	case gcvPOOL_LOCAL_INTERNAL:
	/* Internal memory. */
	videoMemory = device->internalVidMem;
	break;

	case gcvPOOL_LOCAL_EXTERNAL:
	/* External memory. */
	videoMemory = device->externalVidMem;
	break;

	case gcvPOOL_SYSTEM:
	/* System memory. */
	videoMemory = device->contiguousVidMem;
	break;

	case gcvPOOL_INTERNAL_SRAM:
	/* Internal SRAM memory. */
	videoMemory = Kernel->sRAMVidMem[Kernel->sRAMIndex];
	break;

	case gcvPOOL_EXTERNAL_SRAM:
	/* External SRAM memory. */
	videoMemory = device->extSRAMVidMem[Kernel->extSRAMIndex];
	break;

	default:
	/* Unknown pool. */
	videoMemory = NULL;
	}

	/* Return pointer to the gckVIDMEM object. */
	*VideoMemory = videoMemory;

	/* Return status. */
	gcmkFOOTER_ARG("VideoMemory=%p", VideoMemory);
	return (videoMemory == NULL) ? gcvSTATUS_OUT_OF_MEMORY : gcvSTATUS_OK;
	}

	/*******************************************************************************
	**
	** gckKERNEL_MapMemory
	**
	** Map video memory into the current process space.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gctPHYS_ADDR Physical
	** Physical address of video memory to map.
	**
	** gctSIZE_T Bytes
	** Number of bytes to map.
	**
	** OUTPUT:
	**
	** gctPOINTER * Logical
	** Pointer to a variable that will hold the base address of the mapped
	** memory region.
	*/
	gceSTATUS
	gckKERNEL_MapMemory(
	IN gckKERNEL Kernel,
	IN gctPHYS_ADDR Physical,
	IN gctSIZE_T Bytes,
	OUT gctPOINTER * Logical
	)
	{
	gckKERNEL kernel = Kernel;
	gctPHYS_ADDR physical = gcmNAME_TO_PTR(Physical);

	return gckOS_MapMemory(Kernel->os, physical, Bytes, Logical);
	}

	/*******************************************************************************
	**
	** gckKERNEL_UnmapMemory
	**
	** Unmap video memory from the current process space.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gctPHYS_ADDR Physical
	** Physical address of video memory to map.
	**
	** gctSIZE_T Bytes
	** Number of bytes to map.
	**
	** gctPOINTER Logical
	** Base address of the mapped memory region.
	**
	** OUTPUT:
	**
	** Nothing.
	*/
	gceSTATUS
	gckKERNEL_UnmapMemory(
	IN gckKERNEL Kernel,
	IN gctPHYS_ADDR Physical,
	IN gctSIZE_T Bytes,
	IN gctPOINTER Logical,
	IN gctUINT32 ProcessID
	)
	{
	gckKERNEL kernel = Kernel;
	gctPHYS_ADDR physical = gcmNAME_TO_PTR(Physical);

	return gckOS_UnmapMemoryEx(Kernel->os, physical, Bytes, Logical, ProcessID);
	}

	/****************************************************************************
	**
	** gckKERNEL_DestroyProcessReservedUserMap
	**
	** Destroy process reserved memory
	**
	** INPUT:
	**
	** gctPHYS_ADDR Physical
	** Physical address of video memory to map.
	**
	** gctUINT32 Pid
	** Process ID.
	*/
	gceSTATUS
	gckKERNEL_DestroyProcessReservedUserMap(
	IN gckKERNEL Kernel,
	IN gctUINT32 Pid
	)
	{
	gceSTATUS status = gcvSTATUS_OK;
	gckGALDEVICE device = gcvNULL;
	gctSIZE_T bytes = 0;
	gctPHYS_ADDR physHandle = gcvNULL;
	/* when unmap reserved memory, we don't need real logical*/
	gctPOINTER Logical = (gctPOINTER)0xFFFFFFFF;
	gctINT i;
	gcmkHEADER_ARG("Logical=0x%08x pid=%u",
	Logical, Pid);
	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
	/* Extract the pointer to the gckGALDEVICE class. */
	device = (gckGALDEVICE) Kernel->context;

	physHandle = (PLINUX_MDL)device->internalPhysical;
	bytes = device->internalSize;
	if (bytes)
	{
	gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
	}

	physHandle = (PLINUX_MDL)device->externalPhysical;
	bytes = device->externalSize;
	if (bytes)
	{
	gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
	}

	/* System memory. */
	physHandle = (PLINUX_MDL)device->contiguousPhysical;
	bytes = device->contiguousSize;
	if (bytes)
	{
	gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
	}

	/* External shared SRAM memory. */
	for(i = 0; i < gcvSRAM_EXT_COUNT; i++)
	{
	physHandle = (PLINUX_MDL)device->extSRAMPhysical[i];
	bytes = device->extSRAMSizes[i];
	if (bytes)
	{
	gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
	}
	}

	/* Per core SRAM reserved usage. */
	for(i = 0; i < gcvSRAM_INTER_COUNT; i++)
	{
	if (!Kernel->sRAMPhysFaked[i])
	{
	physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[i];
	bytes = Kernel->sRAMSizes[i];
	if (bytes)
	{
	gckOS_UnmapMemoryEx(Kernel->os, physHandle, bytes, Logical, Pid);
	}
	}
	}

	/* Retunn the status. */
	gcmkFOOTER_NO();
	return status;
	}

	/*******************************************************************************
	**
	** gckKERNEL_MapVideoMemory
	**
	** Get the logical address for a hardware specific memory address for the
	** current process.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gctBOOL InUserSpace
	** gcvTRUE to map the memory into the user space.
	**
	** gcePOOL Pool
	** Specify pool type.
	**
	** gctUINT32 Offset
	** Offset to pool start.
	**
	** gctUINT32 Bytes
	** Number of bytes to map.
	**
	** OUTPUT:
	**
	** gctPOINTER * Logical
	** Pointer to a variable that will hold the logical address of the
	** specified memory address.
	*/
	gceSTATUS
	gckKERNEL_MapVideoMemory(
	IN gckKERNEL Kernel,
	IN gctBOOL InUserSpace,
	IN gcePOOL Pool,
	IN gctPHYS_ADDR Physical,
	IN gctUINT32 Offset,
	IN gctUINT32 Bytes,
	OUT gctPOINTER * Logical
	)
	{
	gckGALDEVICE device = gcvNULL;
	gctSIZE_T bytes = 0;
	gctPHYS_ADDR physHandle = gcvNULL;
	gceSTATUS status = gcvSTATUS_OK;
	gctPOINTER logical = gcvNULL;
	gctUINT64 mappingInOne = 1;

	gcmkHEADER_ARG("Kernel=%p InUserSpace=%d Pool=%d Offset=%X Bytes=%X",
	Kernel, InUserSpace, Pool, Offset, Bytes);

	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
	gcmkVERIFY_ARGUMENT(Logical != NULL);

	if (Physical)
	{
	gcmkONERROR(gckOS_QueryOption(Kernel->os, "allMapInOne", &mappingInOne));
	}

	if (mappingInOne)
	{
	/* Extract the pointer to the gckGALDEVICE class. */
	device = (gckGALDEVICE) Kernel->context;

	/* Dispatch on pool. */
	switch (Pool)
	{
	case gcvPOOL_LOCAL_INTERNAL:
	physHandle = (PLINUX_MDL)device->internalPhysical;
	bytes = device->internalSize;
	break;

	case gcvPOOL_LOCAL_EXTERNAL:
	physHandle = (PLINUX_MDL)device->externalPhysical;
	bytes = device->externalSize;
	break;

	case gcvPOOL_SYSTEM:
	/* System memory. */
	physHandle = (PLINUX_MDL)device->contiguousPhysical;
	bytes = device->contiguousSize;
	break;

	case gcvPOOL_EXTERNAL_SRAM:
	/* External shared SRAM memory. */
	physHandle = (PLINUX_MDL)device->extSRAMPhysical[Kernel->extSRAMIndex];
	bytes = device->extSRAMSizes[Kernel->extSRAMIndex];
	break;

	case gcvPOOL_INTERNAL_SRAM:
	/* Per core SRAM reserved usage. */
	if (Kernel->sRAMPhysFaked[Kernel->sRAMIndex])
	{
	*Logical = gcvNULL;

	gcmkFOOTER_NO();
	return gcvSTATUS_OK;
	}
	/* Per core SRAM memory block. */
	else
	{
	physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[Kernel->sRAMIndex];
	bytes = Kernel->sRAMSizes[Kernel->sRAMIndex];
	break;
	}

	default:
	/* Invalid memory pool. */
	gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
	}

	}
	else
	{
	physHandle = (PLINUX_MDL)Physical;
	bytes = Bytes;
	Offset = 0;
	}

	gcmkONERROR(gckOS_LockPages(Kernel->os, physHandle, bytes, gcvFALSE, &logical));
	/* Build logical address of specified address. */
	*Logical = (gctPOINTER)((gctUINT8_PTR)logical + Offset);
	OnError:
	/* Retunn the status. */
	gcmkFOOTER_ARG("*Logical=%p", gcmOPT_POINTER(Logical));
	return status;
	}


	/*******************************************************************************
	**
	** gckKERNEL_UnmapVideoMemory
	**
	** Unmap video memory for the current process.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gcePOOL Pool
	** Specify pool type.

	** gctUINT32 Address
	** Hardware specific memory address.
	**
	** gctUINT32 Pid
	** Process ID of the current process.
	**
	** gctSIZE_T Bytes
	** Number of bytes to map.
	**
	** OUTPUT:
	**
	** Nothing.
	*/
	gceSTATUS
	gckKERNEL_UnmapVideoMemory(
	IN gckKERNEL Kernel,
	IN gcePOOL Pool,
	IN gctPHYS_ADDR Physical,
	IN gctPOINTER Logical,
	IN gctUINT32 Pid,
	IN gctSIZE_T Bytes
	)
	{
	gceSTATUS status = gcvSTATUS_OK;
	gckGALDEVICE device = gcvNULL;
	gctSIZE_T bytes = 0;
	gctPHYS_ADDR physHandle = gcvNULL;
	gctUINT64 mappingInOne = 1;

	gcmkHEADER_ARG("Logical=0x%08x pid=%u Bytes=%u",
	Logical, Pid, Bytes);

	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);

	if (Logical == gcvNULL)
	{
	return gcvSTATUS_OK;
	}

	if (Physical)
	{
	gcmkONERROR(gckOS_QueryOption(Kernel->os, "allMapInOne", &mappingInOne));
	}

	if (mappingInOne)
	{
	/* Extract the pointer to the gckGALDEVICE class. */
	device = (gckGALDEVICE) Kernel->context;

	/* Dispatch on pool. */
	switch (Pool)
	{
	case gcvPOOL_LOCAL_INTERNAL:
	physHandle = (PLINUX_MDL)device->internalPhysical;
	bytes = device->internalSize;
	break;

	case gcvPOOL_LOCAL_EXTERNAL:
	physHandle = (PLINUX_MDL)device->externalPhysical;
	bytes = device->externalSize;
	break;

	case gcvPOOL_SYSTEM:
	/* System memory. */
	physHandle = (PLINUX_MDL)device->contiguousPhysical;
	bytes = device->contiguousSize;
	break;

	case gcvPOOL_EXTERNAL_SRAM:
	/* External shared SRAM memory. */
	physHandle = (PLINUX_MDL)device->extSRAMPhysical[Kernel->extSRAMIndex];
	bytes = device->extSRAMSizes[Kernel->extSRAMIndex];
	break;

	case gcvPOOL_INTERNAL_SRAM:
	/* Per core SRAM reserved usage. */
	if (Kernel->sRAMPhysFaked[Kernel->sRAMIndex])
	{
	gcmkFOOTER_NO();
	return gcvSTATUS_OK;
	}
	/* Per core SRAM memory block. */
	else
	{
	physHandle = (PLINUX_MDL)Kernel->sRAMPhysical[Kernel->sRAMIndex];
	bytes = Kernel->sRAMSizes[Kernel->sRAMIndex];
	break;
	}

	default:
	/* Invalid memory pool. */
	gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
	}
	}
	else
	{
	physHandle = (PLINUX_MDL)Physical;
	bytes = Bytes;
	}

	gcmkONERROR(gckOS_UnlockPages(Kernel->os, physHandle, bytes, Logical));

	OnError:
	/* Retunn the status. */
	gcmkFOOTER_NO();
	return status;

	}

	/*******************************************************************************
	**
	** gckKERNEL_Notify
	**
	** This function iscalled by clients to notify the gckKERNRL object of an event.
	**
	** INPUT:
	**
	** gckKERNEL Kernel
	** Pointer to an gckKERNEL object.
	**
	** gceNOTIFY Notification
	** Notification event.
	**
	** OUTPUT:
	**
	** Nothing.
	*/
	gceSTATUS
	gckKERNEL_Notify(
	IN gckKERNEL Kernel,
	IN gceNOTIFY Notification
	)
	{
	gceSTATUS status = gcvSTATUS_OK;

	gcmkHEADER_ARG("Kernel=%p Notification=%d", Kernel, Notification);

	/* Verify the arguments. */
	gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);

	/* Dispatch on notifcation. */
	switch (Notification)
	{
	case gcvNOTIFY_INTERRUPT:
	/* Process the interrupt. */
	#if COMMAND_PROCESSOR_VERSION > 1
	status = gckINTERRUPT_Notify(Kernel->interrupt, 0);
	#else
	status = gckHARDWARE_Notify(Kernel->hardware);
	#endif
	break;

	default:
	break;
	}

	/* Success. */
	gcmkFOOTER();
	return status;
	}