/**************************************************************************** * * Copyright (c) 2005 - 2023 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_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 #ifdef __cplusplus extern "C" { #endif typedef struct _gckVIDMEM *gckVIDMEM; typedef struct _gckKERNEL *gckKERNEL; typedef struct _gckCOMMAND *gckCOMMAND; typedef struct _gckEVENT *gckEVENT; typedef struct _gckDB *gckDB; typedef struct _gckDVFS *gckDVFS; typedef struct _gckMMU *gckMMU; typedef struct _gcsDEVICE *gckDEVICE; /****************************************************************************** ****************************** Alignment Macros ****************************** ******************************************************************************/ /* Alignment with a non-power of two value. */ #define gcmALIGN_NP2(n, align) (((n) + (align) - 1) - (((n) + (align) - 1) % (align))) #define gcmALIGN_NP2_SAFE(n, align) \ (\ (gcmALIGN_NP2((n) & ~0ULL, (align) & ~0ULL) ^ gcmALIGN_NP2(n, align)) ? \ (n) : gcmALIGN_NP2(n, align) \ ) /* Alignment with a power of two value. */ #define gcmALIGN(n, align) (((n) + ((align) - 1)) & ~((align) - 1)) #define gcmALIGN_SAFE(n, align) \ (\ (gcmALIGN((n) & ~0ULL, (align) & ~0ULL) ^ gcmALIGN(n, align)) ? \ (n) : gcmALIGN(n, align) \ ) #define gcmALIGN_CHECK_OVERFLOW(n, align) \ (\ (gcmALIGN((n) & ~0ULL, (align) & ~0ULL) ^ gcmALIGN(n, align)) ? \ gcvSTATUS_RESLUT_OVERFLOW : gcvSTATUS_OK \ ) #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 ~0ULL #define gcvINVALID_VALUE 0xCCCCCCCC #define gcvINVALID_PHYSICAL_ADDRESS ~0ULL #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)) typedef struct _gckHARDWARE *gckHARDWARE; #define gcdMAX_GPU_COUNT gcvCORE_COUNT #define gcdMAX_SURF_LAYERS 4 #define gcdMAX_DRAW_BUFFERS 16 #define gcdMAX_3DGPU_COUNT 8 #define gcdMAX_VERTEX_STREAM_COUNT 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 gcmkVERIFY_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 gckKERNEL Kernel, IN gctUINT32 Flag, IN gceVIDMEM_TYPE Type, IN OUT 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); /* Map pages. */ gceSTATUS gckOS_MapPagesEx(IN gckOS Os, IN gckKERNEL Kernel, IN gckMMU Mmu, IN gctPHYS_ADDR Physical, IN gctSIZE_T Offset, IN gctSIZE_T PageCount, IN gctADDRESS Address, IN gctPOINTER PageTable, IN gctBOOL Writable, IN gceVIDMEM_TYPE Type); /* Map 1M pages. */ gceSTATUS gckOS_Map1MPages(IN gckOS Os, IN gckKERNEL Kernel, IN gckMMU Mmu, IN gctPHYS_ADDR Physical, IN gctSIZE_T PageCount, IN gctADDRESS Address, IN gctPOINTER PageTable, IN gctBOOL Writable, IN gceVIDMEM_TYPE Type); gceSTATUS gckOS_UnmapPages(IN gckOS Os, IN gctSIZE_T PageCount, IN gctADDRESS 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 gckKERNEL Kernel, IN gctBOOL InUserSpace, IN gctUINT32 Flag, IN OUT gctSIZE_T *Bytes, OUT gctPHYS_ADDR *Physical, OUT gctPOINTER *Logical); /* Free non-paged memory. */ gceSTATUS gckOS_FreeNonPagedMemory(IN gckOS Os, IN gctPHYS_ADDR Physical, IN gctPOINTER Logical, IN gctSIZE_T Bytes); /* Reserved memory. */ gceSTATUS gckOS_RequestReservedMemory(gckOS Os, gctPHYS_ADDR_T Start, gctSIZE_T Size, const char *Name, gctBOOL Requested, gctPOINTER *MemoryHandle); void gckOS_ReleaseReservedMemory(gckOS Os, gctPOINTER MemoryHandle); /* Reserved memory sub area */ gceSTATUS gckOS_RequestReservedMemoryArea(IN gckOS Os, IN gctPOINTER MemoryHandle, IN gctSIZE_T Offset, IN gctSIZE_T Size, OUT gctPOINTER *MemoryAreaHandle); void gckOS_ReleaseReservedMemoryArea(gctPOINTER MemoryAreaHandle); /* 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 gctPHYS_ADDR_T *Address); /* Get real physical address from handle. */ gceSTATUS gckOS_GetPhysicalFromHandle(IN gckOS Os, IN gctPHYS_ADDR Physical, IN gctSIZE_T Offset, OUT gctPHYS_ADDR_T *PhysicalAddress); /* Get the physical address of a corresponding user logical address. */ gceSTATUS gckOS_UserLogicalToPhysical(IN gckOS Os, IN gctPOINTER Logical, OUT gctPHYS_ADDR_T *Address); /* Map physical memory. */ gceSTATUS gckOS_MapPhysical(IN gckOS Os, IN gctPHYS_ADDR_T 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); /* 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 gckKERNEL Kernel, 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 gckKERNEL Kernel, IN gctUINT32 Address, IN gctUINT32 Data); /* Write data to a hardware register without dump. */ gceSTATUS gckOS_WriteRegisterEx_NoDump(IN gckOS Os, IN gckKERNEL Kernel, IN gctUINT32 Address, IN gctUINT32 Data); #ifdef __QNXNTO__ static gcmINLINE gceSTATUS gckOS_WriteMemory(IN gckOS Os, IN gctPOINTER Address, IN gctUINT32 Data) { /* Write memory. */ *(gctUINT32 *)Address = Data; return gcvSTATUS_OK; } #else /* Write data to a 32-bit memory location. */ gceSTATUS gckOS_WriteMemory(IN gckOS Os, IN gctPOINTER Address, IN gctUINT32 Data); #endif /* 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); /* 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); gceSTATUS gckOS_QueryCPUFrequency(IN gckOS Os, IN gctUINT32 CPUId, OUT gctUINT32 *Frequency); gceSTATUS gckOS_TraceGpuMemory(IN gckOS Os, IN gctINT32 ProcessID, IN gctINT64 Delta); void gckOS_NodeIdAssign(gckOS Os, gcuVIDMEM_NODE_PTR Node); #if gcdENABLE_CLEAR_FENCE gceSTATUS gckOS_ClearAllFence(gckDEVICE Device); gctUINT64 gckOS_AllocFenceRecordId(IN gckOS Os, IN gcsUSER_FENCE_INFO_PTR fence_info); gcsUSER_FENCE_INFO_PTR gckOS_ReleaseFenceRecordId(IN gckOS Os, IN gctUINT64 recordId); void gckOS_PreLoadFenceRecId(IN gckOS Os); void gckOS_PreLoadEndFenceRecId(IN gckOS Os); #endif /******************************************************************************* ** ** 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 milliseconds. */ gceSTATUS gckOS_Delay(IN gckOS Os, IN gctUINT32 Delay); /* Delay a number of milliseconds. */ gceSTATUS gckOS_Udelay(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); /******************************************************************************* ** ** 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); /****************************************************************************** ********************************* 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 gctBOOL Interruptable, IN gctUINT32 Wait); #ifdef __QNXNTO__ gceSTATUS gckOS_SignalPulse(IN gckOS Os, IN gctSIGNAL Signal); gceSTATUS gckOS_SignalPending(IN gckOS Os, IN gctSIGNAL Signal); #endif /* 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); /* Get scatter-gather table from memory. */ gceSTATUS gckOS_MemoryGetSGT(IN gckOS Os, IN gctPHYS_ADDR Physical, IN gctSIZE_T Offset, IN gctSIZE_T Bytes, OUT gctPOINTER *SGT); /* Map a page range of memory to user space. */ gceSTATUS gckOS_MemoryMmap(IN gckOS Os, IN gctPHYS_ADDR Physical, IN gctSIZE_T skipPages, IN gctSIZE_T numPages, INOUT gctPOINTER Vma); /* Wrap a user memory to gctPHYS_ADDR. */ gceSTATUS gckOS_WrapMemory(IN gckOS Os, IN gckKERNEL Kernel, IN gcsUSER_MEMORY_DESC_PTR Desc, OUT gctSIZE_T *Bytes, OUT gctPHYS_ADDR *Physical, OUT gctBOOL *Contiguous, OUT gctSIZE_T *PageCountCpu); gceSTATUS gckOS_GetPolicyID(IN gckOS Os, IN gceVIDMEM_TYPE Type, OUT gctUINT32_PTR PolicyID, OUT gctUINT32_PTR AXIConfig); #if gcdENABLE_MP_SWITCH gceSTATUS gckOS_SwitchCoreCount(IN gckOS Os, OUT gctUINT32 *Count); #endif /****************************************************************************** ************************* Android Native Fence Sync ************************** ******************************************************************************/ gceSTATUS gckOS_CreateSyncTimeline(IN gckOS Os, IN gceCORE Core, OUT gctHANDLE *Timeline); gceSTATUS gckOS_DestroySyncTimeline(IN gckOS Os, IN gctHANDLE Timeline); gceSTATUS gckOS_CreateNativeFence(IN gckOS Os, IN gctHANDLE Timeline, IN gctSIGNAL Signal, OUT gctINT *FenceFD); gceSTATUS gckOS_WaitNativeFence(IN gckOS Os, IN gctHANDLE Timeline, IN gctINT FenceFD, IN gctUINT32 Timeout); #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, OUT gceSIGNAL_STATUS *SignalStatus); /* 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 Rcvid, IN const struct sigevent *Event); #else gceSTATUS gckOS_UserSignal(IN gckOS Os, IN gctSIGNAL Signal, IN gctHANDLE Handle); #endif /******************************************************************************\ ** Cache Support */ gceSTATUS gckOS_CacheClean(gckOS Os, gctUINT32 ProcessID, gctPHYS_ADDR Handle, gctSIZE_T Offset, gctPOINTER Logical, gctSIZE_T Bytes); gceSTATUS gckOS_CacheFlush(gckOS Os, gctUINT32 ProcessID, gctPHYS_ADDR Handle, gctSIZE_T Offset, gctPOINTER Logical, gctSIZE_T Bytes); gceSTATUS gckOS_CacheInvalidate(gckOS Os, gctUINT32 ProcessID, gctPHYS_ADDR Handle, gctSIZE_T Offset, gctPOINTER Logical, gctSIZE_T Bytes); gceSTATUS gckOS_CPUPhysicalToGPUPhysical(IN gckOS Os, IN gctPHYS_ADDR_T CPUPhysical, IN gctPHYS_ADDR_T *GPUPhysical); gceSTATUS gckOS_GPUPhysicalToCPUPhysical(IN gckOS Os, IN gctPHYS_ADDR_T GPUPhysical, IN gctPHYS_ADDR_T *CPUPhysical); gceSTATUS gckOS_QueryOption(IN gckOS Os, IN gctCONST_STRING Option, OUT gctUINT64 *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); 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. ** ** gckKERNEL Kernel ** Core 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 gckKERNEL Kernel, IN gctBOOL Clock, IN gctBOOL Power); gceSTATUS gckOS_SetClockState(IN gckOS Os, IN gckKERNEL Kernel, IN gctBOOL Clock); gceSTATUS gckOS_GetClockState(IN gckOS Os, IN gckKERNEL Kernel, IN gctBOOL *Clock); gceSTATUS gckOS_ResetGPU(IN gckOS Os, IN gckKERNEL Kernel); 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); gceSTATUS gckOS_CreateSemaphoreEx(IN gckOS Os, OUT gctPOINTER *Semaphore); /* Delete a semaphore. */ gceSTATUS gckOS_DestroySemaphore(IN gckOS Os, IN gctPOINTER Semaphore); /* Acquire a semaphore. */ gceSTATUS gckOS_AcquireSemaphore(IN gckOS Os, IN gctPOINTER Semaphore); /* Try to acquire a semaphore. */ gceSTATUS gckOS_TryAcquireSemaphore(IN gckOS Os, IN gctPOINTER Semaphore); /* Release a semaphore. */ gceSTATUS gckOS_ReleaseSemaphore(IN gckOS Os, IN gctPOINTER Semaphore); /* Release a semaphore. */ gceSTATUS gckOS_ReleaseSemaphoreEx(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); /* Destroy 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); /****************************************************************************** ******************************* gckKERNEL Object ***************************** ******************************************************************************/ struct _gcsHAL_INTERFACE; /* Construct a new gckKERNEL object. */ gceSTATUS gckKERNEL_Construct(IN gckOS Os, IN gceCORE Core, IN gctUINT ChipID, IN gctPOINTER Context, IN gckDEVICE Device, 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 gckDEVICE Device, 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); /* Map dedicated video memory node. */ gceSTATUS gckKERNEL_MapVideoMemory(IN gckKERNEL Kernel, IN gctBOOL InUserSpace, IN gcePOOL Pool, IN gctPHYS_ADDR Physical, IN gctSIZE_T Offset, IN gctSIZE_T Bytes, OUT gctPOINTER *Logical); /* Unmap dedicated video memory. */ gceSTATUS gckKERNEL_UnmapVideoMemory(IN gckKERNEL Kernel, IN gcePOOL Pool, IN gctPHYS_ADDR Physical, IN gctPOINTER Logical, IN gctUINT32 Pid, IN gctSIZE_T Bytes); /* 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, IN gctUINT32 ProcessID); /* Destroy reserved mem when destroy process*/ gceSTATUS gckKERNEL_DestroyProcessReservedUserMap(IN gckKERNEL Kernel, IN gctUINT32 Pid); /* Notification of events. */ gceSTATUS gckKERNEL_Notify(IN gckKERNEL Kernel, IN gceNOTIFY Notifcation); #if gcdENABLE_VIDEO_MEMORY_MIRROR gceSTATUS gckKERNEL_SyncVideoMemoryMirror(gckKERNEL Kernel, gckVIDMEM_NODE Node, gctSIZE_T Offset, gctSIZE_T Bytes, gctUINT32 Reason); #endif /******************************************************************************* ** ** 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); /* 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); /* Query kernel by core index */ gceSTATUS gckOS_QueryKernel(IN gckKERNEL Kernel, IN gctINT index, OUT gckKERNEL *KernelOut); 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 gckKERNEL Kernel, OUT gckHARDWARE *Hardware); /* Post hardware resource allocation after gckHARDWARE object constructed. */ gceSTATUS gckHARDWARE_PostConstruct(IN gckHARDWARE Hardware); /* Pre-destroy hardwre resource before destroying an gckHARDWARE object. */ gceSTATUS gckHARDWARE_PreDestroy(IN 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, IN gceENGINE Engine, OUT gctUINT32 *Alignment, OUT gctUINT32 *ReservedHead, OUT gctUINT32 *ReservedTail); /* 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); /* Query the available memory. */ gceSTATUS gckHARDWARE_QueryMemory(IN gckHARDWARE Hardware, OUT gctSIZE_T *InternalSize, OUT gctADDRESS *InternalBaseAddress, OUT gctUINT32 *InternalAlignment, OUT gctSIZE_T *ExternalSize, OUT gctADDRESS *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); gceSTATUS gckHARDWARE_QueryChipOptions(IN gckHARDWARE Hardware, OUT gcsHAL_QUERY_CHIP_OPTIONS_PTR Options); /* 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); /* Interrupt manager. */ gceSTATUS gckHARDWARE_Interrupt(IN gckHARDWARE Hardware); gceSTATUS gckHARDWARE_Notify(IN gckHARDWARE Hardware); /* Program MMU. */ gceSTATUS gckHARDWARE_SetMMU(IN gckHARDWARE Hardware, IN gckMMU Mmu); /* Flush the MMU. */ gceSTATUS gckHARDWARE_FlushMMU(IN gckHARDWARE Hardware, IN gctPOINTER Logical, IN gctADDRESS Address, IN gctUINT32 SubsequentBytes, IN OUT gctUINT32 *Bytes); gceSTATUS gckHARDWARE_FlushAsyncMMU(IN gckHARDWARE Hardware, IN gctPOINTER Logical, IN OUT gctUINT32 *Bytes); gceSTATUS gckHARDWARE_FlushMcfeMMU(IN gckHARDWARE Hardware, IN gctPOINTER Logical, IN OUT gctUINT32 *Bytes); /* 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); /* * State timer helper. */ gceSTATUS gckHARDWARE_StartTimerReset(IN gckHARDWARE Hardware); /* Power management. */ gceSTATUS gckHARDWARE_SetPowerState(IN gckHARDWARE Hardware, IN gceCHIPPOWERSTATE State); gceSTATUS gckHARDWARE_QueryPowerStateUnlocked(IN gckHARDWARE Hardware, OUT gceCHIPPOWERSTATE *State); gceSTATUS gckHARDWARE_QueryPowerState(IN gckHARDWARE Hardware, OUT gceCHIPPOWERSTATE *State); gceSTATUS gckHARDWARE_EnablePowerManagement(IN gckHARDWARE Hardware, IN gctBOOL Enable); gceSTATUS gckHARDWARE_QueryPowerManagement(IN gckHARDWARE Hardware, OUT gctBOOL *Enable); gceSTATUS gckHARDWARE_SetGpuProfiler(IN gckHARDWARE Hardware, IN gctBOOL GpuProfiler); #if gcdENABLE_FSCALE_VAL_ADJUST gceSTATUS gckHARDWARE_SetFscaleValue(IN gckHARDWARE Hardware, IN gctUINT32 FscaleValue, IN gctUINT32 ShaderFscaleValue); 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 gceSTATUS gckHARDWARE_InitializeHardware(IN gckHARDWARE Hardware); gceSTATUS gckHARDWARE_Reset(IN gckHARDWARE Hardware); /* 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_QueryStateTimer(IN gckHARDWARE Hardware, OUT gctUINT64_PTR On, OUT gctUINT64_PTR Off, OUT gctUINT64_PTR Idle, OUT gctUINT64_PTR Suspend); gceSTATUS gckHARDWARE_Fence(IN gckHARDWARE Hardware, IN gceENGINE Engine, IN gctPOINTER Logical, IN gctADDRESS FenceAddress, IN gctUINT64 FenceData, IN OUT gctUINT32 *Bytes); /****************************************************************************** **************************** 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); /****************************************************************************** ******************************** gckMMU Object ******************************* ******************************************************************************/ /* 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, IN gcePAGE_TYPE PageType, OUT gctPOINTER *PageTable, OUT gctADDRESS *Address); gceSTATUS gckMMU_AllocatePagesEx(IN gckMMU Mmu, IN gctSIZE_T PageCount, IN gceVIDMEM_TYPE Type, IN gcePAGE_TYPE PageType, IN gctBOOL LowVA, IN gctBOOL Secure, OUT gctPOINTER *PageTable, OUT gctADDRESS *Address); /* Remove a page table from the MMU. */ gceSTATUS gckMMU_FreePages(IN gckMMU Mmu, IN gctBOOL Secure, IN gcePAGE_TYPE PageType, IN gctBOOL LowVA, IN gctADDRESS Address, IN gctPOINTER PageTable, IN gctSIZE_T PageCount); /* Set the MMU page with info. */ gceSTATUS gckMMU_SetPage(IN gckMMU Mmu, IN gctPHYS_ADDR_T PageAddress, IN gcePAGE_TYPE PageType, IN gctBOOL LowVA, IN gctBOOL Writable, IN gctUINT32 *PageEntry); gceSTATUS gckMMU_Flush(IN gckMMU Mmu, IN gceVIDMEM_TYPE Type); gceSTATUS gckMMU_DumpPageTableEntry(IN gckMMU Mmu, IN gceAREA_TYPE AreaType, IN gctADDRESS Address); gceSTATUS gckMMU_FillFlatMapping(IN gckMMU Mmu, IN gctUINT64 PhysBase, IN gctSIZE_T Size, IN gctBOOL Reserved, IN gctBOOL AbleToShift, OUT gctADDRESS *GpuBaseAddress); gceSTATUS gckMMU_IsFlatMapped(IN gckMMU Mmu, IN gctUINT64 Physical, IN gctSIZE_T Bytes, OUT gctBOOL *In, INOUT gctADDRESS *Address); gceSTATUS gckMMU_GetAreaType(IN gckMMU Mmu, IN gctADDRESS GpuAddress, OUT gceAREA_TYPE *AreaType); gceSTATUS gckHARDWARE_QueryContextProfile(IN gckHARDWARE Hardware, IN gctBOOL Reset, OUT gcsPROFILER_COUNTERS_PART1 *Counters_part1, OUT gcsPROFILER_COUNTERS_PART2 *Counters_part2); gceSTATUS gckHARDWARE_UpdateContextProfile(IN gckHARDWARE Hardware); gceSTATUS gckHARDWARE_InitProfiler(IN gckHARDWARE Hardware); gceSTATUS gckOS_DetectProcessByName(IN gctCONST_POINTER Name); void gckOS_DumpParam(void); gceSTATUS gc_mmuinfo_show(void); #ifdef __cplusplus } #endif #endif /* __gc_hal_h_ */