** if lock holder call gckCOMMAND_Stall() */
gcmkONERROR(gcvSTATUS_INVALID_REQUEST);
}
+#if gcdPOWEROFF_TIMEOUT
+ else if(State == gcvPOWER_OFF && timeout == gcvTRUE)
+ {
+ /*
+ ** try to aqcuire the mutex with more milliseconds,
+ ** flush_delayed_work should be running with timeout,
+ ** so waiting here will cause deadlock */
+ status = gckOS_AcquireMutex(os, Hardware->powerMutex, gcdPOWEROFF_TIMEOUT);
+
+ if (status == gcvSTATUS_TIMEOUT)
+ {
+ gckOS_Print("GPU Timer deadlock, exit by timeout!!!!\n");
+
+ gcmkONERROR(gcvSTATUS_INVALID_REQUEST);
+ }
+ }
+#endif
else
{
/* Acquire the power mutex. */
if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
{
bytes = node->VidMem.bytes;
+
+ gcmkONERROR(
+ gckKERNEL_AddProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_RESERVED,
+ node,
+ gcvNULL,
+ bytes));
}
else
{
bytes = node->Virtual.bytes;
+
+ if(node->Virtual.contiguous)
+ {
+ gcmkONERROR(
+ gckKERNEL_AddProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_CONTIGUOUS,
+ node,
+ gcvNULL,
+ bytes));
+ }
+ else
+ {
+ gcmkONERROR(
+ gckKERNEL_AddProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_VIRTUAL,
+ node,
+ gcvNULL,
+ bytes));
+ }
+
}
gcmkONERROR(
processID, gcvDB_VIDEO_MEMORY,
node));
+ if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
+ {
+ gcmkONERROR(
+ gckKERNEL_RemoveProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_RESERVED,
+ node));
+ }
+ else if(node->Virtual.contiguous)
+ {
+ gcmkONERROR(
+ gckKERNEL_RemoveProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_CONTIGUOUS,
+ node));
+ }
+ else
+ {
+ gcmkONERROR(
+ gckKERNEL_RemoveProcessDB(Kernel,
+ processID, gcvDB_VIDEO_MEMORY_VIRTUAL,
+ node));
+ }
+
break;
case gcvHAL_LOCK_VIDEO_MEMORY:
if (hardware)
{
/* This signal is bound to a hardware,
- ** so the timeout is limited by gcdGPU_TIMEOUT.
+ ** so the timeout is limited by Kernel->timeOut.
*/
timer += gcdGPU_ADVANCETIMER;
}
- if (timer >= gcdGPU_TIMEOUT)
+ if (timer >= Kernel->timeOut)
{
gcmkONERROR(
gckOS_Broadcast(Kernel->os,
&Interface->u.Database.gpuIdle));
break;
+ case gcvHAL_VIDMEM_DATABASE:
+ /* Query reserved video memory. */
+ gcmkONERROR(
+ gckKERNEL_QueryProcessDB(Kernel,
+ Interface->u.VidMemDatabase.processID,
+ !Interface->u.VidMemDatabase.validProcessID,
+ gcvDB_VIDEO_MEMORY_RESERVED,
+ &Interface->u.VidMemDatabase.vidMemResv));
+
+ /* Query contiguous video memory. */
+ gcmkONERROR(
+ gckKERNEL_QueryProcessDB(Kernel,
+ Interface->u.VidMemDatabase.processID,
+ !Interface->u.VidMemDatabase.validProcessID,
+ gcvDB_VIDEO_MEMORY_CONTIGUOUS,
+ &Interface->u.VidMemDatabase.vidMemCont));
+
+ /* Query virtual video memory. */
+ gcmkONERROR(
+ gckKERNEL_QueryProcessDB(Kernel,
+ Interface->u.VidMemDatabase.processID,
+ !Interface->u.VidMemDatabase.validProcessID,
+ gcvDB_VIDEO_MEMORY_VIRTUAL,
+ &Interface->u.VidMemDatabase.vidMemVirt));
+
+ break;
+
case gcvHAL_VERSION:
Interface->u.Version.major = gcvVERSION_MAJOR;
Interface->u.Version.minor = gcvVERSION_MINOR;
gcvDB_SHARED_INFO, /* Private data */
gcvDB_MAP_USER_MEMORY, /* Map user memory */
gcvDB_SYNC_POINT, /* Sync point. */
+ gcvDB_VIDEO_MEMORY_RESERVED, /* Reserved video memory */
+ gcvDB_VIDEO_MEMORY_CONTIGUOUS, /* Contiguous video memory */
+ gcvDB_VIDEO_MEMORY_VIRTUAL, /* Virtual video memory */
}
gceDATABASE_TYPE;
gcsDATABASE_COUNTERS contiguous;
gcsDATABASE_COUNTERS mapUserMemory;
gcsDATABASE_COUNTERS mapMemory;
+ gcsDATABASE_COUNTERS vidMemResv;
+ gcsDATABASE_COUNTERS vidMemCont;
+ gcsDATABASE_COUNTERS vidMemVirt;
/* Idle time management. */
gctUINT64 lastIdle;
database->mapUserMemory.bytes = 0;
database->mapUserMemory.maxBytes = 0;
database->mapUserMemory.totalBytes = 0;
+ database->vidMemResv.bytes = 0;
+ database->vidMemResv.maxBytes = 0;
+ database->vidMemResv.totalBytes = 0;
+ database->vidMemCont.bytes = 0;
+ database->vidMemCont.maxBytes = 0;
+ database->vidMemCont.totalBytes = 0;
+ database->vidMemVirt.bytes = 0;
+ database->vidMemVirt.maxBytes = 0;
+ database->vidMemVirt.totalBytes = 0;
for (i = 0; i < gcmCOUNTOF(database->list); i++)
{
count = &database->mapUserMemory;
break;
+ case gcvDB_VIDEO_MEMORY_RESERVED:
+ count = &database->vidMemResv;
+ break;
+
+ case gcvDB_VIDEO_MEMORY_CONTIGUOUS:
+ count = &database->vidMemCont;
+ break;
+
+ case gcvDB_VIDEO_MEMORY_VIRTUAL:
+ count = &database->vidMemVirt;
+ break;
+
default:
count = gcvNULL;
break;
database->mapUserMemory.bytes -= bytes;
break;
+ case gcvDB_VIDEO_MEMORY_RESERVED:
+ database->vidMemResv.bytes -= bytes;
+ break;
+
+ case gcvDB_VIDEO_MEMORY_CONTIGUOUS:
+ database->vidMemCont.bytes -= bytes;
+ break;
+
+ case gcvDB_VIDEO_MEMORY_VIRTUAL:
+ database->vidMemVirt.bytes -= bytes;
+ break;
+
default:
break;
}
break;
#endif
+ case gcvDB_VIDEO_MEMORY_RESERVED:
+ case gcvDB_VIDEO_MEMORY_CONTIGUOUS:
+ case gcvDB_VIDEO_MEMORY_VIRTUAL:
+ break;//Nothing to do
+
default:
gcmkTRACE_ZONE(gcvLEVEL_ERROR, gcvZONE_DATABASE,
"DB: Correcupted record=0x%08x type=%d",
gcmSIZEOF(database->mapUserMemory));
break;
+ case gcvDB_VIDEO_MEMORY_RESERVED:
+ gckOS_MemCopy(&Info->counters,
+ &database->vidMemResv,
+ gcmSIZEOF(database->vidMemResv));
+ break;
+
+ case gcvDB_VIDEO_MEMORY_CONTIGUOUS:
+ gckOS_MemCopy(&Info->counters,
+ &database->vidMemCont,
+ gcmSIZEOF(database->vidMemCont));
+ break;
+
+ case gcvDB_VIDEO_MEMORY_VIRTUAL:
+ gckOS_MemCopy(&Info->counters,
+ &database->vidMemVirt,
+ gcmSIZEOF(database->vidMemVirt));
+ break;
+
default:
break;
}
void
gckOS_Verify(
- IN gceSTATUS Status
+ IN gceSTATUS status
)
{
- _lastError = Status;
+ _lastError = status;
}
/*******************************************************************************
Record->processID,
gcvDB_VIDEO_MEMORY,
gcmUINT64_TO_PTR(Record->info.u.FreeVideoMemory.node)));
+
+ {
+ gcuVIDMEM_NODE_PTR node = (gcuVIDMEM_NODE_PTR)(gcmUINT64_TO_PTR(Record->info.u.FreeVideoMemory.node));
+
+ if (node->VidMem.memory->object.type == gcvOBJ_VIDMEM)
+ {
+ gcmkVERIFY_OK(gckKERNEL_RemoveProcessDB(Event->kernel,
+ Record->processID,
+ gcvDB_VIDEO_MEMORY_RESERVED,
+ node));
+ }
+ else if(node->Virtual.contiguous)
+ {
+ gcmkVERIFY_OK(gckKERNEL_RemoveProcessDB(Event->kernel,
+ Record->processID,
+ gcvDB_VIDEO_MEMORY_CONTIGUOUS,
+ node));
+ }
+ else
+ {
+ gcmkVERIFY_OK(gckKERNEL_RemoveProcessDB(Event->kernel,
+ Record->processID,
+ gcvDB_VIDEO_MEMORY_VIRTUAL,
+ node));
+ }
+ }
+
break;
case gcvHAL_UNLOCK_VIDEO_MEMORY:
/* Increment the wait timer. */
timer += 1;
- if (timer == gcdGPU_TIMEOUT)
+ if (timer == Event->kernel->timeOut)
{
/* Try to call any outstanding events. */
gcmkONERROR(gckHARDWARE_Interrupt(Event->kernel->hardware,
gcvTRUE));
}
- else if (timer > gcdGPU_TIMEOUT)
+ else if (timer > Event->kernel->timeOut)
{
gcmkTRACE_N(
gcvLEVEL_ERROR,
void
gcoOS_Verify(
- IN gceSTATUS Status
+ IN gceSTATUS status
);
void
gckOS_Verify(
- IN gceSTATUS Status
+ IN gceSTATUS status
);
#if gcmIS_DEBUG(gcdDEBUG_ASSERT)
*
*****************************************************************************/
-
/*
** Include file the defines the front- and back-end compilers, as well as the
** objects they use.
IN gctCONST_STRING FragmentSource,
OUT gctBOOL * clipW);
+/*******************************************************************************
+** gcSHADER_GetUniformVectorCount
+**
+** Get the number of vectors used by uniforms for this shader.
+**
+** INPUT:
+**
+** gcSHADER Shader
+** Pointer to a gcSHADER object.
+**
+** OUTPUT:
+**
+** gctSIZE_T * Count
+** Pointer to a variable receiving the number of vectors.
+*/
+gceSTATUS
+gcSHADER_GetUniformVectorCount(
+ IN gcSHADER Shader,
+ OUT gctSIZE_T * Count
+ );
+
/*******************************************************************************
** gcOptimizer Data Structures
*******************************************************************************/
/* Create native fence and return its fd. */
gcvHAL_CREATE_NATIVE_FENCE,
+
+ /* Video memory database */
+ gcvHAL_VIDMEM_DATABASE,
}
gceHAL_COMMAND_CODES;
}
Database;
+ /* gcvHAL_VIDMEM_DATABASE */
+ struct _gcsHAL_VIDMEM_DATABASE
+ {
+ /* Set to gcvTRUE if you want to query a particular process ID.
+ ** Set to gcvFALSE to query the last detached process. */
+ IN gctBOOL validProcessID;
+
+ /* Process ID to query. */
+ IN gctUINT32 processID;
+
+ /* Information. */
+ OUT gcuDATABASE_INFO vidMemResv;
+ OUT gcuDATABASE_INFO vidMemCont;
+ OUT gcuDATABASE_INFO vidMemVirt;
+ }
+ VidMemDatabase;
+
/* gcvHAL_VERSION */
struct _gcsHAL_VERSION
{
*
*****************************************************************************/
-
#ifndef __gc_hal_eglplatform_h_
#define __gc_hal_eglplatform_h_
#elif defined(LINUX) && defined(EGL_API_DFB) && !defined(__APPLE__)
#include <directfb.h>
typedef struct _DFBDisplay * HALNativeDisplayType;
-typedef IDirectFBWindow * HALNativeWindowType;
+typedef struct _DFBWindow * HALNativeWindowType;
typedef struct _DFBPixmap * HALNativePixmapType;
#elif defined(LINUX) && defined(EGL_API_FB) && !defined(__APPLE__)
gcePATCH_CHORME,
gcePATCH_DUOKANTV,
gcePATCH_TESTAPP,
+ gcePATCH_GOOGLEEARTH,
/* Count enum*/
gcePATCH_COUNT,
PhysBaseAddr, PhysSize, Signal);
/* Allocate device structure. */
- device = kmalloc(sizeof(struct _gckGALDEVICE), GFP_KERNEL | __GFP_NOWARN);
+ device = kmalloc(sizeof(struct _gckGALDEVICE), GFP_KERNEL);
if (!device)
{
*
*****************************************************************************/
-
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/notifier.h>
return gcvNULL;
}
- mdlMap->pid = ProcessID;
- mdlMap->vmaAddr = gcvNULL;
- mdlMap->vma = gcvNULL;
- mdlMap->reference = 0;
+ mdlMap->pid = ProcessID;
+ mdlMap->vmaAddr = gcvNULL;
+ mdlMap->vma = gcvNULL;
+ mdlMap->count = 0;
mdlMap->next = Mdl->maps;
Mdl->maps = mdlMap;
up_write(¤t->mm->mmap_sem);
}
-#if 0
- else
- {
- /* mdlMap->vmaAddr != gcvNULL means current process has already locked this node. */
- MEMORY_UNLOCK(Os);
-
- gcmkFOOTER_ARG("*status=%d, mdlMap->vmaAddr=%x", gcvSTATUS_MEMORY_LOCKED, mdlMap->vmaAddr);
- return gcvSTATUS_MEMORY_LOCKED;
- }
-#endif
+ mdlMap->count++;
/* Convert pointer to MDL. */
*Logical = mdlMap->vmaAddr;
*PageCount = mdl->numPages * (PAGE_SIZE / 4096);
- /* Increase reference count. */
- mdlMap->reference++;
-
MEMORY_UNLOCK(Os);
gcmkVERIFY_OK(gckOS_CacheFlush(
{
if ((mdlMap->vmaAddr != gcvNULL) && (_GetProcessID() == mdlMap->pid))
{
- if (--mdlMap->reference > 0)
+ if (--mdlMap->count == 0)
{
- continue;
+ _UnmapUserLogical(mdlMap->pid, mdlMap->vmaAddr, mdl->numPages * PAGE_SIZE);
+ mdlMap->vmaAddr = gcvNULL;
}
-
- _UnmapUserLogical(mdlMap->pid, mdlMap->vmaAddr, mdl->numPages * PAGE_SIZE);
- mdlMap->vmaAddr = gcvNULL;
}
mdlMap = mdlMap->next;
if (unlikely(delayed_work_pending(&timer->work)))
{
- cancel_delayed_work(&timer->work);
+ if (unlikely(!cancel_delayed_work(&timer->work)))
+ {
+ cancel_work_sync(&timer->work.work);
+
+ if (unlikely(delayed_work_pending(&timer->work)))
+ {
+ gckOS_Print("gckOS_StartTimer error, the pending worker cannot complete!!!! \n");
+
+ return gcvSTATUS_INVALID_REQUEST;
+ }
+ }
}
queue_delayed_work(Os->workqueue, &timer->work, msecs_to_jiffies(Delay));
{
gctINT pid;
gctPOINTER vmaAddr;
+ gctUINT32 count;
struct vm_area_struct * vma;
- gctINT reference;
struct _LINUX_MDL_MAP * next;
}
LINUX_MDL_MAP;
projects / karo-tx-linux.git / commitdiff