/*******************************************************************************
**
** gcoVIDMEM_FreeHandleMemory
**
** Free all allocated video memory nodes for a handle.
**
** INPUT:
**
** gcoVIDMEM Memory
** Pointer to an gcoVIDMEM object..
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckVIDMEM_FreeHandleMemory(
IN gckVIDMEM Memory,
IN gctHANDLE Handle
)
{
gceSTATUS status;
gctBOOL mutex = gcvFALSE;
gcuVIDMEM_NODE_PTR node;
gctINT i;
gctUINT32 nodeCount = 0, byteCount = 0;
gctBOOL again;
gcmkHEADER_ARG("Memory=0x%x Handle=0x%x", Memory, Handle);
gcmkVERIFY_OBJECT(Memory, gcvOBJ_VIDMEM);
gcmkONERROR(gckOS_AcquireMutex(Memory->os, Memory->mutex, gcvINFINITE));
mutex = gcvTRUE;
/* Walk all sentinels. */
for (i = 0; i < gcmCOUNTOF(Memory->sentinel); ++i)
{
/* Bail out of the heap if it is not used. */
if (Memory->sentinel[i].VidMem.next == gcvNULL)
{
break;
}
do
{
again = gcvFALSE;
/* Walk all the nodes until we reach the sentinel. */
for (node = Memory->sentinel[i].VidMem.next;
node->VidMem.bytes != 0;
node = node->VidMem.next)
{
/* Free the node if it was allocated by Handle. */
if (node->VidMem.handle == Handle)
{
/* Unlock video memory. */
while (gckVIDMEM_Unlock(node, gcvSURF_TYPE_UNKNOWN, gcvNULL, gcvNULL)
!= gcvSTATUS_MEMORY_UNLOCKED)
;
nodeCount++;
byteCount += node->VidMem.bytes;
/* Free video memory. */
gcmkVERIFY_OK(gckVIDMEM_Free(node, gcvNULL));
/*
* Freeing may cause a merge which will invalidate our iteration.
* Don't be clever, just restart.
*/
again = gcvTRUE;
break;
}
}
}
while (again);
}
gcmkVERIFY_OK(gckOS_ReleaseMutex(Memory->os, Memory->mutex));
gcmkFOOTER();
return gcvSTATUS_OK;
OnError:
if (mutex)
{
gcmkVERIFY_OK(gckOS_ReleaseMutex(Memory->os, Memory->mutex));
}
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** gckKERNEL_Dispatch
**
** Dispatch a command received from the user HAL layer.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to an gckKERNEL object.
**
** gctBOOL FromUser
** whether the call is from the user space.
**
** gcsHAL_INTERFACE * Interface
** Pointer to a gcsHAL_INTERFACE structure that defines the command to
** be dispatched.
**
** OUTPUT:
**
** gcsHAL_INTERFACE * Interface
** Pointer to a gcsHAL_INTERFACE structure that receives any data to be
** returned.
*/
gceSTATUS
gckKERNEL_Dispatch(
IN gckKERNEL Kernel,
IN gctBOOL FromUser,
IN OUT gcsHAL_INTERFACE * Interface
)
{
gceSTATUS status;
gctUINT32 bitsPerPixel;
gctSIZE_T bytes;
gcuVIDMEM_NODE_PTR node;
gctBOOL locked = gcvFALSE;
gctPHYS_ADDR physical;
gctUINT32 address;
gcmkHEADER_ARG("Kernel=0x%x FromUser=%d Interface=0x%x",
Kernel, FromUser, Interface);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
gcmkVERIFY_ARGUMENT(Interface != gcvNULL);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_KERNEL,
"Dispatching command %d", Interface->command);
/* Dispatch on command. */
switch (Interface->command)
{
case gcvHAL_GET_BASE_ADDRESS:
/* Get base address. */
gcmkONERROR(
gckOS_GetBaseAddress(Kernel->os,
&Interface->u.GetBaseAddress.baseAddress));
break;
case gcvHAL_QUERY_VIDEO_MEMORY:
/* Query video memory size. */
gcmkONERROR(gckKERNEL_QueryVideoMemory(Kernel, Interface));
break;
case gcvHAL_QUERY_CHIP_IDENTITY:
/* Query chip identity. */
gcmkONERROR(
gckHARDWARE_QueryChipIdentity(
Kernel->hardware,
&Interface->u.QueryChipIdentity.chipModel,
&Interface->u.QueryChipIdentity.chipRevision,
&Interface->u.QueryChipIdentity.chipFeatures,
&Interface->u.QueryChipIdentity.chipMinorFeatures,
&Interface->u.QueryChipIdentity.chipMinorFeatures1));
/* Query chip specifications. */
gcmkONERROR(
gckHARDWARE_QueryChipSpecs(
Kernel->hardware,
&Interface->u.QueryChipIdentity.streamCount,
&Interface->u.QueryChipIdentity.registerMax,
&Interface->u.QueryChipIdentity.threadCount,
&Interface->u.QueryChipIdentity.shaderCoreCount,
&Interface->u.QueryChipIdentity.vertexCacheSize,
&Interface->u.QueryChipIdentity.vertexOutputBufferSize));
break;
case gcvHAL_MAP_MEMORY:
physical = Interface->u.MapMemory.physical;
/* Map memory. */
gcmkONERROR(
gckKERNEL_MapMemory(Kernel,
physical,
Interface->u.MapMemory.bytes,
&Interface->u.MapMemory.logical));
break;
case gcvHAL_UNMAP_MEMORY:
physical = Interface->u.UnmapMemory.physical;
/* Unmap memory. */
gcmkONERROR(
gckKERNEL_UnmapMemory(Kernel,
physical,
Interface->u.UnmapMemory.bytes,
Interface->u.UnmapMemory.logical));
break;
case gcvHAL_ALLOCATE_NON_PAGED_MEMORY:
/* Allocate non-paged memory. */
#ifdef __QNXNTO__
if (FromUser)
{
gcmkONERROR(
gckOS_AllocateNonPagedMemoryShmPool(
Kernel->os,
FromUser,
Interface->pid,
Interface->handle,
&Interface->u.AllocateNonPagedMemory.bytes,
&Interface->u.AllocateNonPagedMemory.physical,
&Interface->u.AllocateNonPagedMemory.logical));
break;
}
#endif
gcmkONERROR(
gckOS_AllocateNonPagedMemory(
Kernel->os,
FromUser,
&Interface->u.AllocateNonPagedMemory.bytes,
&Interface->u.AllocateNonPagedMemory.physical,
&Interface->u.AllocateNonPagedMemory.logical));
break;
case gcvHAL_FREE_NON_PAGED_MEMORY:
physical = Interface->u.FreeNonPagedMemory.physical;
/* Free non-paged memory. */
gcmkONERROR(
gckOS_FreeNonPagedMemory(Kernel->os,
Interface->u.FreeNonPagedMemory.bytes,
physical,
Interface->u.FreeNonPagedMemory.logical));
break;
case gcvHAL_ALLOCATE_CONTIGUOUS_MEMORY:
/* Allocate contiguous memory. */
#ifdef __QNXNTO__
if (FromUser)
{
gcmkONERROR(
gckOS_AllocateNonPagedMemoryShmPool(
Kernel->os,
FromUser,
Interface->pid,
Interface->handle,
&Interface->u.AllocateNonPagedMemory.bytes,
&Interface->u.AllocateNonPagedMemory.physical,
&Interface->u.AllocateNonPagedMemory.logical));
break;
}
#endif
gcmkONERROR(
gckOS_AllocateContiguous(
Kernel->os,
FromUser,
&Interface->u.AllocateContiguousMemory.bytes,
&Interface->u.AllocateContiguousMemory.physical,
&Interface->u.AllocateContiguousMemory.logical));
break;
case gcvHAL_FREE_CONTIGUOUS_MEMORY:
physical = Interface->u.FreeContiguousMemory.physical;
/* Free contiguous memory. */
gcmkONERROR(
gckOS_FreeContiguous(Kernel->os,
physical,
Interface->u.FreeContiguousMemory.logical,
Interface->u.FreeContiguousMemory.bytes));
break;
case gcvHAL_ALLOCATE_VIDEO_MEMORY:
/* Align width and height to tiles. */
gcmkONERROR(
gckHARDWARE_AlignToTile(Kernel->hardware,
Interface->u.AllocateVideoMemory.type,
&Interface->u.AllocateVideoMemory.width,
&Interface->u.AllocateVideoMemory.height,
gcvNULL));
/* Convert format into bytes per pixel and bytes per tile. */
gcmkONERROR(
gckHARDWARE_ConvertFormat(Kernel->hardware,
Interface->u.AllocateVideoMemory.format,
&bitsPerPixel,
gcvNULL));
/* Compute number of bytes for the allocation. */
bytes = Interface->u.AllocateVideoMemory.width * bitsPerPixel
* Interface->u.AllocateVideoMemory.height
* Interface->u.AllocateVideoMemory.depth / 8;
/* Allocate memory. */
#ifdef __QNXNTO__
gcmkONERROR(
_AllocateMemory(Kernel,
&Interface->u.AllocateVideoMemory.pool,
bytes,
64,
Interface->u.AllocateVideoMemory.type,
Interface->handle,
&Interface->u.AllocateVideoMemory.node));
#else
gcmkONERROR(
_AllocateMemory(Kernel,
&Interface->u.AllocateVideoMemory.pool,
bytes,
64,
Interface->u.AllocateVideoMemory.type,
&Interface->u.AllocateVideoMemory.node));
#endif
break;
case gcvHAL_ALLOCATE_LINEAR_VIDEO_MEMORY:
/* Allocate memory. */
#ifdef __QNXNTO__
gcmkONERROR(
_AllocateMemory(Kernel,
&Interface->u.AllocateLinearVideoMemory.pool,
Interface->u.AllocateLinearVideoMemory.bytes,
Interface->u.AllocateLinearVideoMemory.alignment,
Interface->u.AllocateLinearVideoMemory.type,
Interface->handle,
&Interface->u.AllocateLinearVideoMemory.node));
/* Set the current user pid in the node,
* which is used while locking memory. */
gcmkVERIFY_OK(gckVIDMEM_SetPID(
Interface->u.AllocateLinearVideoMemory.node,
Interface->pid));
#else
gcmkONERROR(
_AllocateMemory(Kernel,
&Interface->u.AllocateLinearVideoMemory.pool,
Interface->u.AllocateLinearVideoMemory.bytes,
Interface->u.AllocateLinearVideoMemory.alignment,
Interface->u.AllocateLinearVideoMemory.type,
&Interface->u.AllocateLinearVideoMemory.node));
#endif
break;
case gcvHAL_FREE_VIDEO_MEMORY:
#ifdef __QNXNTO__
node = Interface->u.FreeVideoMemory.node;
if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM
&& node->VidMem.logical != gcvNULL)
{
gcmkONERROR(
gckKERNEL_UnmapVideoMemory(Kernel,
node->VidMem.logical,
Interface->pid,
node->VidMem.bytes));
node->VidMem.logical = gcvNULL;
}
#endif
/* Free video memory. */
gcmkONERROR(
gckVIDMEM_Free(Interface->u.FreeVideoMemory.node));
break;
case gcvHAL_LOCK_VIDEO_MEMORY:
/* Lock video memory. */
gcmkONERROR(
gckVIDMEM_Lock(Interface->u.LockVideoMemory.node,
&Interface->u.LockVideoMemory.address));
locked = gcvTRUE;
node = Interface->u.LockVideoMemory.node;
if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
{
/* Map video memory address into user space. */
#ifdef __QNXNTO__
if (node->VidMem.logical == gcvNULL)
{
gcmkONERROR(
gckKERNEL_MapVideoMemory(Kernel,
FromUser,
Interface->u.LockVideoMemory.address,
Interface->pid,
node->VidMem.bytes,
&node->VidMem.logical));
}
Interface->u.LockVideoMemory.memory = node->VidMem.logical;
#else
gcmkONERROR(
gckKERNEL_MapVideoMemory(Kernel,
FromUser,
Interface->u.LockVideoMemory.address,
&Interface->u.LockVideoMemory.memory));
#endif
#ifdef __QNXNTO__
/* Add more information to node, which is used while unmapping. */
gcmkVERIFY_OK(gckVIDMEM_SetPID(
Interface->u.LockVideoMemory.node,
Interface->pid));
#endif
}
else
{
/* Copy logical memory for virtual memory. */
Interface->u.LockVideoMemory.memory = node->Virtual.logical;
/* Success. */
status = gcvSTATUS_OK;
}
#if gcdSECURE_USER
/* Return logical address as physical address. */
Interface->u.LockVideoMemory.address =
gcmPTR2INT(Interface->u.LockVideoMemory.memory);
#endif
break;
case gcvHAL_UNLOCK_VIDEO_MEMORY:
/* Unlock video memory. */
node = Interface->u.UnlockVideoMemory.node;
/* Unlock video memory. */
gcmkONERROR(
gckVIDMEM_Unlock(node,
Interface->u.UnlockVideoMemory.type,
&Interface->u.UnlockVideoMemory.asynchroneous));
break;
case gcvHAL_EVENT_COMMIT:
/* Commit an event queue. */
gcmkONERROR(
gckEVENT_Commit(Kernel->event,
Interface->u.Event.queue));
break;
case gcvHAL_COMMIT:
/* Commit a command and context buffer. */
gcmkONERROR(
gckCOMMAND_Commit(Kernel->command,
Interface->u.Commit.commandBuffer,
Interface->u.Commit.contextBuffer,
Interface->u.Commit.process));
break;
case gcvHAL_STALL:
/* Stall the command queue. */
gcmkONERROR(gckCOMMAND_Stall(Kernel->command));
break;
case gcvHAL_MAP_USER_MEMORY:
/* Map user memory to DMA. */
gcmkONERROR(
gckOS_MapUserMemory(Kernel->os,
Interface->u.MapUserMemory.memory,
Interface->u.MapUserMemory.size,
&Interface->u.MapUserMemory.info,
&Interface->u.MapUserMemory.address));
break;
case gcvHAL_UNMAP_USER_MEMORY:
address = Interface->u.MapUserMemory.address;
/* Unmap user memory. */
gcmkONERROR(
gckOS_UnmapUserMemory(Kernel->os,
Interface->u.UnmapUserMemory.memory,
Interface->u.UnmapUserMemory.size,
Interface->u.UnmapUserMemory.info,
address));
break;
#if !USE_NEW_LINUX_SIGNAL
case gcvHAL_USER_SIGNAL:
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_KERNEL,
"Dispatching gcvHAL_USER_SIGNAL %d", Interface->u.UserSignal.command);
/* Dispatch depends on the user signal subcommands. */
switch(Interface->u.UserSignal.command)
{
case gcvUSER_SIGNAL_CREATE:
/* Create a signal used in the user space. */
gcmkONERROR(
gckOS_CreateUserSignal(Kernel->os,
Interface->u.UserSignal.manualReset,
Interface->u.UserSignal.signalType,
&Interface->u.UserSignal.id));
break;
case gcvUSER_SIGNAL_DESTROY:
/* Destroy the signal. */
gcmkONERROR(
gckOS_DestroyUserSignal(Kernel->os,
Interface->u.UserSignal.id));
break;
case gcvUSER_SIGNAL_SIGNAL:
/* Signal the signal. */
gcmkONERROR(
gckOS_SignalUserSignal(Kernel->os,
Interface->u.UserSignal.id,
Interface->u.UserSignal.state));
break;
case gcvUSER_SIGNAL_WAIT:
/* Wait on the signal. */
status = gckOS_WaitUserSignal(Kernel->os,
Interface->u.UserSignal.id,
Interface->u.UserSignal.wait);
break;
default:
/* Invalid user signal command. */
gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
}
break;
#endif
case gcvHAL_SET_POWER_MANAGEMENT_STATE:
/* Set the power management state. */
gcmkONERROR(
gckHARDWARE_SetPowerManagementState(
Kernel->hardware,
Interface->u.SetPowerManagement.state));
break;
case gcvHAL_QUERY_POWER_MANAGEMENT_STATE:
/* Chip is not idle. */
Interface->u.QueryPowerManagement.isIdle = gcvFALSE;
/* Query the power management state. */
gcmkONERROR(gckHARDWARE_QueryPowerManagementState(
Kernel->hardware,
&Interface->u.QueryPowerManagement.state));
/* Query the idle state. */
gcmkONERROR(
gckHARDWARE_QueryIdle(Kernel->hardware,
&Interface->u.QueryPowerManagement.isIdle));
break;
case gcvHAL_READ_REGISTER:
#if gcdREGISTER_ACCESS_FROM_USER
/* Read a register. */
gcmkONERROR(
gckOS_ReadRegister(Kernel->os,
Interface->u.ReadRegisterData.address,
&Interface->u.ReadRegisterData.data));
#else
/* No access from user land to read registers. */
Interface->u.ReadRegisterData.data = 0;
status = gcvSTATUS_NOT_SUPPORTED;
#endif
break;
case gcvHAL_WRITE_REGISTER:
#if gcdREGISTER_ACCESS_FROM_USER
/* Write a register. */
gcmkONERROR(
gckOS_WriteRegister(Kernel->os,
Interface->u.WriteRegisterData.address,
Interface->u.WriteRegisterData.data));
#else
/* No access from user land to write registers. */
status = gcvSTATUS_NOT_SUPPORTED;
#endif
break;
case gcvHAL_READ_ALL_PROFILE_REGISTERS:
#if VIVANTE_PROFILER
/* Read all 3D profile registers. */
gcmkONERROR(
gckHARDWARE_QueryProfileRegisters(
Kernel->hardware,
&Interface->u.RegisterProfileData.counters));
#else
status = gcvSTATUS_OK;
#endif
break;
case gcvHAL_PROFILE_REGISTERS_2D:
#if VIVANTE_PROFILER
/* Read all 2D profile registers. */
gcmkONERROR(
gckHARDWARE_ProfileEngine2D(
Kernel->hardware,
Interface->u.RegisterProfileData2D.hwProfile2D));
#else
status = gcvSTATUS_OK;
#endif
break;
case gcvHAL_GET_PROFILE_SETTING:
#if VIVANTE_PROFILER
/* Get profile setting */
Interface->u.GetProfileSetting.enable = Kernel->profileEnable;
gcmkVERIFY_OK(
gckOS_MemCopy(Interface->u.GetProfileSetting.fileName,
Kernel->profileFileName,
gcdMAX_PROFILE_FILE_NAME));
#endif
status = gcvSTATUS_OK;
break;
case gcvHAL_SET_PROFILE_SETTING:
#if VIVANTE_PROFILER
/* Set profile setting */
Kernel->profileEnable = Interface->u.SetProfileSetting.enable;
gcmkVERIFY_OK(
gckOS_MemCopy(Kernel->profileFileName,
Interface->u.SetProfileSetting.fileName,
gcdMAX_PROFILE_FILE_NAME));
#endif
status = gcvSTATUS_OK;
break;
case gcvHAL_QUERY_KERNEL_SETTINGS:
/* Get kernel settings. */
gcmkONERROR(
gckKERNEL_QuerySettings(Kernel,
&Interface->u.QueryKernelSettings.settings));
break;
case gcvHAL_RESET:
/* Reset the hardware. */
gcmkONERROR(
gckHARDWARE_Reset(Kernel->hardware));
break;
case gcvHAL_DEBUG:
/* Set debug level and zones. */
if (Interface->u.Debug.set)
{
gckOS_SetDebugLevel(Interface->u.Debug.level);
gckOS_SetDebugZones(Interface->u.Debug.zones,
Interface->u.Debug.enable);
}
if (Interface->u.Debug.message[0] != '\0')
{
/* Print a message to the debugger. */
gcmkPRINT(Interface->u.Debug.message);
}
status = gcvSTATUS_OK;
break;
case gcvHAL_CACHE:
if (Interface->u.Cache.invalidate)
{
/* Flush and invalidate the cache. */
status = gckOS_CacheInvalidate(Kernel->os,
Interface->u.Cache.process,
Interface->u.Cache.logical,
Interface->u.Cache.bytes);
}
else
{
/* Flush the cache. */
status = gckOS_CacheFlush(Kernel->os,
Interface->u.Cache.process,
Interface->u.Cache.logical,
Interface->u.Cache.bytes);
}
break;
default:
/* Invalid command. */
gcmkONERROR(gcvSTATUS_INVALID_ARGUMENT);
}
OnError:
/* Save status. */
Interface->status = status;
if (gcmIS_ERROR(status))
{
if (locked)
{
/* Roll back the lock. */
gcmkVERIFY_OK(
gckVIDMEM_Unlock(Interface->u.LockVideoMemory.node,
gcvSURF_TYPE_UNKNOWN,
gcvNULL));
}
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** gckKERNEL_Dispatch
**
** Dispatch a command received from the user HAL layer.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to an gckKERNEL object.
**
** gcsHAL_INTERFACE * Interface
** Pointer to a gcsHAL_INTERFACE structure that defines the command to
** be dispatched.
**
** OUTPUT:
**
** gcsHAL_INTERFACE * Interface
** Pointer to a gcsHAL_INTERFACE structure that receives any data to be
** returned.
*/
gceSTATUS gckVGKERNEL_Dispatch(
IN gckKERNEL Kernel,
IN gctBOOL FromUser,
IN OUT gcsHAL_INTERFACE * Interface
)
{
gceSTATUS status;
gcsHAL_INTERFACE * kernelInterface = Interface;
gcuVIDMEM_NODE_PTR node;
gctUINT32 processID;
gcmkHEADER_ARG("Kernel=0x%x Interface=0x%x ", Kernel, Interface);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
gcmkVERIFY_ARGUMENT(Interface != gcvNULL);
gcmkONERROR(gckOS_GetProcessID(&processID));
/* Dispatch on command. */
switch (Interface->command)
{
case gcvHAL_QUERY_VIDEO_MEMORY:
/* Query video memory size. */
gcmkERR_BREAK(gckKERNEL_QueryVideoMemory(
Kernel, kernelInterface
));
break;
case gcvHAL_QUERY_CHIP_IDENTITY:
/* Query chip identity. */
gcmkERR_BREAK(gckVGHARDWARE_QueryChipIdentity(
Kernel->vg->hardware,
&kernelInterface->u.QueryChipIdentity.chipModel,
&kernelInterface->u.QueryChipIdentity.chipRevision,
&kernelInterface->u.QueryChipIdentity.chipFeatures,
&kernelInterface->u.QueryChipIdentity.chipMinorFeatures,
&kernelInterface->u.QueryChipIdentity.chipMinorFeatures2
));
break;
case gcvHAL_QUERY_COMMAND_BUFFER:
/* Query command buffer information. */
gcmkERR_BREAK(gckKERNEL_QueryCommandBuffer(
Kernel,
&kernelInterface->u.QueryCommandBuffer.information
));
break;
case gcvHAL_ALLOCATE_NON_PAGED_MEMORY:
/* Allocate non-paged memory. */
gcmkERR_BREAK(gckOS_AllocateContiguous(
Kernel->os,
gcvTRUE,
&kernelInterface->u.AllocateNonPagedMemory.bytes,
&kernelInterface->u.AllocateNonPagedMemory.physical,
&kernelInterface->u.AllocateNonPagedMemory.logical
));
break;
case gcvHAL_FREE_NON_PAGED_MEMORY:
/* Unmap user logical out of physical memory first. */
gcmkERR_BREAK(gckOS_UnmapUserLogical(
Kernel->os,
kernelInterface->u.AllocateNonPagedMemory.physical,
kernelInterface->u.AllocateNonPagedMemory.bytes,
kernelInterface->u.AllocateNonPagedMemory.logical
));
/* Free non-paged memory. */
gcmkERR_BREAK(gckOS_FreeNonPagedMemory(
Kernel->os,
kernelInterface->u.AllocateNonPagedMemory.bytes,
kernelInterface->u.AllocateNonPagedMemory.physical,
kernelInterface->u.AllocateNonPagedMemory.logical
));
break;
case gcvHAL_ALLOCATE_CONTIGUOUS_MEMORY:
/* Allocate contiguous memory. */
gcmkERR_BREAK(gckOS_AllocateContiguous(
Kernel->os,
gcvTRUE,
&kernelInterface->u.AllocateNonPagedMemory.bytes,
&kernelInterface->u.AllocateNonPagedMemory.physical,
&kernelInterface->u.AllocateNonPagedMemory.logical
));
break;
case gcvHAL_FREE_CONTIGUOUS_MEMORY:
/* Unmap user logical out of physical memory first. */
gcmkERR_BREAK(gckOS_UnmapUserLogical(
Kernel->os,
kernelInterface->u.AllocateNonPagedMemory.physical,
kernelInterface->u.AllocateNonPagedMemory.bytes,
kernelInterface->u.AllocateNonPagedMemory.logical
));
/* Free contiguous memory. */
gcmkERR_BREAK(gckOS_FreeContiguous(
Kernel->os,
kernelInterface->u.AllocateNonPagedMemory.physical,
kernelInterface->u.AllocateNonPagedMemory.logical,
kernelInterface->u.AllocateNonPagedMemory.bytes
));
break;
case gcvHAL_ALLOCATE_VIDEO_MEMORY:
{
gctSIZE_T bytes;
gctUINT32 bitsPerPixel;
gctUINT32 bits;
/* Align width and height to tiles. */
gcmkERR_BREAK(gckVGHARDWARE_AlignToTile(
Kernel->vg->hardware,
kernelInterface->u.AllocateVideoMemory.type,
&kernelInterface->u.AllocateVideoMemory.width,
&kernelInterface->u.AllocateVideoMemory.height
));
/* Convert format into bytes per pixel and bytes per tile. */
gcmkERR_BREAK(gckVGHARDWARE_ConvertFormat(
Kernel->vg->hardware,
kernelInterface->u.AllocateVideoMemory.format,
&bitsPerPixel,
gcvNULL
));
/* Compute number of bits for the allocation. */
bits
= kernelInterface->u.AllocateVideoMemory.width
* kernelInterface->u.AllocateVideoMemory.height
* kernelInterface->u.AllocateVideoMemory.depth
* bitsPerPixel;
/* Compute number of bytes for the allocation. */
bytes = gcmALIGN(bits, 8) / 8;
/* Allocate memory. */
gcmkERR_BREAK(gckKERNEL_AllocateLinearMemory(
Kernel,
&kernelInterface->u.AllocateVideoMemory.pool,
bytes,
64,
kernelInterface->u.AllocateVideoMemory.type,
&kernelInterface->u.AllocateVideoMemory.node
));
}
break;
case gcvHAL_ALLOCATE_LINEAR_VIDEO_MEMORY:
/* Allocate memory. */
gcmkERR_BREAK(gckKERNEL_AllocateLinearMemory(
Kernel,
&kernelInterface->u.AllocateLinearVideoMemory.pool,
kernelInterface->u.AllocateLinearVideoMemory.bytes,
kernelInterface->u.AllocateLinearVideoMemory.alignment,
kernelInterface->u.AllocateLinearVideoMemory.type,
&kernelInterface->u.AllocateLinearVideoMemory.node
));
gcmkERR_BREAK(gckKERNEL_AddProcessDB(Kernel,
processID, gcvDB_VIDEO_MEMORY,
Interface->u.AllocateLinearVideoMemory.node,
gcvNULL,
kernelInterface->u.AllocateLinearVideoMemory.bytes
));
break;
case gcvHAL_FREE_VIDEO_MEMORY:
#ifdef __QNXNTO__
/* Unmap the video memory */
node = Interface->u.FreeVideoMemory.node;
if ((node->VidMem.memory->object.type == gcvOBJ_VIDMEM) &&
(node->VidMem.logical != gcvNULL))
{
gckKERNEL_UnmapVideoMemory(Kernel,
node->VidMem.logical,
processID,
node->VidMem.bytes);
node->VidMem.logical = gcvNULL;
}
#endif /* __QNXNTO__ */
/* Free video memory. */
gcmkERR_BREAK(gckVIDMEM_Free(
Interface->u.FreeVideoMemory.node
));
gcmkERR_BREAK(gckKERNEL_RemoveProcessDB(
Kernel,
processID, gcvDB_VIDEO_MEMORY,
Interface->u.FreeVideoMemory.node
));
break;
case gcvHAL_MAP_MEMORY:
/* Map memory. */
gcmkERR_BREAK(gckKERNEL_MapMemory(
Kernel,
kernelInterface->u.MapMemory.physical,
kernelInterface->u.MapMemory.bytes,
&kernelInterface->u.MapMemory.logical
));
break;
case gcvHAL_UNMAP_MEMORY:
/* Unmap memory. */
gcmkERR_BREAK(gckKERNEL_UnmapMemory(
Kernel,
kernelInterface->u.MapMemory.physical,
kernelInterface->u.MapMemory.bytes,
kernelInterface->u.MapMemory.logical
));
break;
case gcvHAL_MAP_USER_MEMORY:
/* Map user memory to DMA. */
gcmkERR_BREAK(gckOS_MapUserMemory(
Kernel->os,
gcvCORE_VG,
kernelInterface->u.MapUserMemory.memory,
kernelInterface->u.MapUserMemory.physical,
kernelInterface->u.MapUserMemory.size,
&kernelInterface->u.MapUserMemory.info,
&kernelInterface->u.MapUserMemory.address
));
break;
case gcvHAL_UNMAP_USER_MEMORY:
/* Unmap user memory. */
gcmkERR_BREAK(gckOS_UnmapUserMemory(
Kernel->os,
gcvCORE_VG,
kernelInterface->u.UnmapUserMemory.memory,
kernelInterface->u.UnmapUserMemory.size,
kernelInterface->u.UnmapUserMemory.info,
kernelInterface->u.UnmapUserMemory.address
));
break;
case gcvHAL_LOCK_VIDEO_MEMORY:
/* Lock video memory. */
gcmkERR_BREAK(
gckVIDMEM_Lock(Kernel,
Interface->u.LockVideoMemory.node,
gcvFALSE,
&Interface->u.LockVideoMemory.address));
node = Interface->u.LockVideoMemory.node;
if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
{
/* Map video memory address into user space. */
#ifdef __QNXNTO__
if (node->VidMem.logical == gcvNULL)
{
gcmkONERROR(
gckKERNEL_MapVideoMemory(Kernel,
FromUser,
Interface->u.LockVideoMemory.address,
processID,
node->VidMem.bytes,
&node->VidMem.logical));
}
Interface->u.LockVideoMemory.memory = node->VidMem.logical;
#else
gcmkERR_BREAK(
gckKERNEL_MapVideoMemoryEx(Kernel,
gcvCORE_VG,
FromUser,
Interface->u.LockVideoMemory.address,
&Interface->u.LockVideoMemory.memory));
#endif
}
else
{
Interface->u.LockVideoMemory.memory = node->Virtual.logical;
/* Success. */
status = gcvSTATUS_OK;
}
#if gcdSECURE_USER
/* Return logical address as physical address. */
Interface->u.LockVideoMemory.address =
gcmPTR2INT(Interface->u.LockVideoMemory.memory);
#endif
gcmkERR_BREAK(
gckKERNEL_AddProcessDB(Kernel,
processID, gcvDB_VIDEO_MEMORY_LOCKED,
Interface->u.LockVideoMemory.node,
gcvNULL,
0));
break;
case gcvHAL_UNLOCK_VIDEO_MEMORY:
/* Unlock video memory. */
node = Interface->u.UnlockVideoMemory.node;
#if gcdSECURE_USER
/* Save node information before it disappears. */
if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
{
logical = gcvNULL;
bytes = 0;
}
else
{
logical = node->Virtual.logical;
bytes = node->Virtual.bytes;
}
#endif
/* Unlock video memory. */
gcmkERR_BREAK(
gckVIDMEM_Unlock(Kernel,
node,
Interface->u.UnlockVideoMemory.type,
&Interface->u.UnlockVideoMemory.asynchroneous,
gcvFALSE));
#if gcdSECURE_USER
/* Flush the translation cache for virtual surfaces. */
if (logical != gcvNULL)
{
gcmkVERIFY_OK(gckKERNEL_FlushTranslationCache(Kernel,
cache,
logical,
bytes));
}
#endif
if (Interface->u.UnlockVideoMemory.asynchroneous == gcvFALSE)
{
/* There isn't a event to unlock this node, remove record now */
gcmkERR_BREAK(
gckKERNEL_RemoveProcessDB(Kernel,
processID, gcvDB_VIDEO_MEMORY_LOCKED,
Interface->u.UnlockVideoMemory.node));
}
break;
case gcvHAL_USER_SIGNAL:
#if !USE_NEW_LINUX_SIGNAL
/* Dispatch depends on the user signal subcommands. */
switch(Interface->u.UserSignal.command)
{
case gcvUSER_SIGNAL_CREATE:
/* Create a signal used in the user space. */
gcmkERR_BREAK(
gckOS_CreateUserSignal(Kernel->os,
Interface->u.UserSignal.manualReset,
&Interface->u.UserSignal.id));
gcmkVERIFY_OK(
gckKERNEL_AddProcessDB(Kernel,
processID, gcvDB_SIGNAL,
gcmINT2PTR(Interface->u.UserSignal.id),
gcvNULL,
0));
break;
case gcvUSER_SIGNAL_DESTROY:
/* Destroy the signal. */
gcmkERR_BREAK(
gckOS_DestroyUserSignal(Kernel->os,
Interface->u.UserSignal.id));
gcmkVERIFY_OK(gckKERNEL_RemoveProcessDB(
Kernel,
processID, gcvDB_SIGNAL,
gcmINT2PTR(Interface->u.UserSignal.id)));
break;
case gcvUSER_SIGNAL_SIGNAL:
/* Signal the signal. */
gcmkERR_BREAK(
gckOS_SignalUserSignal(Kernel->os,
Interface->u.UserSignal.id,
Interface->u.UserSignal.state));
break;
case gcvUSER_SIGNAL_WAIT:
/* Wait on the signal. */
status = gckOS_WaitUserSignal(Kernel->os,
Interface->u.UserSignal.id,
Interface->u.UserSignal.wait);
break;
default:
/* Invalid user signal command. */
gcmkERR_BREAK(gcvSTATUS_INVALID_ARGUMENT);
}
#endif
break;
case gcvHAL_COMMIT:
/* Commit a command and context buffer. */
gcmkERR_BREAK(gckVGCOMMAND_Commit(
Kernel->vg->command,
kernelInterface->u.VGCommit.context,
kernelInterface->u.VGCommit.queue,
kernelInterface->u.VGCommit.entryCount,
kernelInterface->u.VGCommit.taskTable
));
break;
case gcvHAL_VERSION:
kernelInterface->u.Version.major = gcvVERSION_MAJOR;
kernelInterface->u.Version.minor = gcvVERSION_MINOR;
kernelInterface->u.Version.patch = gcvVERSION_PATCH;
kernelInterface->u.Version.build = gcvVERSION_BUILD;
status = gcvSTATUS_OK;
break;
case gcvHAL_GET_BASE_ADDRESS:
/* Get base address. */
gcmkERR_BREAK(
gckOS_GetBaseAddress(Kernel->os,
&kernelInterface->u.GetBaseAddress.baseAddress));
break;
default:
/* Invalid command. */
status = gcvSTATUS_INVALID_ARGUMENT;
}
OnError:
/* Save status. */
kernelInterface->status = status;
gcmkFOOTER();
/* Return the status. */
return status;
}
/*******************************************************************************
** gckKERNEL_DestroyProcessDB
**
** Destroy a process database. If the database contains any records, the data
** inside those records will be deleted as well. This aids in the cleanup if
** a process has died unexpectedly or has memory leaks.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gctUINT32 ProcessID
** Process ID used to identify the database.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckKERNEL_DestroyProcessDB(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID
)
{
gceSTATUS status;
gcsDATABASE_PTR database;
gcsDATABASE_RECORD_PTR record, next;
gctBOOL asynchronous;
gctPHYS_ADDR physical;
gcuVIDMEM_NODE_PTR node;
gckKERNEL kernel = Kernel;
gctUINT32 i;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d", Kernel, ProcessID);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
/* Find the database. */
gcmkONERROR(gckKERNEL_FindDatabase(Kernel, ProcessID, gcvFALSE, &database));
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): VidMem: total=%lu max=%lu",
ProcessID, database->vidMem.totalBytes,
database->vidMem.maxBytes);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): NonPaged: total=%lu max=%lu",
ProcessID, database->nonPaged.totalBytes,
database->nonPaged.maxBytes);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): Contiguous: total=%lu max=%lu",
ProcessID, database->contiguous.totalBytes,
database->contiguous.maxBytes);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): Idle time=%llu",
ProcessID, Kernel->db->idleTime);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): Map: total=%lu max=%lu",
ProcessID, database->mapMemory.totalBytes,
database->mapMemory.maxBytes);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DATABASE,
"DB(%d): Map: total=%lu max=%lu",
ProcessID, database->mapUserMemory.totalBytes,
database->mapUserMemory.maxBytes);
if (database->list != gcvNULL)
{
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"Process %d has entries in its database:",
ProcessID);
}
for(i = 0; i < gcmCOUNTOF(database->list); i++)
{
/* Walk all records. */
for (record = database->list[i]; record != gcvNULL; record = next)
{
/* Next next record. */
next = record->next;
/* Dispatch on record type. */
switch (record->type)
{
case gcvDB_VIDEO_MEMORY:
/* Free the video memory. */
status = gckVIDMEM_Free(gcmUINT64_TO_PTR(record->data));
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: VIDEO_MEMORY 0x%x (status=%d)",
record->data, status);
break;
case gcvDB_NON_PAGED:
physical = gcmNAME_TO_PTR(record->physical);
/* Unmap user logical memory first. */
status = gckOS_UnmapUserLogical(Kernel->os,
physical,
record->bytes,
record->data);
/* Free the non paged memory. */
status = gckOS_FreeNonPagedMemory(Kernel->os,
record->bytes,
physical,
record->data);
gcmRELEASE_NAME(record->physical);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: NON_PAGED 0x%x, bytes=%lu (status=%d)",
record->data, record->bytes, status);
break;
#if gcdVIRTUAL_COMMAND_BUFFER
case gcvDB_COMMAND_BUFFER:
/* Free the command buffer. */
status = gckEVENT_DestroyVirtualCommandBuffer(record->kernel->eventObj,
record->bytes,
gcmNAME_TO_PTR(record->physical),
record->data,
gcvKERNEL_PIXEL);
gcmRELEASE_NAME(record->physical);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: COMMAND_BUFFER 0x%x, bytes=%lu (status=%d)",
record->data, record->bytes, status);
break;
#endif
case gcvDB_CONTIGUOUS:
physical = gcmNAME_TO_PTR(record->physical);
/* Unmap user logical memory first. */
status = gckOS_UnmapUserLogical(Kernel->os,
physical,
record->bytes,
record->data);
/* Free the contiguous memory. */
status = gckEVENT_FreeContiguousMemory(Kernel->eventObj,
record->bytes,
physical,
record->data,
gcvKERNEL_PIXEL);
gcmRELEASE_NAME(record->physical);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: CONTIGUOUS 0x%x bytes=%lu (status=%d)",
record->data, record->bytes, status);
break;
case gcvDB_SIGNAL:
#if USE_NEW_LINUX_SIGNAL
status = gcvSTATUS_NOT_SUPPORTED;
#else
/* Free the user signal. */
status = gckOS_DestroyUserSignal(Kernel->os,
gcmPTR2INT(record->data));
#endif /* USE_NEW_LINUX_SIGNAL */
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: SIGNAL %d (status=%d)",
(gctINT)(gctUINTPTR_T)record->data, status);
break;
case gcvDB_VIDEO_MEMORY_LOCKED:
node = gcmUINT64_TO_PTR(record->data);
/* Unlock what we still locked */
status = gckVIDMEM_Unlock(record->kernel,
node,
gcvSURF_TYPE_UNKNOWN,
&asynchronous);
if (gcmIS_SUCCESS(status) && (gcvTRUE == asynchronous))
{
/* TODO: we maybe need to schedule a event here */
status = gckVIDMEM_Unlock(record->kernel,
node,
gcvSURF_TYPE_UNKNOWN,
gcvNULL);
}
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: VIDEO_MEMORY_LOCKED 0x%x (status=%d)",
node, status);
break;
case gcvDB_CONTEXT:
/* TODO: Free the context */
status = gckCOMMAND_Detach(Kernel->command, gcmNAME_TO_PTR(record->data));
gcmRELEASE_NAME(record->data);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: CONTEXT 0x%x (status=%d)",
record->data, status);
break;
case gcvDB_MAP_MEMORY:
/* Unmap memory. */
status = gckKERNEL_UnmapMemory(Kernel,
record->physical,
record->bytes,
record->data);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: MAP MEMORY %d (status=%d)",
gcmPTR2INT(record->data), status);
break;
case gcvDB_MAP_USER_MEMORY:
/* TODO: Unmap user memory. */
status = gckOS_UnmapUserMemory(Kernel->os,
Kernel->core,
record->physical,
record->bytes,
gcmNAME_TO_PTR(record->data),
0);
gcmRELEASE_NAME(record->data);
gcmkTRACE_ZONE(gcvLEVEL_WARNING, gcvZONE_DATABASE,
"DB: MAP USER MEMORY %d (status=%d)",
gcmPTR2INT(record->data), status);
break;
case gcvDB_SHARED_INFO:
status = gckOS_FreeMemory(Kernel->os, record->physical);
break;
default:
gcmkTRACE_ZONE(gcvLEVEL_ERROR, gcvZONE_DATABASE,
"DB: Correcupted record=0x%08x type=%d",
record, record->type);
break;
}
/* Delete the record. */
gcmkONERROR(gckKERNEL_DeleteRecord(Kernel,
database,
record->type,
record->data,
gcvNULL));
}
}
/* Delete the database. */
gcmkONERROR(gckKERNEL_DeleteDatabase(Kernel, database));
/* Success. */
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmkFOOTER();
return status;
}