blob: 14289f0ada45aac31af8a427226a4beacb17f674 [file] [log] [blame]
/****************************************************************************
*
* Copyright (c) 2005 - 2014 by Vivante Corp. All rights reserved.
*
* The material in this file is confidential and contains trade secrets
* of Vivante Corporation. This is proprietary information owned by
* Vivante Corporation. No part of this work may be disclosed,
* reproduced, copied, transmitted, or used in any way for any purpose,
* without the express written permission of Vivante Corporation.
*
*****************************************************************************/
#ifndef __gc_hal_h_
#define __gc_hal_h_
#include "gc_hal_rename.h"
#include "gc_hal_types.h"
#include "gc_hal_enum.h"
#include "gc_hal_base.h"
#include "gc_hal_profiler.h"
#include "gc_hal_driver.h"
#if gcdENABLE_3D
#include "gc_hal_statistics.h"
#endif
#if gcdSECURITY
#include "gc_hal_security_interface.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************\
******************************* Alignment Macros *******************************
\******************************************************************************/
/* Alignment with a non-power of two value. */
#define gcmALIGN_NP2(n, align) \
( \
((n) + (align) - 1) - (((n) + (align) - 1) % (align)) \
)
/* Alignment with a power of two value. */
#define gcmALIGN(n, align) \
( \
((n) + ((align) - 1)) & ~((align) - 1) \
)
#define gcmALIGN_BASE(n, align) \
( \
((n) & ~((align) - 1)) \
)
/******************************************************************************\
***************************** Element Count Macro *****************************
\******************************************************************************/
#define gcmSIZEOF(a) \
( \
(gctSIZE_T) (sizeof(a)) \
)
#define gcmCOUNTOF(a) \
( \
sizeof(a) / sizeof(a[0]) \
)
/******************************************************************************\
********************************* Cast Macro **********************************
\******************************************************************************/
#define gcmNAME_TO_PTR(na) \
gckKERNEL_QueryPointerFromName(kernel, gcmALL_TO_UINT32(na))
#define gcmPTR_TO_NAME(ptr) \
gckKERNEL_AllocateNameFromPointer(kernel, ptr)
#define gcmRELEASE_NAME(na) \
gckKERNEL_DeleteName(kernel, gcmALL_TO_UINT32(na))
#define gcmALL_TO_UINT32(t) \
( \
(gctUINT32) (gctUINTPTR_T) (t)\
)
#define gcmPTR_TO_UINT64(p) \
( \
(gctUINT64) (gctUINTPTR_T) (p)\
)
#define gcmUINT64_TO_PTR(u) \
( \
(gctPOINTER) (gctUINTPTR_T) (u)\
)
#define gcmUINT64_TO_TYPE(u, t) \
( \
(t) (gctUINTPTR_T) (u)\
)
/******************************************************************************\
******************************** Useful Macro *********************************
\******************************************************************************/
#define gcvINVALID_ADDRESS ~0U
#define gcmGET_PRE_ROTATION(rotate) \
((rotate) & (~(gcvSURF_POST_FLIP_X | gcvSURF_POST_FLIP_Y)))
#define gcmGET_POST_ROTATION(rotate) \
((rotate) & (gcvSURF_POST_FLIP_X | gcvSURF_POST_FLIP_Y))
/******************************************************************************\
******************************** gcsOBJECT Object *******************************
\******************************************************************************/
/* Type of objects. */
typedef enum _gceOBJECT_TYPE
{
gcvOBJ_UNKNOWN = 0,
gcvOBJ_2D = gcmCC('2','D',' ',' '),
gcvOBJ_3D = gcmCC('3','D',' ',' '),
gcvOBJ_ATTRIBUTE = gcmCC('A','T','T','R'),
gcvOBJ_BRUSHCACHE = gcmCC('B','R','U','$'),
gcvOBJ_BRUSHNODE = gcmCC('B','R','U','n'),
gcvOBJ_BRUSH = gcmCC('B','R','U','o'),
gcvOBJ_BUFFER = gcmCC('B','U','F','R'),
gcvOBJ_COMMAND = gcmCC('C','M','D',' '),
gcvOBJ_COMMANDBUFFER = gcmCC('C','M','D','B'),
gcvOBJ_CONTEXT = gcmCC('C','T','X','T'),
gcvOBJ_DEVICE = gcmCC('D','E','V',' '),
gcvOBJ_DUMP = gcmCC('D','U','M','P'),
gcvOBJ_EVENT = gcmCC('E','V','N','T'),
gcvOBJ_FUNCTION = gcmCC('F','U','N','C'),
gcvOBJ_HAL = gcmCC('H','A','L',' '),
gcvOBJ_HARDWARE = gcmCC('H','A','R','D'),
gcvOBJ_HEAP = gcmCC('H','E','A','P'),
gcvOBJ_INDEX = gcmCC('I','N','D','X'),
gcvOBJ_INTERRUPT = gcmCC('I','N','T','R'),
gcvOBJ_KERNEL = gcmCC('K','E','R','N'),
gcvOBJ_KERNEL_FUNCTION = gcmCC('K','F','C','N'),
gcvOBJ_MEMORYBUFFER = gcmCC('M','E','M','B'),
gcvOBJ_MMU = gcmCC('M','M','U',' '),
gcvOBJ_OS = gcmCC('O','S',' ',' '),
gcvOBJ_OUTPUT = gcmCC('O','U','T','P'),
gcvOBJ_PAINT = gcmCC('P','N','T',' '),
gcvOBJ_PATH = gcmCC('P','A','T','H'),
gcvOBJ_QUEUE = gcmCC('Q','U','E',' '),
gcvOBJ_SAMPLER = gcmCC('S','A','M','P'),
gcvOBJ_SHADER = gcmCC('S','H','D','R'),
gcvOBJ_STREAM = gcmCC('S','T','R','M'),
gcvOBJ_SURF = gcmCC('S','U','R','F'),
gcvOBJ_TEXTURE = gcmCC('T','X','T','R'),
gcvOBJ_UNIFORM = gcmCC('U','N','I','F'),
gcvOBJ_VARIABLE = gcmCC('V','A','R','I'),
gcvOBJ_VERTEX = gcmCC('V','R','T','X'),
gcvOBJ_VIDMEM = gcmCC('V','M','E','M'),
gcvOBJ_VG = gcmCC('V','G',' ',' '),
gcvOBJ_BUFOBJ = gcmCC('B','U','F','O'),
gcvOBJ_UNIFORM_BLOCK = gcmCC('U','B','L','K'),
gcvOBJ_CL = gcmCC('C','L',' ',' '),
}
gceOBJECT_TYPE;
/* gcsOBJECT object defintinon. */
typedef struct _gcsOBJECT
{
/* Type of an object. */
gceOBJECT_TYPE type;
}
gcsOBJECT;
typedef struct _gckHARDWARE * gckHARDWARE;
/* CORE flags. */
typedef enum _gceCORE
{
gcvCORE_MAJOR = 0x0,
gcvCORE_2D = 0x1,
gcvCORE_VG = 0x2,
#if gcdMULTI_GPU_AFFINITY
gcvCORE_OCL = 0x3,
#endif
}
gceCORE;
#if gcdMULTI_GPU_AFFINITY
#define gcdMAX_GPU_COUNT 4
#else
#define gcdMAX_GPU_COUNT 3
#endif
#define gcdMAX_SURF_LAYER 4
#define gcdMAX_DRAW_BUFFERS 4
/*******************************************************************************
**
** gcmVERIFY_OBJECT
**
** Assert if an object is invalid or is not of the specified type. If the
** object is invalid or not of the specified type, gcvSTATUS_INVALID_OBJECT
** will be returned from the current function. In retail mode this macro
** does nothing.
**
** ARGUMENTS:
**
** obj Object to test.
** t Expected type of the object.
*/
#if gcmIS_DEBUG(gcdDEBUG_TRACE)
#define _gcmVERIFY_OBJECT(prefix, obj, t) \
if ((obj) == gcvNULL) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "VERIFY_OBJECT failed: NULL"); \
prefix##TRACE(gcvLEVEL_ERROR, " expected: %c%c%c%c", \
gcmCC_PRINT(t)); \
prefix##ASSERT((obj) != gcvNULL); \
prefix##FOOTER_ARG("status=%d", gcvSTATUS_INVALID_OBJECT); \
return gcvSTATUS_INVALID_OBJECT; \
} \
else if (((gcsOBJECT*) (obj))->type != t) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "VERIFY_OBJECT failed: %c%c%c%c", \
gcmCC_PRINT(((gcsOBJECT*) (obj))->type)); \
prefix##TRACE(gcvLEVEL_ERROR, " expected: %c%c%c%c", \
gcmCC_PRINT(t)); \
prefix##ASSERT(((gcsOBJECT*)(obj))->type == t); \
prefix##FOOTER_ARG("status=%d", gcvSTATUS_INVALID_OBJECT); \
return gcvSTATUS_INVALID_OBJECT; \
}
# define gcmVERIFY_OBJECT(obj, t) _gcmVERIFY_OBJECT(gcm, obj, t)
# define gcmkVERIFY_OBJECT(obj, t) _gcmVERIFY_OBJECT(gcmk, obj, t)
#else
# define gcmVERIFY_OBJECT(obj, t) do {} while (gcvFALSE)
# define gcmkVERIFY_OBJECT(obj, t) do {} while (gcvFALSE)
#endif
/******************************************************************************/
/*VERIFY_OBJECT if special return expected*/
/******************************************************************************/
#ifndef EGL_API_ANDROID
# define _gcmVERIFY_OBJECT_RETURN(prefix, obj, t, retVal) \
do \
{ \
if ((obj) == gcvNULL) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "VERIFY_OBJECT_RETURN failed: NULL"); \
prefix##TRACE(gcvLEVEL_ERROR, " expected: %c%c%c%c", \
gcmCC_PRINT(t)); \
prefix##ASSERT((obj) != gcvNULL); \
prefix##FOOTER_ARG("retVal=%d", retVal); \
return retVal; \
} \
else if (((gcsOBJECT*) (obj))->type != t) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "VERIFY_OBJECT_RETURN failed: %c%c%c%c", \
gcmCC_PRINT(((gcsOBJECT*) (obj))->type)); \
prefix##TRACE(gcvLEVEL_ERROR, " expected: %c%c%c%c", \
gcmCC_PRINT(t)); \
prefix##ASSERT(((gcsOBJECT*)(obj))->type == t); \
prefix##FOOTER_ARG("retVal=%d", retVal); \
return retVal; \
} \
} \
while (gcvFALSE)
# define gcmVERIFY_OBJECT_RETURN(obj, t, retVal) \
_gcmVERIFY_OBJECT_RETURN(gcm, obj, t, retVal)
# define gcmkVERIFY_OBJECT_RETURN(obj, t, retVal) \
_gcmVERIFY_OBJECT_RETURN(gcmk, obj, t, retVal)
#else
# define gcmVERIFY_OBJECT_RETURN(obj, t) do {} while (gcvFALSE)
# define gcmVERIFY_OBJECT_RETURN(obj, t) do {} while (gcvFALSE)
#endif
/******************************************************************************\
********************************** gckOS Object *********************************
\******************************************************************************/
/* Construct a new gckOS object. */
gceSTATUS
gckOS_Construct(
IN gctPOINTER Context,
OUT gckOS * Os
);
/* Destroy an gckOS object. */
gceSTATUS
gckOS_Destroy(
IN gckOS Os
);
/* Query the video memory. */
gceSTATUS
gckOS_QueryVideoMemory(
IN gckOS Os,
OUT gctPHYS_ADDR * InternalAddress,
OUT gctSIZE_T * InternalSize,
OUT gctPHYS_ADDR * ExternalAddress,
OUT gctSIZE_T * ExternalSize,
OUT gctPHYS_ADDR * ContiguousAddress,
OUT gctSIZE_T * ContiguousSize
);
/* Allocate memory from the heap. */
gceSTATUS
gckOS_Allocate(
IN gckOS Os,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Memory
);
/* Free allocated memory. */
gceSTATUS
gckOS_Free(
IN gckOS Os,
IN gctPOINTER Memory
);
/* Wrapper for allocation memory.. */
gceSTATUS
gckOS_AllocateMemory(
IN gckOS Os,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Memory
);
/* Wrapper for freeing memory. */
gceSTATUS
gckOS_FreeMemory(
IN gckOS Os,
IN gctPOINTER Memory
);
/* Allocate paged memory. */
gceSTATUS
gckOS_AllocatePagedMemory(
IN gckOS Os,
IN gctSIZE_T Bytes,
OUT gctPHYS_ADDR * Physical
);
/* Allocate paged memory. */
gceSTATUS
gckOS_AllocatePagedMemoryEx(
IN gckOS Os,
IN gctUINT32 Flag,
IN gctSIZE_T Bytes,
OUT gctUINT32 * Gid,
OUT gctPHYS_ADDR * Physical
);
/* Lock pages. */
gceSTATUS
gckOS_LockPages(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctBOOL Cacheable,
OUT gctPOINTER * Logical,
OUT gctSIZE_T * PageCount
);
/* Map pages. */
gceSTATUS
gckOS_MapPages(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T PageCount,
IN gctPOINTER PageTable
);
/* Map pages. */
gceSTATUS
gckOS_MapPagesEx(
IN gckOS Os,
IN gceCORE Core,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T PageCount,
IN gctUINT32 Address,
IN gctPOINTER PageTable
);
gceSTATUS
gckOS_UnmapPages(
IN gckOS Os,
IN gctSIZE_T PageCount,
IN gctUINT32 Address
);
/* Unlock pages. */
gceSTATUS
gckOS_UnlockPages(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctPOINTER Logical
);
/* Free paged memory. */
gceSTATUS
gckOS_FreePagedMemory(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes
);
/* Allocate non-paged memory. */
gceSTATUS
gckOS_AllocateNonPagedMemory(
IN gckOS Os,
IN gctBOOL InUserSpace,
IN OUT gctSIZE_T * Bytes,
OUT gctPHYS_ADDR * Physical,
OUT gctPOINTER * Logical
);
/* Free non-paged memory. */
gceSTATUS
gckOS_FreeNonPagedMemory(
IN gckOS Os,
IN gctSIZE_T Bytes,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical
);
/* Allocate contiguous memory. */
gceSTATUS
gckOS_AllocateContiguous(
IN gckOS Os,
IN gctBOOL InUserSpace,
IN OUT gctSIZE_T * Bytes,
OUT gctPHYS_ADDR * Physical,
OUT gctPOINTER * Logical
);
/* Free contiguous memory. */
gceSTATUS
gckOS_FreeContiguous(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes
);
/* Get the number fo bytes per page. */
gceSTATUS
gckOS_GetPageSize(
IN gckOS Os,
OUT gctSIZE_T * PageSize
);
/* Get the physical address of a corresponding logical address. */
gceSTATUS
gckOS_GetPhysicalAddress(
IN gckOS Os,
IN gctPOINTER Logical,
OUT gctUINT32 * Address
);
/* Get the physical address of a corresponding user logical address. */
gceSTATUS
gckOS_UserLogicalToPhysical(
IN gckOS Os,
IN gctPOINTER Logical,
OUT gctUINT32 * Address
);
/* Get the physical address of a corresponding logical address. */
gceSTATUS
gckOS_GetPhysicalAddressProcess(
IN gckOS Os,
IN gctPOINTER Logical,
IN gctUINT32 ProcessID,
OUT gctUINT32 * Address
);
/* Map physical memory. */
gceSTATUS
gckOS_MapPhysical(
IN gckOS Os,
IN gctUINT32 Physical,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Logical
);
/* Unmap previously mapped physical memory. */
gceSTATUS
gckOS_UnmapPhysical(
IN gckOS Os,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes
);
/* Get real physical address from descriptor. */
gceSTATUS
gckOS_PhysicalToPhysicalAddress(
IN gckOS Os,
IN gctPOINTER Physical,
OUT gctUINT32 * PhysicalAddress
);
/* Read data from a hardware register. */
gceSTATUS
gckOS_ReadRegister(
IN gckOS Os,
IN gctUINT32 Address,
OUT gctUINT32 * Data
);
/* Read data from a hardware register. */
gceSTATUS
gckOS_ReadRegisterEx(
IN gckOS Os,
IN gceCORE Core,
IN gctUINT32 Address,
OUT gctUINT32 * Data
);
/* Write data to a hardware register. */
gceSTATUS
gckOS_WriteRegister(
IN gckOS Os,
IN gctUINT32 Address,
IN gctUINT32 Data
);
/* Write data to a hardware register. */
gceSTATUS
gckOS_WriteRegisterEx(
IN gckOS Os,
IN gceCORE Core,
IN gctUINT32 Address,
IN gctUINT32 Data
);
#if gcdMULTI_GPU
gceSTATUS
gckOS_ReadRegisterByCoreId(
IN gckOS Os,
IN gceCORE Core,
IN gctUINT32 CoreId,
IN gctUINT32 Address,
OUT gctUINT32 * Data
);
gceSTATUS
gckOS_WriteRegisterByCoreId(
IN gckOS Os,
IN gceCORE Core,
IN gctUINT32 CoreId,
IN gctUINT32 Address,
IN gctUINT32 Data
);
#endif
/* Write data to a 32-bit memory location. */
gceSTATUS
gckOS_WriteMemory(
IN gckOS Os,
IN gctPOINTER Address,
IN gctUINT32 Data
);
/* Map physical memory into the process space. */
gceSTATUS
gckOS_MapMemory(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Logical
);
/* Unmap physical memory from the specified process space. */
gceSTATUS
gckOS_UnmapMemoryEx(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctPOINTER Logical,
IN gctUINT32 PID
);
/* Unmap physical memory from the process space. */
gceSTATUS
gckOS_UnmapMemory(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctPOINTER Logical
);
/* Unmap user logical memory out of physical memory.
* This function is only supported in Linux currently.
*/
gceSTATUS
gckOS_UnmapUserLogical(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctPOINTER Logical
);
/* Create a new mutex. */
gceSTATUS
gckOS_CreateMutex(
IN gckOS Os,
OUT gctPOINTER * Mutex
);
/* Delete a mutex. */
gceSTATUS
gckOS_DeleteMutex(
IN gckOS Os,
IN gctPOINTER Mutex
);
/* Acquire a mutex. */
gceSTATUS
gckOS_AcquireMutex(
IN gckOS Os,
IN gctPOINTER Mutex,
IN gctUINT32 Timeout
);
/* Release a mutex. */
gceSTATUS
gckOS_ReleaseMutex(
IN gckOS Os,
IN gctPOINTER Mutex
);
/* Atomically exchange a pair of 32-bit values. */
gceSTATUS
gckOS_AtomicExchange(
IN gckOS Os,
IN OUT gctUINT32_PTR Target,
IN gctUINT32 NewValue,
OUT gctUINT32_PTR OldValue
);
/* Atomically exchange a pair of pointers. */
gceSTATUS
gckOS_AtomicExchangePtr(
IN gckOS Os,
IN OUT gctPOINTER * Target,
IN gctPOINTER NewValue,
OUT gctPOINTER * OldValue
);
gceSTATUS
gckOS_AtomSetMask(
IN gctPOINTER Atom,
IN gctUINT32 Mask
);
gceSTATUS
gckOS_AtomClearMask(
IN gctPOINTER Atom,
IN gctUINT32 Mask
);
gceSTATUS
gckOS_DumpCallStack(
IN gckOS Os
);
gceSTATUS
gckOS_GetProcessNameByPid(
IN gctINT Pid,
IN gctSIZE_T Length,
OUT gctUINT8_PTR String
);
/*******************************************************************************
**
** gckOS_AtomConstruct
**
** Create an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** OUTPUT:
**
** gctPOINTER * Atom
** Pointer to a variable receiving the constructed atom.
*/
gceSTATUS
gckOS_AtomConstruct(
IN gckOS Os,
OUT gctPOINTER * Atom
);
/*******************************************************************************
**
** gckOS_AtomDestroy
**
** Destroy an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gctPOINTER Atom
** Pointer to the atom to destroy.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckOS_AtomDestroy(
IN gckOS Os,
OUT gctPOINTER Atom
);
/*******************************************************************************
**
** gckOS_AtomGet
**
** Get the 32-bit value protected by an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gctPOINTER Atom
** Pointer to the atom.
**
** OUTPUT:
**
** gctINT32_PTR Value
** Pointer to a variable the receives the value of the atom.
*/
gceSTATUS
gckOS_AtomGet(
IN gckOS Os,
IN gctPOINTER Atom,
OUT gctINT32_PTR Value
);
/*******************************************************************************
**
** gckOS_AtomSet
**
** Set the 32-bit value protected by an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gctPOINTER Atom
** Pointer to the atom.
**
** gctINT32 Value
** The value of the atom.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckOS_AtomSet(
IN gckOS Os,
IN gctPOINTER Atom,
IN gctINT32 Value
);
/*******************************************************************************
**
** gckOS_AtomIncrement
**
** Atomically increment the 32-bit integer value inside an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gctPOINTER Atom
** Pointer to the atom.
**
** OUTPUT:
**
** gctINT32_PTR Value
** Pointer to a variable the receives the original value of the atom.
*/
gceSTATUS
gckOS_AtomIncrement(
IN gckOS Os,
IN gctPOINTER Atom,
OUT gctINT32_PTR Value
);
/*******************************************************************************
**
** gckOS_AtomDecrement
**
** Atomically decrement the 32-bit integer value inside an atom.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gctPOINTER Atom
** Pointer to the atom.
**
** OUTPUT:
**
** gctINT32_PTR Value
** Pointer to a variable the receives the original value of the atom.
*/
gceSTATUS
gckOS_AtomDecrement(
IN gckOS Os,
IN gctPOINTER Atom,
OUT gctINT32_PTR Value
);
/* Delay a number of microseconds. */
gceSTATUS
gckOS_Delay(
IN gckOS Os,
IN gctUINT32 Delay
);
/* Get time in milliseconds. */
gceSTATUS
gckOS_GetTicks(
OUT gctUINT32_PTR Time
);
/* Compare time value. */
gceSTATUS
gckOS_TicksAfter(
IN gctUINT32 Time1,
IN gctUINT32 Time2,
OUT gctBOOL_PTR IsAfter
);
/* Get time in microseconds. */
gceSTATUS
gckOS_GetTime(
OUT gctUINT64_PTR Time
);
/* Memory barrier. */
gceSTATUS
gckOS_MemoryBarrier(
IN gckOS Os,
IN gctPOINTER Address
);
/* Map user pointer. */
gceSTATUS
gckOS_MapUserPointer(
IN gckOS Os,
IN gctPOINTER Pointer,
IN gctSIZE_T Size,
OUT gctPOINTER * KernelPointer
);
/* Unmap user pointer. */
gceSTATUS
gckOS_UnmapUserPointer(
IN gckOS Os,
IN gctPOINTER Pointer,
IN gctSIZE_T Size,
IN gctPOINTER KernelPointer
);
/*******************************************************************************
**
** gckOS_QueryNeedCopy
**
** Query whether the memory can be accessed or mapped directly or it has to be
** copied.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** gctUINT32 ProcessID
** Process ID of the current process.
**
** OUTPUT:
**
** gctBOOL_PTR NeedCopy
** Pointer to a boolean receiving gcvTRUE if the memory needs a copy or
** gcvFALSE if the memory can be accessed or mapped dircetly.
*/
gceSTATUS
gckOS_QueryNeedCopy(
IN gckOS Os,
IN gctUINT32 ProcessID,
OUT gctBOOL_PTR NeedCopy
);
/*******************************************************************************
**
** gckOS_CopyFromUserData
**
** Copy data from user to kernel memory.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** gctPOINTER KernelPointer
** Pointer to kernel memory.
**
** gctPOINTER Pointer
** Pointer to user memory.
**
** gctSIZE_T Size
** Number of bytes to copy.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckOS_CopyFromUserData(
IN gckOS Os,
IN gctPOINTER KernelPointer,
IN gctPOINTER Pointer,
IN gctSIZE_T Size
);
/*******************************************************************************
**
** gckOS_CopyToUserData
**
** Copy data from kernel to user memory.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** gctPOINTER KernelPointer
** Pointer to kernel memory.
**
** gctPOINTER Pointer
** Pointer to user memory.
**
** gctSIZE_T Size
** Number of bytes to copy.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckOS_CopyToUserData(
IN gckOS Os,
IN gctPOINTER KernelPointer,
IN gctPOINTER Pointer,
IN gctSIZE_T Size
);
gceSTATUS
gckOS_SuspendInterrupt(
IN gckOS Os
);
gceSTATUS
gckOS_SuspendInterruptEx(
IN gckOS Os,
IN gceCORE Core
);
gceSTATUS
gckOS_ResumeInterrupt(
IN gckOS Os
);
gceSTATUS
gckOS_ResumeInterruptEx(
IN gckOS Os,
IN gceCORE Core
);
/* Get the base address for the physical memory. */
gceSTATUS
gckOS_GetBaseAddress(
IN gckOS Os,
OUT gctUINT32_PTR BaseAddress
);
/* Perform a memory copy. */
gceSTATUS
gckOS_MemCopy(
IN gctPOINTER Destination,
IN gctCONST_POINTER Source,
IN gctSIZE_T Bytes
);
/* Zero memory. */
gceSTATUS
gckOS_ZeroMemory(
IN gctPOINTER Memory,
IN gctSIZE_T Bytes
);
/* Device I/O control to the kernel HAL layer. */
gceSTATUS
gckOS_DeviceControl(
IN gckOS Os,
IN gctBOOL FromUser,
IN gctUINT32 IoControlCode,
IN gctPOINTER InputBuffer,
IN gctSIZE_T InputBufferSize,
OUT gctPOINTER OutputBuffer,
IN gctSIZE_T OutputBufferSize
);
/*******************************************************************************
**
** gckOS_GetProcessID
**
** Get current process ID.
**
** INPUT:
**
** Nothing.
**
** OUTPUT:
**
** gctUINT32_PTR ProcessID
** Pointer to the variable that receives the process ID.
*/
gceSTATUS
gckOS_GetProcessID(
OUT gctUINT32_PTR ProcessID
);
gceSTATUS
gckOS_GetCurrentProcessID(
OUT gctUINT32_PTR ProcessID
);
/*******************************************************************************
**
** gckOS_GetThreadID
**
** Get current thread ID.
**
** INPUT:
**
** Nothing.
**
** OUTPUT:
**
** gctUINT32_PTR ThreadID
** Pointer to the variable that receives the thread ID.
*/
gceSTATUS
gckOS_GetThreadID(
OUT gctUINT32_PTR ThreadID
);
#if gcdSECURITY
gceSTATUS
gckOS_OpenSecurityChannel(
IN gckOS Os,
IN gceCORE Core,
OUT gctUINT32 *Channel
);
gceSTATUS
gckOS_CloseSecurityChannel(
IN gctUINT32 Channel
);
gceSTATUS
gckOS_CallSecurityService(
IN gctUINT32 Channel,
IN gcsTA_INTERFACE * Interface
);
gceSTATUS
gckOS_InitSecurityChannel(
OUT gctUINT32 Channel
);
gceSTATUS
gckOS_AllocatePageArray(
IN gckOS Os,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T PageCount,
OUT gctPOINTER * PageArrayLogical,
OUT gctPHYS_ADDR * PageArrayPhysical
);
#endif
/******************************************************************************\
********************************** Signal Object *********************************
\******************************************************************************/
/* Create a signal. */
gceSTATUS
gckOS_CreateSignal(
IN gckOS Os,
IN gctBOOL ManualReset,
OUT gctSIGNAL * Signal
);
/* Destroy a signal. */
gceSTATUS
gckOS_DestroySignal(
IN gckOS Os,
IN gctSIGNAL Signal
);
/* Signal a signal. */
gceSTATUS
gckOS_Signal(
IN gckOS Os,
IN gctSIGNAL Signal,
IN gctBOOL State
);
/* Wait for a signal. */
gceSTATUS
gckOS_WaitSignal(
IN gckOS Os,
IN gctSIGNAL Signal,
IN gctUINT32 Wait
);
/* Map a user signal to the kernel space. */
gceSTATUS
gckOS_MapSignal(
IN gckOS Os,
IN gctSIGNAL Signal,
IN gctHANDLE Process,
OUT gctSIGNAL * MappedSignal
);
/* Unmap a user signal */
gceSTATUS
gckOS_UnmapSignal(
IN gckOS Os,
IN gctSIGNAL Signal
);
/* Map user memory. */
gceSTATUS
gckOS_MapUserMemory(
IN gckOS Os,
IN gceCORE Core,
IN gctPOINTER Memory,
IN gctUINT32 Physical,
IN gctSIZE_T Size,
OUT gctPOINTER * Info,
OUT gctUINT32_PTR Address
);
/* Unmap user memory. */
gceSTATUS
gckOS_UnmapUserMemory(
IN gckOS Os,
IN gceCORE Core,
IN gctPOINTER Memory,
IN gctSIZE_T Size,
IN gctPOINTER Info,
IN gctUINT32 Address
);
/******************************************************************************\
************************** Android Native Fence Sync ***************************
\******************************************************************************/
gceSTATUS
gckOS_CreateSyncTimeline(
IN gckOS Os,
OUT gctHANDLE * Timeline
);
gceSTATUS
gckOS_DestroySyncTimeline(
IN gckOS Os,
IN gctHANDLE Timeline
);
gceSTATUS
gckOS_CreateSyncPoint(
IN gckOS Os,
OUT gctSYNC_POINT * SyncPoint
);
gceSTATUS
gckOS_ReferenceSyncPoint(
IN gckOS Os,
IN gctSYNC_POINT SyncPoint
);
gceSTATUS
gckOS_DestroySyncPoint(
IN gckOS Os,
IN gctSYNC_POINT SyncPoint
);
gceSTATUS
gckOS_SignalSyncPoint(
IN gckOS Os,
IN gctSYNC_POINT SyncPoint
);
gceSTATUS
gckOS_QuerySyncPoint(
IN gckOS Os,
IN gctSYNC_POINT SyncPoint,
OUT gctBOOL_PTR State
);
gceSTATUS
gckOS_CreateNativeFence(
IN gckOS Os,
IN gctHANDLE Timeline,
IN gctSYNC_POINT SyncPoint,
OUT gctINT * FenceFD
);
#if !USE_NEW_LINUX_SIGNAL
/* Create signal to be used in the user space. */
gceSTATUS
gckOS_CreateUserSignal(
IN gckOS Os,
IN gctBOOL ManualReset,
OUT gctINT * SignalID
);
/* Destroy signal used in the user space. */
gceSTATUS
gckOS_DestroyUserSignal(
IN gckOS Os,
IN gctINT SignalID
);
/* Wait for signal used in the user space. */
gceSTATUS
gckOS_WaitUserSignal(
IN gckOS Os,
IN gctINT SignalID,
IN gctUINT32 Wait
);
/* Signal a signal used in the user space. */
gceSTATUS
gckOS_SignalUserSignal(
IN gckOS Os,
IN gctINT SignalID,
IN gctBOOL State
);
#endif /* USE_NEW_LINUX_SIGNAL */
/* Set a signal owned by a process. */
#if defined(__QNXNTO__)
gceSTATUS
gckOS_UserSignal(
IN gckOS Os,
IN gctSIGNAL Signal,
IN gctINT Recvid,
IN gctINT Coid
);
#else
gceSTATUS
gckOS_UserSignal(
IN gckOS Os,
IN gctSIGNAL Signal,
IN gctHANDLE Process
);
#endif
/******************************************************************************\
** Cache Support
*/
gceSTATUS
gckOS_CacheClean(
gckOS Os,
gctUINT32 ProcessID,
gctPHYS_ADDR Handle,
gctUINT32 Physical,
gctPOINTER Logical,
gctSIZE_T Bytes
);
gceSTATUS
gckOS_CacheFlush(
gckOS Os,
gctUINT32 ProcessID,
gctPHYS_ADDR Handle,
gctUINT32 Physical,
gctPOINTER Logical,
gctSIZE_T Bytes
);
gceSTATUS
gckOS_CacheInvalidate(
gckOS Os,
gctUINT32 ProcessID,
gctPHYS_ADDR Handle,
gctUINT32 Physical,
gctPOINTER Logical,
gctSIZE_T Bytes
);
gceSTATUS
gckOS_CPUPhysicalToGPUPhysical(
IN gckOS Os,
IN gctUINT32 CPUPhysical,
IN gctUINT32_PTR GPUPhysical
);
gceSTATUS
gckOS_GPUPhysicalToCPUPhysical(
IN gckOS Os,
IN gctUINT32 GPUPhysical,
IN gctUINT32_PTR CPUPhysical
);
gceSTATUS
gckOS_QueryOption(
IN gckOS Os,
IN gctCONST_STRING Option,
OUT gctUINT32 * Value
);
/******************************************************************************\
** Debug Support
*/
void
gckOS_SetDebugLevel(
IN gctUINT32 Level
);
void
gckOS_SetDebugZone(
IN gctUINT32 Zone
);
void
gckOS_SetDebugLevelZone(
IN gctUINT32 Level,
IN gctUINT32 Zone
);
void
gckOS_SetDebugZones(
IN gctUINT32 Zones,
IN gctBOOL Enable
);
void
gckOS_SetDebugFile(
IN gctCONST_STRING FileName
);
/*******************************************************************************
** Broadcast interface.
*/
typedef enum _gceBROADCAST
{
/* GPU might be idle. */
gcvBROADCAST_GPU_IDLE,
/* A commit is going to happen. */
gcvBROADCAST_GPU_COMMIT,
/* GPU seems to be stuck. */
gcvBROADCAST_GPU_STUCK,
/* First process gets attached. */
gcvBROADCAST_FIRST_PROCESS,
/* Last process gets detached. */
gcvBROADCAST_LAST_PROCESS,
/* AXI bus error. */
gcvBROADCAST_AXI_BUS_ERROR,
/* Out of memory. */
gcvBROADCAST_OUT_OF_MEMORY,
}
gceBROADCAST;
gceSTATUS
gckOS_Broadcast(
IN gckOS Os,
IN gckHARDWARE Hardware,
IN gceBROADCAST Reason
);
gceSTATUS
gckOS_BroadcastHurry(
IN gckOS Os,
IN gckHARDWARE Hardware,
IN gctUINT Urgency
);
gceSTATUS
gckOS_BroadcastCalibrateSpeed(
IN gckOS Os,
IN gckHARDWARE Hardware,
IN gctUINT Idle,
IN gctUINT Time
);
/*******************************************************************************
**
** gckOS_SetGPUPower
**
** Set the power of the GPU on or off.
**
** INPUT:
**
** gckOS Os
** Pointer to a gckOS object.
**
** gceCORE Core
** GPU whose power is set.
**
** gctBOOL Clock
** gcvTRUE to turn on the clock, or gcvFALSE to turn off the clock.
**
** gctBOOL Power
** gcvTRUE to turn on the power, or gcvFALSE to turn off the power.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckOS_SetGPUPower(
IN gckOS Os,
IN gceCORE Core,
IN gctBOOL Clock,
IN gctBOOL Power
);
gceSTATUS
gckOS_ResetGPU(
IN gckOS Os,
IN gceCORE Core
);
gceSTATUS
gckOS_PrepareGPUFrequency(
IN gckOS Os,
IN gceCORE Core
);
gceSTATUS
gckOS_FinishGPUFrequency(
IN gckOS Os,
IN gceCORE Core
);
gceSTATUS
gckOS_QueryGPUFrequency(
IN gckOS Os,
IN gceCORE Core,
OUT gctUINT32 * Frequency,
OUT gctUINT8 * Scale
);
gceSTATUS
gckOS_SetGPUFrequency(
IN gckOS Os,
IN gceCORE Core,
IN gctUINT8 Scale
);
/*******************************************************************************
** Semaphores.
*/
/* Create a new semaphore. */
gceSTATUS
gckOS_CreateSemaphore(
IN gckOS Os,
OUT gctPOINTER * Semaphore
);
#if gcdENABLE_VG
gceSTATUS
gckOS_CreateSemaphoreVG(
IN gckOS Os,
OUT gctPOINTER * Semaphore
);
#endif
/* Delete a semahore. */
gceSTATUS
gckOS_DestroySemaphore(
IN gckOS Os,
IN gctPOINTER Semaphore
);
/* Acquire a semahore. */
gceSTATUS
gckOS_AcquireSemaphore(
IN gckOS Os,
IN gctPOINTER Semaphore
);
/* Try to acquire a semahore. */
gceSTATUS
gckOS_TryAcquireSemaphore(
IN gckOS Os,
IN gctPOINTER Semaphore
);
/* Release a semahore. */
gceSTATUS
gckOS_ReleaseSemaphore(
IN gckOS Os,
IN gctPOINTER Semaphore
);
/*******************************************************************************
** Timer API.
*/
typedef void (*gctTIMERFUNCTION)(gctPOINTER);
/* Create a timer. */
gceSTATUS
gckOS_CreateTimer(
IN gckOS Os,
IN gctTIMERFUNCTION Function,
IN gctPOINTER Data,
OUT gctPOINTER * Timer
);
/* Destory a timer. */
gceSTATUS
gckOS_DestroyTimer(
IN gckOS Os,
IN gctPOINTER Timer
);
/* Start a timer. */
gceSTATUS
gckOS_StartTimer(
IN gckOS Os,
IN gctPOINTER Timer,
IN gctUINT32 Delay
);
/* Stop a timer. */
gceSTATUS
gckOS_StopTimer(
IN gckOS Os,
IN gctPOINTER Timer
);
/******************************************************************************\
********************************* gckHEAP Object ********************************
\******************************************************************************/
typedef struct _gckHEAP * gckHEAP;
/* Construct a new gckHEAP object. */
gceSTATUS
gckHEAP_Construct(
IN gckOS Os,
IN gctSIZE_T AllocationSize,
OUT gckHEAP * Heap
);
/* Destroy an gckHEAP object. */
gceSTATUS
gckHEAP_Destroy(
IN gckHEAP Heap
);
/* Allocate memory. */
gceSTATUS
gckHEAP_Allocate(
IN gckHEAP Heap,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Node
);
/* Free memory. */
gceSTATUS
gckHEAP_Free(
IN gckHEAP Heap,
IN gctPOINTER Node
);
/* Profile the heap. */
gceSTATUS
gckHEAP_ProfileStart(
IN gckHEAP Heap
);
gceSTATUS
gckHEAP_ProfileEnd(
IN gckHEAP Heap,
IN gctCONST_STRING Title
);
/******************************************************************************\
******************************** gckVIDMEM Object ******************************
\******************************************************************************/
typedef struct _gckVIDMEM * gckVIDMEM;
typedef struct _gckKERNEL * gckKERNEL;
typedef struct _gckDB * gckDB;
typedef struct _gckDVFS * gckDVFS;
/* Construct a new gckVIDMEM object. */
gceSTATUS
gckVIDMEM_Construct(
IN gckOS Os,
IN gctUINT32 BaseAddress,
IN gctSIZE_T Bytes,
IN gctSIZE_T Threshold,
IN gctSIZE_T Banking,
OUT gckVIDMEM * Memory
);
/* Destroy an gckVDIMEM object. */
gceSTATUS
gckVIDMEM_Destroy(
IN gckVIDMEM Memory
);
/* Allocate linear memory. */
gceSTATUS
gckVIDMEM_AllocateLinear(
IN gckKERNEL Kernel,
IN gckVIDMEM Memory,
IN gctSIZE_T Bytes,
IN gctUINT32 Alignment,
IN gceSURF_TYPE Type,
IN gctBOOL Specified,
OUT gcuVIDMEM_NODE_PTR * Node
);
/* Free memory. */
gceSTATUS
gckVIDMEM_Free(
IN gckKERNEL Kernel,
IN gcuVIDMEM_NODE_PTR Node
);
/* Lock memory. */
gceSTATUS
gckVIDMEM_Lock(
IN gckKERNEL Kernel,
IN gckVIDMEM_NODE Node,
IN gctBOOL Cacheable,
OUT gctUINT32 * Address,
OUT gctUINT32 * Gid,
OUT gctUINT64 * PhysicalAddress
);
/* Unlock memory. */
gceSTATUS
gckVIDMEM_Unlock(
IN gckKERNEL Kernel,
IN gckVIDMEM_NODE Node,
IN gceSURF_TYPE Type,
IN OUT gctBOOL * Asynchroneous
);
/* Construct a gcuVIDMEM_NODE union for virtual memory. */
gceSTATUS
gckVIDMEM_ConstructVirtual(
IN gckKERNEL Kernel,
IN gctUINT32 Flag,
IN gctSIZE_T Bytes,
OUT gcuVIDMEM_NODE_PTR * Node
);
/* Destroy a gcuVIDMEM_NODE union for virtual memory. */
gceSTATUS
gckVIDMEM_DestroyVirtual(
IN gcuVIDMEM_NODE_PTR Node
);
/******************************************************************************\
******************************** gckKERNEL Object ******************************
\******************************************************************************/
struct _gcsHAL_INTERFACE;
/* Notifications. */
typedef enum _gceNOTIFY
{
gcvNOTIFY_INTERRUPT,
gcvNOTIFY_COMMAND_QUEUE,
}
gceNOTIFY;
/* Flush flags. */
typedef enum _gceKERNEL_FLUSH
{
gcvFLUSH_COLOR = 0x01,
gcvFLUSH_DEPTH = 0x02,
gcvFLUSH_TEXTURE = 0x04,
gcvFLUSH_2D = 0x08,
#if gcdMULTI_GPU
gcvFLUSH_L2 = 0x10,
#endif
gcvFLUSH_TILE_STATUS = 0x20,
gcvFLUSH_ALL = gcvFLUSH_COLOR
| gcvFLUSH_DEPTH
| gcvFLUSH_TEXTURE
| gcvFLUSH_2D
#if gcdMULTI_GPU
| gcvFLUSH_L2
#endif
| gcvFLUSH_TILE_STATUS
}
gceKERNEL_FLUSH;
/* Construct a new gckKERNEL object. */
gceSTATUS
gckKERNEL_Construct(
IN gckOS Os,
IN gceCORE Core,
IN gctPOINTER Context,
IN gckDB SharedDB,
OUT gckKERNEL * Kernel
);
/* Destroy an gckKERNEL object. */
gceSTATUS
gckKERNEL_Destroy(
IN gckKERNEL Kernel
);
/* Dispatch a user-level command. */
gceSTATUS
gckKERNEL_Dispatch(
IN gckKERNEL Kernel,
IN gctBOOL FromUser,
IN OUT struct _gcsHAL_INTERFACE * Interface
);
/* Query Database requirements. */
gceSTATUS
gckKERNEL_QueryDatabase(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
IN OUT gcsHAL_INTERFACE * Interface
);
/* Query the video memory. */
gceSTATUS
gckKERNEL_QueryVideoMemory(
IN gckKERNEL Kernel,
OUT struct _gcsHAL_INTERFACE * Interface
);
/* Lookup the gckVIDMEM object for a pool. */
gceSTATUS
gckKERNEL_GetVideoMemoryPool(
IN gckKERNEL Kernel,
IN gcePOOL Pool,
OUT gckVIDMEM * VideoMemory
);
gceSTATUS
gckKERNEL_AllocateLinearMemory(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
IN OUT gcePOOL * Pool,
IN gctSIZE_T Bytes,
IN gctUINT32 Alignment,
IN gceSURF_TYPE Type,
IN gctUINT32 Flag,
OUT gctUINT32 * Node
);
gceSTATUS
gckKERNEL_ReleaseVideoMemory(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
IN gctUINT32 Handle
);
gceSTATUS
gckKERNEL_LockVideoMemory(
IN gckKERNEL Kernel,
IN gceCORE Core,
IN gctUINT32 ProcessID,
IN gctBOOL FromUser,
IN OUT gcsHAL_INTERFACE * Interface
);
gceSTATUS
gckKERNEL_UnlockVideoMemory(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
IN OUT gcsHAL_INTERFACE * Interface
);
/* Map video memory. */
gceSTATUS
gckKERNEL_MapVideoMemory(
IN gckKERNEL Kernel,
IN gctBOOL InUserSpace,
IN gctUINT32 Address,
#ifdef __QNXNTO__
IN gctUINT32 Pid,
IN gctUINT32 Bytes,
#endif
OUT gctPOINTER * Logical
);
/* Map video memory. */
gceSTATUS
gckKERNEL_MapVideoMemoryEx(
IN gckKERNEL Kernel,
IN gceCORE Core,
IN gctBOOL InUserSpace,
IN gctUINT32 Address,
#ifdef __QNXNTO__
IN gctUINT32 Pid,
IN gctUINT32 Bytes,
#endif
OUT gctPOINTER * Logical
);
#ifdef __QNXNTO__
/* Unmap video memory. */
gceSTATUS
gckKERNEL_UnmapVideoMemory(
IN gckKERNEL Kernel,
IN gctPOINTER Logical,
IN gctUINT32 Pid,
IN gctUINT32 Bytes
);
#endif
/* Map memory. */
gceSTATUS
gckKERNEL_MapMemory(
IN gckKERNEL Kernel,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Logical
);
/* Unmap memory. */
gceSTATUS
gckKERNEL_UnmapMemory(
IN gckKERNEL Kernel,
IN gctPHYS_ADDR Physical,
IN gctSIZE_T Bytes,
IN gctPOINTER Logical
);
/* Notification of events. */
gceSTATUS
gckKERNEL_Notify(
IN gckKERNEL Kernel,
#if gcdMULTI_GPU
IN gctUINT CoreId,
#endif
IN gceNOTIFY Notifcation,
IN gctBOOL Data
);
gceSTATUS
gckKERNEL_QuerySettings(
IN gckKERNEL Kernel,
OUT gcsKERNEL_SETTINGS * Settings
);
/*******************************************************************************
**
** gckKERNEL_Recovery
**
** Try to recover the GPU from a fatal error.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to an gckKERNEL object.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckKERNEL_Recovery(
IN gckKERNEL Kernel
);
/* Set the value of timeout on HW operation. */
void
gckKERNEL_SetTimeOut(
IN gckKERNEL Kernel,
IN gctUINT32 timeOut
);
/* Get access to the user data. */
gceSTATUS
gckKERNEL_OpenUserData(
IN gckKERNEL Kernel,
IN gctBOOL NeedCopy,
IN gctPOINTER StaticStorage,
IN gctPOINTER UserPointer,
IN gctSIZE_T Size,
OUT gctPOINTER * KernelPointer
);
/* Release resources associated with the user data connection. */
gceSTATUS
gckKERNEL_CloseUserData(
IN gckKERNEL Kernel,
IN gctBOOL NeedCopy,
IN gctBOOL FlushData,
IN gctPOINTER UserPointer,
IN gctSIZE_T Size,
OUT gctPOINTER * KernelPointer
);
gceSTATUS
gckDVFS_Construct(
IN gckHARDWARE Hardware,
OUT gckDVFS * Frequency
);
gceSTATUS
gckDVFS_Destroy(
IN gckDVFS Dvfs
);
gceSTATUS
gckDVFS_Start(
IN gckDVFS Dvfs
);
gceSTATUS
gckDVFS_Stop(
IN gckDVFS Dvfs
);
/******************************************************************************\
******************************* gckHARDWARE Object *****************************
\******************************************************************************/
/* Construct a new gckHARDWARE object. */
gceSTATUS
gckHARDWARE_Construct(
IN gckOS Os,
IN gceCORE Core,
OUT gckHARDWARE * Hardware
);
/* Destroy an gckHARDWARE object. */
gceSTATUS
gckHARDWARE_Destroy(
IN gckHARDWARE Hardware
);
/* Get hardware type. */
gceSTATUS
gckHARDWARE_GetType(
IN gckHARDWARE Hardware,
OUT gceHARDWARE_TYPE * Type
);
/* Query system memory requirements. */
gceSTATUS
gckHARDWARE_QuerySystemMemory(
IN gckHARDWARE Hardware,
OUT gctSIZE_T * SystemSize,
OUT gctUINT32 * SystemBaseAddress
);
/* Build virtual address. */
gceSTATUS
gckHARDWARE_BuildVirtualAddress(
IN gckHARDWARE Hardware,
IN gctUINT32 Index,
IN gctUINT32 Offset,
OUT gctUINT32 * Address
);
/* Query command buffer requirements. */
gceSTATUS
gckHARDWARE_QueryCommandBuffer(
IN gckHARDWARE Hardware,
OUT gctUINT32 * Alignment,
OUT gctUINT32 * ReservedHead,
OUT gctUINT32 * ReservedTail
);
/* Add a WAIT/LINK pair in the command queue. */
gceSTATUS
gckHARDWARE_WaitLink(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctUINT32 Offset,
IN OUT gctUINT32 * Bytes,
OUT gctUINT32 * WaitOffset,
OUT gctUINT32 * WaitBytes
);
/* Kickstart the command processor. */
gceSTATUS
gckHARDWARE_Execute(
IN gckHARDWARE Hardware,
IN gctUINT32 Address,
IN gctSIZE_T Bytes
);
/* Add an END command in the command queue. */
gceSTATUS
gckHARDWARE_End(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN OUT gctUINT32 * Bytes
);
#if gcdMULTI_GPU
gceSTATUS
gckHARDWARE_ChipEnable(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gceCORE_3D_MASK ChipEnable,
IN OUT gctSIZE_T * Bytes
);
#endif
/* Add a NOP command in the command queue. */
gceSTATUS
gckHARDWARE_Nop(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN OUT gctSIZE_T * Bytes
);
/* Add a PIPESELECT command in the command queue. */
gceSTATUS
gckHARDWARE_PipeSelect(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gcePIPE_SELECT Pipe,
IN OUT gctUINT32 * Bytes
);
/* Add a LINK command in the command queue. */
gceSTATUS
gckHARDWARE_Link(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctUINT32 FetchAddress,
IN gctUINT32 FetchSize,
IN OUT gctUINT32 * Bytes
);
/* Add an EVENT command in the command queue. */
gceSTATUS
gckHARDWARE_Event(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctUINT8 Event,
IN gceKERNEL_WHERE FromWhere,
IN OUT gctUINT32 * Bytes
);
/* Query the available memory. */
gceSTATUS
gckHARDWARE_QueryMemory(
IN gckHARDWARE Hardware,
OUT gctSIZE_T * InternalSize,
OUT gctUINT32 * InternalBaseAddress,
OUT gctUINT32 * InternalAlignment,
OUT gctSIZE_T * ExternalSize,
OUT gctUINT32 * ExternalBaseAddress,
OUT gctUINT32 * ExternalAlignment,
OUT gctUINT32 * HorizontalTileSize,
OUT gctUINT32 * VerticalTileSize
);
/* Query the identity of the hardware. */
gceSTATUS
gckHARDWARE_QueryChipIdentity(
IN gckHARDWARE Hardware,
OUT gcsHAL_QUERY_CHIP_IDENTITY_PTR Identity
);
/* Query the shader uniforms support. */
gceSTATUS
gckHARDWARE_QueryShaderCaps(
IN gckHARDWARE Hardware,
OUT gctUINT * VertexUniforms,
OUT gctUINT * FragmentUniforms,
OUT gctBOOL * UnifiedUnforms
);
/* Split a harwdare specific address into API stuff. */
gceSTATUS
gckHARDWARE_SplitMemory(
IN gckHARDWARE Hardware,
IN gctUINT32 Address,
OUT gcePOOL * Pool,
OUT gctUINT32 * Offset
);
/* Update command queue tail pointer. */
gceSTATUS
gckHARDWARE_UpdateQueueTail(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctUINT32 Offset
);
/* Convert logical address to hardware specific address. */
gceSTATUS
gckHARDWARE_ConvertLogical(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctBOOL InUserSpace,
OUT gctUINT32 * Address
);
/* Interrupt manager. */
gceSTATUS
gckHARDWARE_Interrupt(
IN gckHARDWARE Hardware,
#if gcdMULTI_GPU
IN gctUINT CoreId,
#endif
IN gctBOOL InterruptValid
);
/* Program MMU. */
gceSTATUS
gckHARDWARE_SetMMU(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical
);
/* Flush the MMU. */
gceSTATUS
gckHARDWARE_FlushMMU(
IN gckHARDWARE Hardware
);
/* Set the page table base address. */
gceSTATUS
gckHARDWARE_SetMMUv2(
IN gckHARDWARE Hardware,
IN gctBOOL Enable,
IN gctPOINTER MtlbAddress,
IN gceMMU_MODE Mode,
IN gctPOINTER SafeAddress,
IN gctBOOL FromPower
);
#if gcdPROCESS_ADDRESS_SPACE
/* Configure mmu configuration. */
gceSTATUS
gckHARDWARE_ConfigMMU(
IN gckHARDWARE Hardware,
IN gctPOINTER Logical,
IN gctPOINTER MtlbLogical,
IN gctUINT32 Offset,
IN OUT gctSIZE_T * Bytes,
OUT gctSIZE_T * WaitLinkOffset,
OUT gctSIZE_T * WaitLinkBytes
);
#endif
/* Get idle register. */
gceSTATUS
gckHARDWARE_GetIdle(
IN gckHARDWARE Hardware,
IN gctBOOL Wait,
OUT gctUINT32 * Data
);
/* Flush the caches. */
gceSTATUS
gckHARDWARE_Flush(
IN gckHARDWARE Hardware,
IN gceKERNEL_FLUSH Flush,
IN gctPOINTER Logical,
IN OUT gctUINT32 * Bytes
);
/* Enable/disable fast clear. */
gceSTATUS
gckHARDWARE_SetFastClear(
IN gckHARDWARE Hardware,
IN gctINT Enable,
IN gctINT Compression
);
gceSTATUS
gckHARDWARE_ReadInterrupt(
IN gckHARDWARE Hardware,
OUT gctUINT32_PTR IDs
);
/* Power management. */
gceSTATUS
gckHARDWARE_SetPowerManagementState(
IN gckHARDWARE Hardware,
IN gceCHIPPOWERSTATE State
);
gceSTATUS
gckHARDWARE_QueryPowerManagementState(
IN gckHARDWARE Hardware,
OUT gceCHIPPOWERSTATE* State
);
gceSTATUS
gckHARDWARE_SetPowerManagement(
IN gckHARDWARE Hardware,
IN gctBOOL PowerManagement
);
gceSTATUS
gckHARDWARE_SetPowerManagementLock(
IN gckHARDWARE Hardware,
IN gctBOOL Lock
);
gceSTATUS
gckHARDWARE_SetGpuProfiler(
IN gckHARDWARE Hardware,
IN gctBOOL GpuProfiler
);
#if gcdENABLE_FSCALE_VAL_ADJUST
gceSTATUS
gckHARDWARE_SetFscaleValue(
IN gckHARDWARE Hardware,
IN gctUINT32 FscaleValue
);
gceSTATUS
gckHARDWARE_GetFscaleValue(
IN gckHARDWARE Hardware,
IN gctUINT * FscaleValue,
IN gctUINT * MinFscaleValue,
IN gctUINT * MaxFscaleValue
);
gceSTATUS
gckHARDWARE_SetMinFscaleValue(
IN gckHARDWARE Hardware,
IN gctUINT MinFscaleValue
);
#endif
#if gcdPOWEROFF_TIMEOUT
gceSTATUS
gckHARDWARE_SetPowerOffTimeout(
IN gckHARDWARE Hardware,
IN gctUINT32 Timeout
);
gceSTATUS
gckHARDWARE_QueryPowerOffTimeout(
IN gckHARDWARE Hardware,
OUT gctUINT32* Timeout
);
#endif
/* Profile 2D Engine. */
gceSTATUS
gckHARDWARE_ProfileEngine2D(
IN gckHARDWARE Hardware,
OUT gcs2D_PROFILE_PTR Profile
);
gceSTATUS
gckHARDWARE_InitializeHardware(
IN gckHARDWARE Hardware
);
gceSTATUS
gckHARDWARE_Reset(
IN gckHARDWARE Hardware
);
typedef gceSTATUS (*gctISRMANAGERFUNC)(gctPOINTER Context);
gceSTATUS
gckHARDWARE_SetIsrManager(
IN gckHARDWARE Hardware,
IN gctISRMANAGERFUNC StartIsr,
IN gctISRMANAGERFUNC StopIsr,
IN gctPOINTER Context
);
/* Start a composition. */
gceSTATUS
gckHARDWARE_Compose(
IN gckHARDWARE Hardware,
IN gctUINT32 ProcessID,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical,
IN gctSIZE_T Offset,
IN gctSIZE_T Size,
IN gctUINT8 EventID
);
/* Check for Hardware features. */
gceSTATUS
gckHARDWARE_IsFeatureAvailable(
IN gckHARDWARE Hardware,
IN gceFEATURE Feature
);
gceSTATUS
gckHARDWARE_DumpMMUException(
IN gckHARDWARE Hardware
);
gceSTATUS
gckHARDWARE_DumpGPUState(
IN gckHARDWARE Hardware
);
gceSTATUS
gckHARDWARE_InitDVFS(
IN gckHARDWARE Hardware
);
gceSTATUS
gckHARDWARE_QueryLoad(
IN gckHARDWARE Hardware,
OUT gctUINT32 * Load
);
gceSTATUS
gckHARDWARE_SetDVFSPeroid(
IN gckHARDWARE Hardware,
IN gctUINT32 Frequency
);
gceSTATUS
gckHARDWARE_PrepareFunctions(
gckHARDWARE Hardware
);
gceSTATUS
gckHARDWARE_SetMMUStates(
IN gckHARDWARE Hardware,
IN gctPOINTER MtlbAddress,
IN gceMMU_MODE Mode,
IN gctPOINTER SafeAddress,
IN gctPOINTER Logical,
IN OUT gctUINT32 * Bytes
);
#if !gcdENABLE_VG
/******************************************************************************\
***************************** gckINTERRUPT Object ******************************
\******************************************************************************/
typedef struct _gckINTERRUPT * gckINTERRUPT;
typedef gceSTATUS (* gctINTERRUPT_HANDLER)(
IN gckKERNEL Kernel
);
gceSTATUS
gckINTERRUPT_Construct(
IN gckKERNEL Kernel,
OUT gckINTERRUPT * Interrupt
);
gceSTATUS
gckINTERRUPT_Destroy(
IN gckINTERRUPT Interrupt
);
gceSTATUS
gckINTERRUPT_SetHandler(
IN gckINTERRUPT Interrupt,
IN OUT gctINT32_PTR Id,
IN gctINTERRUPT_HANDLER Handler
);
gceSTATUS
gckINTERRUPT_Notify(
IN gckINTERRUPT Interrupt,
IN gctBOOL Valid
);
#endif
/******************************************************************************\
******************************** gckEVENT Object *******************************
\******************************************************************************/
typedef struct _gckEVENT * gckEVENT;
/* Construct a new gckEVENT object. */
gceSTATUS
gckEVENT_Construct(
IN gckKERNEL Kernel,
OUT gckEVENT * Event
);
/* Destroy an gckEVENT object. */
gceSTATUS
gckEVENT_Destroy(
IN gckEVENT Event
);
/* Reserve the next available hardware event. */
#if gcdMULTI_GPU
gceSTATUS
gckEVENT_GetEvent(
IN gckEVENT Event,
IN gctBOOL Wait,
OUT gctUINT8 * EventID,
IN gceKERNEL_WHERE Source,
IN gceCORE_3D_MASK ChipEnable
);
#else
gceSTATUS
gckEVENT_GetEvent(
IN gckEVENT Event,
IN gctBOOL Wait,
OUT gctUINT8 * EventID,
IN gceKERNEL_WHERE Source
);
#endif
/* Add a new event to the list of events. */
gceSTATUS
gckEVENT_AddList(
IN gckEVENT Event,
IN gcsHAL_INTERFACE_PTR Interface,
IN gceKERNEL_WHERE FromWhere,
IN gctBOOL AllocateAllowed,
IN gctBOOL FromKernel
);
/* Schedule a FreeNonPagedMemory event. */
gceSTATUS
gckEVENT_FreeNonPagedMemory(
IN gckEVENT Event,
IN gctSIZE_T Bytes,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical,
IN gceKERNEL_WHERE FromWhere
);
/* Schedule a FreeContiguousMemory event. */
gceSTATUS
gckEVENT_FreeContiguousMemory(
IN gckEVENT Event,
IN gctSIZE_T Bytes,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical,
IN gceKERNEL_WHERE FromWhere
);
/* Schedule a FreeVideoMemory event. */
gceSTATUS
gckEVENT_FreeVideoMemory(
IN gckEVENT Event,
IN gcuVIDMEM_NODE_PTR VideoMemory,
IN gceKERNEL_WHERE FromWhere
);
/* Schedule a signal event. */
gceSTATUS
gckEVENT_Signal(
IN gckEVENT Event,
IN gctSIGNAL Signal,
IN gceKERNEL_WHERE FromWhere
);
/* Schedule an Unlock event. */
gceSTATUS
gckEVENT_Unlock(
IN gckEVENT Event,
IN gceKERNEL_WHERE FromWhere,
IN gctPOINTER Node,
IN gceSURF_TYPE Type
);
gceSTATUS
gckEVENT_CommitDone(
IN gckEVENT Event,
IN gceKERNEL_WHERE FromWhere
);
/* Schedule a FreeVirtualCommandBuffer event. */
gceSTATUS
gckEVENT_DestroyVirtualCommandBuffer(
IN gckEVENT Event,
IN gctSIZE_T Bytes,
IN gctPHYS_ADDR Physical,
IN gctPOINTER Logical,
IN gceKERNEL_WHERE FromWhere
);
#if gcdMULTI_GPU
gceSTATUS
gckEVENT_Submit(
IN gckEVENT Event,
IN gctBOOL Wait,
IN gctBOOL FromPower,
IN gceCORE_3D_MASK ChipEnable
);
#else
gceSTATUS
gckEVENT_Submit(
IN gckEVENT Event,
IN gctBOOL Wait,
IN gctBOOL FromPower
);
#endif
#if gcdMULTI_GPU
gceSTATUS
gckEVENT_Commit(
IN gckEVENT Event,
IN gcsQUEUE_PTR Queue,
IN gceCORE_3D_MASK ChipEnable
);
#else
gceSTATUS
gckEVENT_Commit(
IN gckEVENT Event,
IN gcsQUEUE_PTR Queue
);
#endif
/* Schedule a composition event. */
gceSTATUS
gckEVENT_Compose(
IN gckEVENT Event,
IN gcsHAL_COMPOSE_PTR Info
);
/* Event callback routine. */
gceSTATUS
gckEVENT_Notify(
IN gckEVENT Event,
IN gctUINT32 IDs
);
/* Event callback routine. */
gceSTATUS
gckEVENT_Interrupt(
IN gckEVENT Event,
#if gcdMULTI_GPU
IN gctUINT CoreId,
#endif
IN gctUINT32 IDs
);
gceSTATUS
gckEVENT_Dump(
IN gckEVENT Event
);
/******************************************************************************\
******************************* gckCOMMAND Object ******************************
\******************************************************************************/
typedef struct _gckCOMMAND * gckCOMMAND;
/* Construct a new gckCOMMAND object. */
gceSTATUS
gckCOMMAND_Construct(
IN gckKERNEL Kernel,
OUT gckCOMMAND * Command
);
/* Destroy an gckCOMMAND object. */
gceSTATUS
gckCOMMAND_Destroy(
IN gckCOMMAND Command
);
/* Acquire command queue synchronization objects. */
gceSTATUS
gckCOMMAND_EnterCommit(
IN gckCOMMAND Command,
IN gctBOOL FromPower
);
/* Release command queue synchronization objects. */
gceSTATUS
gckCOMMAND_ExitCommit(
IN gckCOMMAND Command,
IN gctBOOL FromPower
);
/* Start the command queue. */
gceSTATUS
gckCOMMAND_Start(
IN gckCOMMAND Command
);
/* Stop the command queue. */
gceSTATUS
gckCOMMAND_Stop(
IN gckCOMMAND Command,
IN gctBOOL FromRecovery
);
#if gcdMULTI_GPU
/* Commit a buffer to the command queue. */
gceSTATUS
gckCOMMAND_Commit(
IN gckCOMMAND Command,
IN gckCONTEXT Context,
IN gcoCMDBUF CommandBuffer,
IN gcsSTATE_DELTA_PTR StateDelta,
IN gcsQUEUE_PTR EventQueue,
IN gctUINT32 ProcessID,
IN gceCORE_3D_MASK ChipEnable
);
#else
gceSTATUS
gckCOMMAND_Commit(
IN gckCOMMAND Command,
IN gckCONTEXT Context,
IN gcoCMDBUF CommandBuffer,
IN gcsSTATE_DELTA_PTR StateDelta,
IN gcsQUEUE_PTR EventQueue,
IN gctUINT32 ProcessID
);
#endif
/* Reserve space in the command buffer. */
gceSTATUS
gckCOMMAND_Reserve(
IN gckCOMMAND Command,
IN gctUINT32 RequestedBytes,
OUT gctPOINTER * Buffer,
OUT gctUINT32 * BufferSize
);
/* Execute reserved space in the command buffer. */
gceSTATUS
gckCOMMAND_Execute(
IN gckCOMMAND Command,
IN gctUINT32 RequstedBytes
);
/* Stall the command queue. */
#if gcdMULTI_GPU
gceSTATUS
gckCOMMAND_Stall(
IN gckCOMMAND Command,
IN gctBOOL FromPower,
IN gceCORE_3D_MASK ChipEnable
);
#else
gceSTATUS
gckCOMMAND_Stall(
IN gckCOMMAND Command,
IN gctBOOL FromPower
);
#endif
/* Attach user process. */
gceSTATUS
gckCOMMAND_Attach(
IN gckCOMMAND Command,
OUT gckCONTEXT * Context,
OUT gctSIZE_T * StateCount,
IN gctUINT32 ProcessID
);
/* Detach user process. */
gceSTATUS
gckCOMMAND_Detach(
IN gckCOMMAND Command,
IN gckCONTEXT Context
);
/* Dump command buffer being executed by GPU. */
gceSTATUS
gckCOMMAND_DumpExecutingBuffer(
IN gckCOMMAND Command
);
/* Whether a kernel command buffer address. */
gceSTATUS
gckCOMMAND_AddressInKernelCommandBuffer(
IN gckCOMMAND Command,
IN gctUINT32 Address,
OUT gctBOOL *In
);
/******************************************************************************\
********************************* gckMMU Object ********************************
\******************************************************************************/
typedef struct _gckMMU * gckMMU;
/* Construct a new gckMMU object. */
gceSTATUS
gckMMU_Construct(
IN gckKERNEL Kernel,
IN gctSIZE_T MmuSize,
OUT gckMMU * Mmu
);
/* Destroy an gckMMU object. */
gceSTATUS
gckMMU_Destroy(
IN gckMMU Mmu
);
/* Allocate pages inside the MMU. */
gceSTATUS
gckMMU_AllocatePages(
IN gckMMU Mmu,
IN gctSIZE_T PageCount,
OUT gctPOINTER * PageTable,
OUT gctUINT32 * Address
);
gceSTATUS
gckMMU_AllocatePagesEx(
IN gckMMU Mmu,
IN gctSIZE_T PageCount,
IN gceSURF_TYPE Type,
OUT gctPOINTER * PageTable,
OUT gctUINT32 * Address
);
/* Remove a page table from the MMU. */
gceSTATUS
gckMMU_FreePages(
IN gckMMU Mmu,
IN gctPOINTER PageTable,
IN gctSIZE_T PageCount
);
/* Set the MMU page with info. */
gceSTATUS
gckMMU_SetPage(
IN gckMMU Mmu,
IN gctUINT32 PageAddress,
IN gctUINT32 *PageEntry
);
gceSTATUS
gckMMU_Flush(
IN gckMMU Mmu,
IN gceSURF_TYPE Type
);
gceSTATUS
gckMMU_DumpPageTableEntry(
IN gckMMU Mmu,
IN gctUINT32 Address
);
#if VIVANTE_PROFILER
gceSTATUS
gckHARDWARE_QueryProfileRegisters(
IN gckHARDWARE Hardware,
IN gctBOOL Reset,
OUT gcsPROFILER_COUNTERS * Counters
);
#endif
#if VIVANTE_PROFILER_CONTEXT
gceSTATUS
gckHARDWARE_QueryContextProfile(
IN gckHARDWARE Hardware,
IN gctBOOL Reset,
IN gckCONTEXT Context,
OUT gcsPROFILER_COUNTERS * Counters
);
gceSTATUS
gckHARDWARE_UpdateContextProfile(
IN gckHARDWARE Hardware,
IN gckCONTEXT Context
);
#endif
#if VIVANTE_PROFILER_NEW
gceSTATUS
gckHARDWARE_InitProfiler(
IN gckHARDWARE Hardware
);
#endif
gceSTATUS
gckOS_SignalQueryHardware(
IN gckOS Os,
IN gctSIGNAL Signal,
OUT gckHARDWARE * Hardware
);
gceSTATUS
gckOS_SignalSetHardware(
IN gckOS Os,
IN gctSIGNAL Signal,
gckHARDWARE Hardware
);
gceSTATUS
gckOS_DetectProcessByName(
IN gctCONST_POINTER Name
);
void
gckOS_DumpParam(
void
);
#ifdef __cplusplus
}
#endif
#if gcdENABLE_VG
#include "gc_hal_vg.h"
#endif
#endif /* __gc_hal_h_ */