/*******************************************************************************
**
** gckVIDMEM_Destroy
**
** Destroy an gckVIDMEM object.
**
** INPUT:
**
** gckVIDMEM Memory
** Pointer to an gckVIDMEM object to destroy.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckVIDMEM_Destroy(
IN gckVIDMEM Memory
)
{
gcuVIDMEM_NODE_PTR node, next;
gctINT i;
gcmkHEADER_ARG("Memory=0x%x", Memory);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Memory, gcvOBJ_VIDMEM);
/* Walk all sentinels. */
for (i = 0; i < gcmCOUNTOF(Memory->sentinel); ++i)
{
/* Bail out of the heap is not used. */
if (Memory->sentinel[i].VidMem.next == gcvNULL)
{
break;
}
/* Walk all the nodes until we reach the sentinel. */
for (node = Memory->sentinel[i].VidMem.next;
node->VidMem.bytes != 0;
node = next)
{
/* Save pointer to the next node. */
next = node->VidMem.next;
/* Free the node. */
gcmkVERIFY_OK(gckOS_Free(Memory->os, node));
}
}
/* Free the mutex. */
gcmkVERIFY_OK(gckOS_DeleteMutex(Memory->os, Memory->mutex));
/* Mark the object as unknown. */
Memory->object.type = gcvOBJ_UNKNOWN;
/* Free the gckVIDMEM object. */
gcmkVERIFY_OK(gckOS_Free(Memory->os, Memory));
/* Success. */
gcmkFOOTER_NO();
return gcvSTATUS_OK;
}
gceSTATUS
gckKERNEL_DumpProcessDB(
IN gckKERNEL Kernel
)
{
gcsDATABASE_PTR database;
gctINT i, pid;
gctUINT8 name[24];
gcmkHEADER_ARG("Kernel=0x%x", Kernel);
/* Acquire the database mutex. */
gcmkVERIFY_OK(
gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
gcmkPRINT("**************************\n");
gcmkPRINT("*** PROCESS DB DUMP ***\n");
gcmkPRINT("**************************\n");
gcmkPRINT_N(8, "%-8s%s\n", "PID", "NAME");
/* Walk the databases. */
for (i = 0; i < gcmCOUNTOF(Kernel->db->db); ++i)
{
for (database = Kernel->db->db[i];
database != gcvNULL;
database = database->next)
{
pid = database->processID;
gcmkVERIFY_OK(gckOS_ZeroMemory(name, gcmSIZEOF(name)));
gcmkVERIFY_OK(gckOS_GetProcessNameByPid(pid, gcmSIZEOF(name), name));
gcmkPRINT_N(8, "%-8d%s\n", pid, name);
}
}
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Success. */
gcmkFOOTER_NO();
return gcvSTATUS_OK;
}
static gceSTATUS
gcoBUFFER_FreeObjects(
IN gcoBUFFER Buffer
)
{
gceSTATUS status;
gctUINT i;
gcmHEADER_ARG("Buffer=0x%x", Buffer);
/* Roll back all command buffers. */
for (i = 0; i < gcmCOUNTOF(Buffer->commandBuffers); i += 1)
{
if (Buffer->commandBuffers[i] != gcvNULL)
{
/* Destroy command buffer. */
gcmONERROR(gcoCMDBUF_Destroy(Buffer->commandBuffers[i]));
Buffer->commandBuffers[i] = gcvNULL;
}
if (Buffer->signal[i] != gcvNULL)
{
/* Destroy signal. */
gcmONERROR(gcoOS_DestroySignal(gcvNULL, Buffer->signal[i]));
Buffer->signal[i] = gcvNULL;
}
}
/* Free the object memory. */
gcmONERROR(gcmOS_SAFE_FREE(gcvNULL, Buffer));
/* Success. */
gcmFOOTER();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gcoBUFFER_Construct
**
** Construct a new gcoBUFFER object.
**
** INPUT:
**
** gcoHAL Hal
** Pointer to a gcoHAL object.
**
** gcoHARDWARE Hardware
** Pointer to a gcoHARDWARE object.
**
** gckCONTEXT Context
** Pointer to a gckCONTEXT object.
**
** gctSIZE_T MaxSize
** Maximum size of buffer.
**
** OUTPUT:
**
** gcoBUFFER * Buffer
** Pointer to a variable that will hold the the gcoBUFFER object
** pointer.
*/
gceSTATUS
gcoBUFFER_Construct(
IN gcoHAL Hal,
IN gcoHARDWARE Hardware,
IN gckCONTEXT Context,
IN gctSIZE_T MaxSize,
OUT gcoBUFFER * Buffer
)
{
gceSTATUS status;
gcoBUFFER buffer = gcvNULL;
gctUINT i = 0;
gctPOINTER pointer = gcvNULL;
gcmHEADER_ARG("Hal=0x%x Hardware=0x%x Context=0x%x MaxSize=%lu",
Hal, Hardware, Context, MaxSize);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Hal, gcvOBJ_HAL);
gcmVERIFY_OBJECT(Hardware, gcvOBJ_HARDWARE);
gcmDEBUG_VERIFY_ARGUMENT(Buffer != gcvNULL);
/***************************************************************************
** Allocate and reset the gcoBUFFER object.
*/
gcmONERROR(gcoOS_Allocate(
gcvNULL, gcmSIZEOF(struct _gcoBUFFER), &pointer
));
buffer = pointer;
/* Initialize the gcoBUFFER object. */
buffer->object.type = gcvOBJ_BUFFER;
buffer->hal = Hal;
buffer->context = Context;
/* Maximum size of buffer. */
buffer->size = 0;
buffer->maxSize = MaxSize;
/* Zero the command buffers. */
for (i = 0; i < gcmCOUNTOF(buffer->commandBuffers); ++i)
{
buffer->commandBuffers[i] = gcvNULL;
buffer->signal[i] = gcvNULL;
}
/***************************************************************************
** Query alignment.
*/
gcmONERROR(gcoHARDWARE_QueryCommandBuffer(
&buffer->info.alignment,
&buffer->info.reservedHead,
&buffer->info.reservedTail
));
buffer->totalReserved
= buffer->info.reservedHead
+ buffer->info.reservedTail
+ buffer->info.alignment;
/***************************************************************************
** Initialize the command buffers.
*/
for (i = 0; i < gcdCMD_BUFFERS; ++i)
{
/* Construct a command buffer. */
gcmONERROR(gcoCMDBUF_Construct(
gcvNULL,
gcvNULL,
buffer->maxSize,
&buffer->info,
&buffer->commandBuffers[i]
));
/* Create the signal. */
gcmONERROR(gcoOS_CreateSignal(
gcvNULL, gcvFALSE, &buffer->signal[i]
));
gcmTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_SIGNAL,
"%s(%d): buffer %d signal created 0x%08X",
__FUNCTION__, __LINE__,
i, buffer->signal[i]
);
/* Mark the buffer as available. */
gcmONERROR(gcoOS_Signal(
gcvNULL, buffer->signal[i], gcvTRUE\
));
}
/* Number of buffers initialized. */
buffer->count = gcdCMD_BUFFERS;
/* Grab the first command buffer. */
buffer->currentCommandBuffer = gcvNULL;
gcmONERROR(gcoBUFFER_GetCMDBUF(buffer));
/* Return pointer to the gcoBUFFER object. */
*Buffer = buffer;
/* Success. */
gcmFOOTER_ARG("*Buffer=0x%x", *Buffer);
return gcvSTATUS_OK;
OnError:
if (buffer != gcvNULL)
{
gcmVERIFY_OK(gcoBUFFER_FreeObjects(buffer));
}
/* Return the status. */
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gckVIDMEM_AllocateLinear
**
** Allocate linear memory from the gckVIDMEM object.
**
** INPUT:
**
** gckVIDMEM Memory
** Pointer to an gckVIDMEM object.
**
** gctSIZE_T Bytes
** Number of bytes to allocate.
**
** gctUINT32 Alignment
** Byte alignment for allocation.
**
** gceSURF_TYPE Type
** Type of surface to allocate (use by bank optimization).
**
** OUTPUT:
**
** gcuVIDMEM_NODE_PTR * Node
** Pointer to a variable that will hold the allocated memory node.
*/
gceSTATUS
gckVIDMEM_AllocateLinear(
IN gckVIDMEM Memory,
IN gctSIZE_T Bytes,
IN gctUINT32 Alignment,
IN gceSURF_TYPE Type,
#ifdef __QNXNTO__
IN gctHANDLE Handle,
#endif
OUT gcuVIDMEM_NODE_PTR * Node
)
{
gceSTATUS status;
gcuVIDMEM_NODE_PTR node;
gctUINT32 alignment;
gctINT bank, i;
gctBOOL acquired = gcvFALSE;
gcmkHEADER_ARG("Memory=0x%x Bytes=%lu Alignment=%u Type=%d",
Memory, Bytes, Alignment, Type);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Memory, gcvOBJ_VIDMEM);
gcmkVERIFY_ARGUMENT(Bytes > 0);
gcmkVERIFY_ARGUMENT(Node != gcvNULL);
#ifdef __QNXNTO__
gcmkVERIFY_ARGUMENT(Handle != gcvNULL);
#endif
/* Acquire the mutex. */
gcmkONERROR(
gckOS_AcquireMutex(Memory->os, Memory->mutex, gcvINFINITE));
acquired = gcvTRUE;
if (Bytes > Memory->freeBytes)
{
/* Not enough memory. */
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
/* Find the default bank for this surface type. */
gcmkASSERT((gctINT) Type < gcmCOUNTOF(Memory->mapping));
bank = Memory->mapping[Type];
alignment = Alignment;
/* Find a free node in the default bank. */
node = _FindNode(Memory, bank, Bytes, &alignment);
/* Out of memory? */
if (node == gcvNULL)
{
/* Walk all lower banks. */
for (i = bank - 1; i >= 0; --i)
{
/* Find a free node inside the current bank. */
node = _FindNode(Memory, i, Bytes, &alignment);
if (node != gcvNULL)
{
break;
}
}
}
if (node == gcvNULL)
{
/* Walk all upper banks. */
for (i = bank + 1; i < gcmCOUNTOF(Memory->sentinel); ++i)
{
if (Memory->sentinel[i].VidMem.nextFree == gcvNULL)
{
/* Abort when we reach unused banks. */
break;
}
/* Find a free node inside the current bank. */
node = _FindNode(Memory, i, Bytes, &alignment);
if (node != gcvNULL)
{
break;
}
}
}
if (node == gcvNULL)
{
/* Out of memory. */
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
/* Do we have an alignment? */
if (alignment > 0)
{
/* Split the node so it is aligned. */
if (_Split(Memory->os, node, alignment))
{
/* Successful split, move to aligned node. */
node = node->VidMem.next;
/* Remove alignment. */
alignment = 0;
}
}
/* Do we have enough memory after the allocation to split it? */
if (node->VidMem.bytes - Bytes > Memory->threshold)
{
/* Adjust the node size. */
_Split(Memory->os, node, Bytes);
}
/* Remove the node from the free list. */
node->VidMem.prevFree->VidMem.nextFree = node->VidMem.nextFree;
node->VidMem.nextFree->VidMem.prevFree = node->VidMem.prevFree;
node->VidMem.nextFree =
node->VidMem.prevFree = gcvNULL;
/* Fill in the information. */
node->VidMem.alignment = alignment;
node->VidMem.memory = Memory;
#ifdef __QNXNTO__
node->VidMem.logical = gcvNULL;
node->VidMem.handle = Handle;
#endif
/* Adjust the number of free bytes. */
Memory->freeBytes -= node->VidMem.bytes;
/* Release the mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Memory->os, Memory->mutex));
/* Return the pointer to the node. */
*Node = node;
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"Allocated %u bytes @ 0x%x [0x%08X]",
node->VidMem.bytes, node, node->VidMem.offset);
/* Success. */
gcmkFOOTER_ARG("*Node=0x%x", *Node);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Memory->os, Memory->mutex));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** gckVIDMEM_Construct
**
** Construct a new gckVIDMEM object.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** gctUINT32 BaseAddress
** Base address for the video memory heap.
**
** gctSIZE_T Bytes
** Number of bytes in the video memory heap.
**
** gctSIZE_T Threshold
** Minimum number of bytes beyond am allocation before the node is
** split. Can be used as a minimum alignment requirement.
**
** gctSIZE_T BankSize
** Number of bytes per physical memory bank. Used by bank
** optimization.
**
** OUTPUT:
**
** gckVIDMEM * Memory
** Pointer to a variable that will hold the pointer to the gckVIDMEM
** object.
*/
gceSTATUS
gckVIDMEM_Construct(
IN gckOS Os,
IN gctUINT32 BaseAddress,
IN gctSIZE_T Bytes,
IN gctSIZE_T Threshold,
IN gctSIZE_T BankSize,
OUT gckVIDMEM * Memory
)
{
gckVIDMEM memory = gcvNULL;
gceSTATUS status;
gcuVIDMEM_NODE_PTR node;
gctINT i, banks = 0;
gcmkHEADER_ARG("Os=0x%x BaseAddress=%08x Bytes=%lu Threshold=%lu "
"BankSize=%lu",
Os, BaseAddress, Bytes, Threshold, BankSize);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Os, gcvOBJ_OS);
gcmkVERIFY_ARGUMENT(Bytes > 0);
gcmkVERIFY_ARGUMENT(Memory != gcvNULL);
/* Allocate the gckVIDMEM object. */
gcmkONERROR(
gckOS_Allocate(Os,
gcmSIZEOF(struct _gckVIDMEM),
(gctPOINTER *) &memory));
/* Initialize the gckVIDMEM object. */
memory->object.type = gcvOBJ_VIDMEM;
memory->os = Os;
/* Set video memory heap information. */
memory->baseAddress = BaseAddress;
memory->bytes = Bytes;
memory->freeBytes = Bytes;
memory->threshold = Threshold;
memory->mutex = gcvNULL;
BaseAddress = 0;
/* Walk all possible banks. */
for (i = 0; i < gcmCOUNTOF(memory->sentinel); ++i)
{
gctSIZE_T bytes;
if (BankSize == 0)
{
/* Use all bytes for the first bank. */
bytes = Bytes;
}
else
{
/* Compute number of bytes for this bank. */
bytes = gcmALIGN(BaseAddress + 1, BankSize) - BaseAddress;
if (bytes > Bytes)
{
/* Make sure we don't exceed the total number of bytes. */
bytes = Bytes;
}
}
if (bytes == 0)
{
/* Mark heap is not used. */
memory->sentinel[i].VidMem.next =
memory->sentinel[i].VidMem.prev =
memory->sentinel[i].VidMem.nextFree =
memory->sentinel[i].VidMem.prevFree = gcvNULL;
continue;
}
/* Allocate one gcuVIDMEM_NODE union. */
gcmkONERROR(
gckOS_Allocate(Os,
gcmSIZEOF(gcuVIDMEM_NODE),
(gctPOINTER *) &node));
/* Initialize gcuVIDMEM_NODE union. */
node->VidMem.memory = memory;
node->VidMem.next =
node->VidMem.prev =
node->VidMem.nextFree =
node->VidMem.prevFree = &memory->sentinel[i];
node->VidMem.offset = BaseAddress;
node->VidMem.bytes = bytes;
node->VidMem.alignment = 0;
node->VidMem.physical = 0;
node->VidMem.pool = gcvPOOL_UNKNOWN;
node->VidMem.locked = 0;
#ifdef __QNXNTO__
node->VidMem.logical = gcvNULL;
node->VidMem.handle = 0;
#endif
/* Initialize the linked list of nodes. */
memory->sentinel[i].VidMem.next =
memory->sentinel[i].VidMem.prev =
memory->sentinel[i].VidMem.nextFree =
memory->sentinel[i].VidMem.prevFree = node;
/* Mark sentinel. */
memory->sentinel[i].VidMem.bytes = 0;
/* Adjust address for next bank. */
BaseAddress += bytes;
Bytes -= bytes;
banks ++;
}
/* Assign all the bank mappings. */
memory->mapping[gcvSURF_RENDER_TARGET] = banks - 1;
memory->mapping[gcvSURF_BITMAP] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_DEPTH] = banks - 1;
memory->mapping[gcvSURF_HIERARCHICAL_DEPTH] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_TEXTURE] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_VERTEX] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_INDEX] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_TILE_STATUS] = banks - 1;
if (banks > 1) --banks;
memory->mapping[gcvSURF_TYPE_UNKNOWN] = 0;
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] INDEX: bank %d",
memory->mapping[gcvSURF_INDEX]);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] VERTEX: bank %d",
memory->mapping[gcvSURF_VERTEX]);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] TEXTURE: bank %d",
memory->mapping[gcvSURF_TEXTURE]);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] RENDER_TARGET: bank %d",
memory->mapping[gcvSURF_RENDER_TARGET]);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] DEPTH: bank %d",
memory->mapping[gcvSURF_DEPTH]);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"[GALCORE] TILE_STATUS: bank %d",
memory->mapping[gcvSURF_TILE_STATUS]);
/* Allocate the mutex. */
gcmkONERROR(gckOS_CreateMutex(Os, &memory->mutex));
/* Return pointer to the gckVIDMEM object. */
*Memory = memory;
/* Success. */
gcmkFOOTER_ARG("*Memory=0x%x", *Memory);
return gcvSTATUS_OK;
OnError:
/* Roll back. */
if (memory != gcvNULL)
{
if (memory->mutex != gcvNULL)
{
/* Delete the mutex. */
gcmkVERIFY_OK(gckOS_DeleteMutex(Os, memory->mutex));
}
for (i = 0; i < banks; ++i)
{
/* Free the heap. */
gcmkASSERT(memory->sentinel[i].VidMem.next != gcvNULL);
gcmkVERIFY_OK(gckOS_Free(Os, memory->sentinel[i].VidMem.next));
}
/* Free the object. */
gcmkVERIFY_OK(gckOS_Free(Os, memory));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** 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;
}
gceSTATUS
gckKERNEL_MapLogicalToPhysical(
IN gckKERNEL Kernel,
IN gctHANDLE Process,
IN OUT gctPOINTER * Data
)
{
gctUINT i, oldest;
gceSTATUS status;
gctUINT32 baseAddress;
gcmkHEADER_ARG("Kernel=0x%x Process=0x%x *Data=0x%x",
Kernel, Process, gcmOPT_POINTER(Data));
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
gcmkVERIFY_ARGUMENT(Data != gcvNULL);
/* Get base address. */
gcmkONERROR(gckHARDWARE_GetBaseAddress(Kernel->hardware, &baseAddress));
/* Walk all used cache slots. */
for (i = oldest = 0; i < Kernel->cacheSlots; ++i)
{
if ((Kernel->cache[i].logical == *Data)
&& (Kernel->cache[i].process == Process)
)
{
/* Bail out. */
break;
}
if (i == 0)
{
/* First slot. */
oldest = i;
}
/* Test if this cache slot is older. */
else if (Kernel->cache[i].stamp < Kernel->cache[oldest].stamp)
{
oldest = i;
}
}
/* See if we had a match. */
if (i == Kernel->cacheSlots)
{
/* See if there is room in the cache. */
if (i < gcmCOUNTOF(Kernel->cache))
{
/* Just append to the cache. */
i = Kernel->cacheSlots++;
}
else
{
/* Evict the oldest cache line. */
i = oldest;
}
/* Initialize the cache line. */
Kernel->cache[i].logical = *Data;
Kernel->cache[i].process = Process;
/* Map the logical address to a DMA address. */
gcmkONERROR(gckOS_GetPhysicalAddress(Kernel->os,
*Data,
&Kernel->cache[i].dma));
if (baseAddress != 0)
{
gctBOOL needBase;
/* Does this state load need a base address? */
gcmkONERROR(gckHARDWARE_NeedBaseAddress(Kernel->hardware,
((gctUINT32_PTR) Data)[-1],
&needBase));
if (needBase)
{
/* Add the base address. */
Kernel->cache[i].dma += baseAddress;
}
}
}
/* Increment time stamp of the cache slot. */
Kernel->cache[i].stamp = Kernel->cacheTimeStamp++;
/* Return DMA address. */
*Data = gcmINT2PTR(Kernel->cache[i].dma);
/* Success. */
gcmkFOOTER_ARG("*Data=0x%08x", *Data);
return gcvSTATUS_OK;
OnError:
gcmkLOG_ERROR_STATUS();
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_CreateProcessDB
**
** Create a new process database.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gctUINT32 ProcessID
** Process ID used to identify the database.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gckKERNEL_CreateProcessDB(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID
)
{
gceSTATUS status;
gcsDATABASE_PTR database = gcvNULL;
gctUINT32 i;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d", Kernel, ProcessID);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
/* Create a new database. */
gcmkONERROR(gckKERNEL_NewDatabase(Kernel, ProcessID, &database));
/* Initialize the database. */
database->processID = ProcessID;
database->vidMem.bytes = 0;
database->vidMem.maxBytes = 0;
database->vidMem.totalBytes = 0;
database->nonPaged.bytes = 0;
database->nonPaged.maxBytes = 0;
database->nonPaged.totalBytes = 0;
database->contiguous.bytes = 0;
database->contiguous.maxBytes = 0;
database->contiguous.totalBytes = 0;
database->mapMemory.bytes = 0;
database->mapMemory.maxBytes = 0;
database->mapMemory.totalBytes = 0;
database->mapUserMemory.bytes = 0;
database->mapUserMemory.maxBytes = 0;
database->mapUserMemory.totalBytes = 0;
for (i = 0; i < gcmCOUNTOF(database->list); i++)
{
database->list[i] = gcvNULL;
}
#if gcdSECURE_USER
{
gctINT slot;
gcskSECURE_CACHE * cache = &database->cache;
/* Setup the linked list of cache nodes. */
for (slot = 1; slot <= gcdSECURE_CACHE_SLOTS; ++slot)
{
cache->cache[slot].logical = gcvNULL;
#if gcdSECURE_CACHE_METHOD != gcdSECURE_CACHE_TABLE
cache->cache[slot].prev = &cache->cache[slot - 1];
cache->cache[slot].next = &cache->cache[slot + 1];
# endif
#if gcdSECURE_CACHE_METHOD == gcdSECURE_CACHE_HASH
cache->cache[slot].nextHash = gcvNULL;
cache->cache[slot].prevHash = gcvNULL;
# endif
}
#if gcdSECURE_CACHE_METHOD != gcdSECURE_CACHE_TABLE
/* Setup the head and tail of the cache. */
cache->cache[0].next = &cache->cache[1];
cache->cache[0].prev = &cache->cache[gcdSECURE_CACHE_SLOTS];
cache->cache[0].logical = gcvNULL;
/* Fix up the head and tail pointers. */
cache->cache[0].next->prev = &cache->cache[0];
cache->cache[0].prev->next = &cache->cache[0];
# endif
#if gcdSECURE_CACHE_METHOD == gcdSECURE_CACHE_HASH
/* Zero out the hash table. */
for (slot = 0; slot < gcmCOUNTOF(cache->hash); ++slot)
{
cache->hash[slot].logical = gcvNULL;
cache->hash[slot].nextHash = gcvNULL;
}
# endif
/* Initialize cache index. */
cache->cacheIndex = gcvNULL;
cache->cacheFree = 1;
cache->cacheStamp = 0;
}
#endif
/* Reset idle timer. */
Kernel->db->lastIdle = 0;
/* Success. */
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_NewDatabase
**
** Create a new database structure and insert it to the head of the hash list.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gctUINT32 ProcessID
** ProcessID that identifies the database.
**
** OUTPUT:
**
** gcsDATABASE_PTR * Database
** Pointer to a variable receiving the database structure pointer on
** success.
*/
static gceSTATUS
gckKERNEL_NewDatabase(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
OUT gcsDATABASE_PTR * Database
)
{
gceSTATUS status;
gcsDATABASE_PTR database;
gctBOOL acquired = gcvFALSE;
gctSIZE_T slot;
gcsDATABASE_PTR existingDatabase;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d", Kernel, ProcessID);
/* Acquire the database mutex. */
gcmkONERROR(gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
/* Compute the hash for the database. */
slot = ProcessID % gcmCOUNTOF(Kernel->db->db);
/* Walk the hash list. */
for (existingDatabase = Kernel->db->db[slot];
existingDatabase != gcvNULL;
existingDatabase = existingDatabase->next)
{
if (existingDatabase->processID == ProcessID)
{
/* One process can't be added twice. */
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
}
if (Kernel->db->freeDatabase != gcvNULL)
{
/* Allocate a database from the free list. */
database = Kernel->db->freeDatabase;
Kernel->db->freeDatabase = database->next;
}
else
{
gctPOINTER pointer = gcvNULL;
/* Allocate a new database from the heap. */
gcmkONERROR(gckOS_Allocate(Kernel->os,
gcmSIZEOF(gcsDATABASE),
&pointer));
database = pointer;
}
/* Insert the database into the hash. */
database->next = Kernel->db->db[slot];
Kernel->db->db[slot] = database;
/* Save the hash slot. */
database->slot = slot;
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Return the database. */
*Database = database;
/* Success. */
gcmkFOOTER_ARG("*Database=0x%x", *Database);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_DeleteDatabase
**
** Remove a database from the hash list and delete its structure.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gcsDATABASE_PTR Database
** Pointer to the database structure to remove.
**
** OUTPUT:
**
** Nothing.
*/
static gceSTATUS
gckKERNEL_DeleteDatabase(
IN gckKERNEL Kernel,
IN gcsDATABASE_PTR Database
)
{
gceSTATUS status;
gctBOOL acquired = gcvFALSE;
gcsDATABASE_PTR database;
gcmkHEADER_ARG("Kernel=0x%x Database=0x%x", Kernel, Database);
/* Acquire the database mutex. */
gcmkONERROR(
gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
/* Check slot value. */
gcmkVERIFY_ARGUMENT(Database->slot < gcmCOUNTOF(Kernel->db->db));
if (Database->slot < gcmCOUNTOF(Kernel->db->db))
{
/* Check if database if the head of the hash list. */
if (Kernel->db->db[Database->slot] == Database)
{
/* Remove the database from the hash list. */
Kernel->db->db[Database->slot] = Database->next;
}
else
{
/* Walk the has list to find the database. */
for (database = Kernel->db->db[Database->slot];
database != gcvNULL;
database = database->next
)
{
/* Check if the next list entry is this database. */
if (database->next == Database)
{
/* Remove the database from the hash list. */
database->next = Database->next;
break;
}
}
if (database == gcvNULL)
{
/* Ouch! Something got corrupted. */
gcmkONERROR(gcvSTATUS_INVALID_DATA);
}
}
}
if (Kernel->db->lastDatabase != gcvNULL)
{
/* Insert database to the free list. */
Kernel->db->lastDatabase->next = Kernel->db->freeDatabase;
Kernel->db->freeDatabase = Kernel->db->lastDatabase;
}
/* Keep database as the last database. */
Kernel->db->lastDatabase = Database;
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Success. */
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_FindDatabase
**
** Find a database identified by a process ID and move it to the head of the
** hash list.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gctUINT32 ProcessID
** ProcessID that identifies the database.
**
** gctBOOL LastProcessID
** gcvTRUE if searching for the last known process ID. gcvFALSE if
** we need to search for the process ID specified by the ProcessID
** argument.
**
** OUTPUT:
**
** gcsDATABASE_PTR * Database
** Pointer to a variable receiving the database structure pointer on
** success.
*/
static gceSTATUS
gckKERNEL_FindDatabase(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
IN gctBOOL LastProcessID,
OUT gcsDATABASE_PTR * Database
)
{
gceSTATUS status;
gcsDATABASE_PTR database, previous;
gctSIZE_T slot;
gctBOOL acquired = gcvFALSE;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d LastProcessID=%d",
Kernel, ProcessID, LastProcessID);
/* Compute the hash for the database. */
slot = ProcessID % gcmCOUNTOF(Kernel->db->db);
/* Acquire the database mutex. */
gcmkONERROR(
gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
/* Check whether we are getting the last known database. */
if (LastProcessID)
{
/* Use last database. */
database = Kernel->db->lastDatabase;
if (database == gcvNULL)
{
/* Database not found. */
gcmkONERROR(gcvSTATUS_INVALID_DATA);
}
}
else
{
/* Walk the hash list. */
for (previous = gcvNULL, database = Kernel->db->db[slot];
database != gcvNULL;
database = database->next)
{
if (database->processID == ProcessID)
{
/* Found it! */
break;
}
previous = database;
}
if (database == gcvNULL)
{
/* Database not found. */
gcmkONERROR(gcvSTATUS_INVALID_DATA);
}
if (previous != gcvNULL)
{
/* Move database to the head of the hash list. */
previous->next = database->next;
database->next = Kernel->db->db[slot];
Kernel->db->db[slot] = database;
}
}
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Return the database. */
*Database = database;
/* Success. */
gcmkFOOTER_ARG("*Database=0x%x", *Database);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
/* Return the status. */
gcmkFOOTER();
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;
}
static gceSTATUS _ReferenceObjectCache(
vgsCONTEXT_PTR Context,
vgsOBJECT_CACHE_PTR * ObjectCache
)
{
gceSTATUS status, last;
vgsOBJECT_CACHE_PTR objectCache = gcvNULL;
do
{
/* Has the object cache been created? */
if (*ObjectCache == gcvNULL)
{
static vgtSET_OBJECT_LIST initList[] =
{
vgfSetPathObjectList,
vgfSetImageObjectList,
vgfSetMaskObjectList,
vgfSetFontObjectList,
vgfSetPaintObjectList
};
gctUINT i;
/* Allocate the context structure. */
gcmERR_BREAK(gcoOS_Allocate(
Context->os,
gcmSIZEOF(vgsOBJECT_CACHE),
(gctPOINTER *) &objectCache
));
gcmERR_BREAK(gcoOS_ZeroMemory(
objectCache,
gcmSIZEOF(vgsOBJECT_CACHE)));
/* Initialize the object. */
objectCache->loHandle = ~0;
objectCache->hiHandle = 0;
objectCache->referenceCount = 0;
/* Initialize object arrays. */
for (i = 0; i < gcmCOUNTOF(initList); i++)
{
initList[i] (&objectCache->cache[i]);
}
/* Set the result pointer. */
*ObjectCache = objectCache;
}
/* Increment the counter. */
(*ObjectCache)->referenceCount++;
/* Success. */
return gcvSTATUS_OK;
}
while (gcvFALSE);
/* Roll back. */
if (objectCache != gcvNULL)
{
gcmCHECK_STATUS(gcoOS_Free(Context->os, objectCache));
}
/* Return status. */
return status;
}
static ssize_t store_dutycycle (struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
#if MRVL_PULSE_EATER_COUNT_NUM
if(has_feat_pulse_eater_profiler())
{
gctBOOL start;
gctUINT core;
gctUINT32 busyRatio[4], totalTime[4], timeGap = 0;
gcePulseEaterDomain domain = gcvPulse_Core;
gceSTATUS status = gcvSTATUS_OK;
SYSFS_VERIFY_INPUT(sscanf(buf, "%d %d", &start, &core), 2);
SYSFS_VERIFY_INPUT_RANGE(start, 0, 1);
#if gcdENABLE_VG
SYSFS_VERIFY_INPUT_RANGE(core, 0, 2);
#else
SYSFS_VERIFY_INPUT_RANGE(core, 0, 1);
#endif
for(; domain < 2; domain++)
{
status = gckKERNEL_QueryPulseEaterIdleProfile(galDevice->kernels[core],
start,
domain,
busyRatio,
&timeGap,
totalTime);
if(!start && !status)
{
gctINT i = 0;
gcmkPRINT("\n|Domain: %6s totalTime: %8d|", domain ==0 ?"Core":"Shader" ,timeGap);
gcmkPRINT("|Freq RunTime| BusyRatio| DutyCycle|\n");
for(; i < gcmCOUNTOF(busyRatio); i++)
{
gcmkPRINT("|%dM %6u| %8u| %8d%%|\n", i==2?416: 156*(i+1),
totalTime[i],
busyRatio[i],
totalTime[i]==0?0: ((100*((gctINT)busyRatio[i]))/(gctINT)totalTime[i]));
}
}
else if(status)
{
switch(status)
{
case gcvSTATUS_INVALID_ARGUMENT:
printk("Invalidate argument: %d, cat /sys/../dutycycle for more info\n", status);
break;
case gcvSTATUS_INVALID_REQUEST:
printk("Statistics has started alreay, echo 0 x > /sys/.../dutycycle to stop it\n");
break;
default:
printk("cat /sys/../dutycycle for more info, status: %d\n", status);
}
}
}
}
else
#endif
{
printk("Oops, %s is under working\n", __func__);
}
return count;
}
