/drivers/gpu/pvr/handle.c
C | 1873 lines | 1391 code | 457 blank | 25 comment | 286 complexity | b19747385e728bc71f9a33a3ac83ecdf MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
/**********************************************************************
*
* Copyright (C) Imagination Technologies Ltd. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful but, except
* as otherwise stated in writing, without any warranty; without even the
* implied warranty of merchantability or fitness for a particular purpose.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
*
* The full GNU General Public License is included in this distribution in
* the file called "COPYING".
*
* Contact Information:
* Imagination Technologies Ltd. <gpl-support@imgtec.com>
* Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
*
******************************************************************************/
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
#include <stddef.h>
#include "services_headers.h"
#include "handle.h"
#ifdef DEBUG
#define HANDLE_BLOCK_SHIFT 2
#else
#define HANDLE_BLOCK_SHIFT 8
#endif
#define DIVIDE_BY_BLOCK_SIZE(i) (((IMG_UINT32)(i)) >> HANDLE_BLOCK_SHIFT)
#define MULTIPLY_BY_BLOCK_SIZE(i) (((IMG_UINT32)(i)) << HANDLE_BLOCK_SHIFT)
#define HANDLE_BLOCK_SIZE MULTIPLY_BY_BLOCK_SIZE(1)
#define HANDLE_SUB_BLOCK_MASK (HANDLE_BLOCK_SIZE - 1)
#define HANDLE_BLOCK_MASK (~(HANDLE_SUB_BLOCK_MASK))
#define HANDLE_HASH_TAB_INIT_SIZE 32
#define INDEX_IS_VALID(psBase, i) ((i) < (psBase)->ui32TotalHandCount)
#if defined (SUPPORT_SID_INTERFACE)
#define INDEX_TO_HANDLE(i) ((IMG_SID)((i) + 1))
#define HANDLE_TO_INDEX(h) ((IMG_UINT32)(h) - 1)
#else
#define INDEX_TO_HANDLE(i) ((IMG_HANDLE)((IMG_UINTPTR_T)(i) + 1))
#define HANDLE_TO_INDEX(h) ((IMG_UINT32)(IMG_UINTPTR_T)(h) - 1)
#endif
#define INDEX_TO_BLOCK_INDEX(i) DIVIDE_BY_BLOCK_SIZE(i)
#define BLOCK_INDEX_TO_INDEX(i) MULTIPLY_BY_BLOCK_SIZE(i)
#define INDEX_TO_SUB_BLOCK_INDEX(i) ((i) & HANDLE_SUB_BLOCK_MASK)
#define INDEX_TO_INDEX_STRUCT_PTR(psArray, i) (&((psArray)[INDEX_TO_BLOCK_INDEX(i)]))
#define BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i) INDEX_TO_INDEX_STRUCT_PTR((psBase)->psHandleArray, i)
#define INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, i) (BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i)->ui32FreeHandBlockCount)
#define INDEX_TO_HANDLE_STRUCT_PTR(psBase, i) (BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i)->psHandle + INDEX_TO_SUB_BLOCK_INDEX(i))
#define HANDLE_TO_HANDLE_STRUCT_PTR(psBase, h) (INDEX_TO_HANDLE_STRUCT_PTR(psBase, HANDLE_TO_INDEX(h)))
#define HANDLE_PTR_TO_INDEX(psHandle) ((psHandle)->ui32Index)
#define HANDLE_PTR_TO_HANDLE(psHandle) INDEX_TO_HANDLE(HANDLE_PTR_TO_INDEX(psHandle))
#define ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(a) (HANDLE_BLOCK_MASK & (a))
#define ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(a) ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE((a) + HANDLE_BLOCK_SIZE - 1)
#define DEFAULT_MAX_HANDLE 0x7fffffffu
#define DEFAULT_MAX_INDEX_PLUS_ONE ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(DEFAULT_MAX_HANDLE)
#define HANDLES_BATCHED(psBase) ((psBase)->ui32HandBatchSize != 0)
#define HANDLE_ARRAY_SIZE(handleCount) DIVIDE_BY_BLOCK_SIZE(ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(handleCount))
#define SET_FLAG(v, f) ((IMG_VOID)((v) |= (f)))
#define CLEAR_FLAG(v, f) ((IMG_VOID)((v) &= ~(f)))
#define TEST_FLAG(v, f) ((IMG_BOOL)(((v) & (f)) != 0))
#define TEST_ALLOC_FLAG(psHandle, f) TEST_FLAG((psHandle)->eFlag, f)
#define SET_INTERNAL_FLAG(psHandle, f) SET_FLAG((psHandle)->eInternalFlag, f)
#define CLEAR_INTERNAL_FLAG(psHandle, f) CLEAR_FLAG((psHandle)->eInternalFlag, f)
#define TEST_INTERNAL_FLAG(psHandle, f) TEST_FLAG((psHandle)->eInternalFlag, f)
#define BATCHED_HANDLE(psHandle) TEST_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
#define SET_BATCHED_HANDLE(psHandle) SET_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
#define SET_UNBATCHED_HANDLE(psHandle) CLEAR_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
#define BATCHED_HANDLE_PARTIALLY_FREE(psHandle) TEST_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE)
#define SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle) SET_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE)
#define HANDLE_STRUCT_IS_FREE(psHandle) ((psHandle)->eType == PVRSRV_HANDLE_TYPE_NONE && (psHandle)->eInternalFlag == INTERNAL_HANDLE_FLAG_NONE)
#ifdef MIN
#undef MIN
#endif
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
struct sHandleList
{
IMG_UINT32 ui32Prev;
IMG_UINT32 ui32Next;
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hParent;
#else
IMG_HANDLE hParent;
#endif
};
enum ePVRSRVInternalHandleFlag
{
INTERNAL_HANDLE_FLAG_NONE = 0x00,
INTERNAL_HANDLE_FLAG_BATCHED = 0x01,
INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE = 0x02,
};
struct sHandle
{
PVRSRV_HANDLE_TYPE eType;
IMG_VOID *pvData;
IMG_UINT32 ui32NextIndexPlusOne;
enum ePVRSRVInternalHandleFlag eInternalFlag;
PVRSRV_HANDLE_ALLOC_FLAG eFlag;
IMG_UINT32 ui32Index;
struct sHandleList sChildren;
struct sHandleList sSiblings;
};
struct sHandleIndex
{
struct sHandle *psHandle;
IMG_HANDLE hBlockAlloc;
IMG_UINT32 ui32FreeHandBlockCount;
};
struct _PVRSRV_HANDLE_BASE_
{
IMG_HANDLE hBaseBlockAlloc;
IMG_HANDLE hArrayBlockAlloc;
struct sHandleIndex *psHandleArray;
HASH_TABLE *psHashTab;
IMG_UINT32 ui32FreeHandCount;
IMG_UINT32 ui32FirstFreeIndex;
IMG_UINT32 ui32MaxIndexPlusOne;
IMG_UINT32 ui32TotalHandCount;
IMG_UINT32 ui32LastFreeIndexPlusOne;
IMG_UINT32 ui32HandBatchSize;
IMG_UINT32 ui32TotalHandCountPreBatch;
IMG_UINT32 ui32FirstBatchIndexPlusOne;
IMG_UINT32 ui32BatchHandAllocFailures;
IMG_BOOL bPurgingEnabled;
};
enum eHandKey {
HAND_KEY_DATA = 0,
HAND_KEY_TYPE,
HAND_KEY_PARENT,
HAND_KEY_LEN
};
PVRSRV_HANDLE_BASE *gpsKernelHandleBase = IMG_NULL;
typedef IMG_UINTPTR_T HAND_KEY[HAND_KEY_LEN];
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListInit)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
IMG_VOID HandleListInit(IMG_UINT32 ui32Index, struct sHandleList *psList, IMG_SID hParent)
#else
IMG_VOID HandleListInit(IMG_UINT32 ui32Index, struct sHandleList *psList, IMG_HANDLE hParent)
#endif
{
psList->ui32Next = ui32Index;
psList->ui32Prev = ui32Index;
psList->hParent = hParent;
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(InitParentList)
#endif
static INLINE
IMG_VOID InitParentList(struct sHandle *psHandle)
{
IMG_UINT32 ui32Parent = HANDLE_PTR_TO_INDEX(psHandle);
HandleListInit(ui32Parent, &psHandle->sChildren, INDEX_TO_HANDLE(ui32Parent));
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(InitChildEntry)
#endif
static INLINE
IMG_VOID InitChildEntry(struct sHandle *psHandle)
{
HandleListInit(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, IMG_NULL);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListIsEmpty)
#endif
static INLINE
IMG_BOOL HandleListIsEmpty(IMG_UINT32 ui32Index, struct sHandleList *psList)
{
IMG_BOOL bIsEmpty;
bIsEmpty = (IMG_BOOL)(psList->ui32Next == ui32Index);
#ifdef DEBUG
{
IMG_BOOL bIsEmpty2;
bIsEmpty2 = (IMG_BOOL)(psList->ui32Prev == ui32Index);
PVR_ASSERT(bIsEmpty == bIsEmpty2)
}
#endif
return bIsEmpty;
}
#ifdef DEBUG
#ifdef INLINE_IS_PRAGMA
#pragma inline(NoChildren)
#endif
static INLINE
IMG_BOOL NoChildren(struct sHandle *psHandle)
{
PVR_ASSERT(psHandle->sChildren.hParent == HANDLE_PTR_TO_HANDLE(psHandle))
return HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sChildren);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(NoParent)
#endif
static INLINE
IMG_BOOL NoParent(struct sHandle *psHandle)
{
if (HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings))
{
PVR_ASSERT(psHandle->sSiblings.hParent == IMG_NULL)
return IMG_TRUE;
}
else
{
PVR_ASSERT(psHandle->sSiblings.hParent != IMG_NULL)
}
return IMG_FALSE;
}
#endif
#ifdef INLINE_IS_PRAGMA
#pragma inline(ParentHandle)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID ParentHandle(struct sHandle *psHandle)
#else
IMG_HANDLE ParentHandle(struct sHandle *psHandle)
#endif
{
return psHandle->sSiblings.hParent;
}
#define LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, i, p, po, eo) \
((struct sHandleList *)((IMG_CHAR *)(INDEX_TO_HANDLE_STRUCT_PTR(psBase, i)) + (((i) == (p)) ? (po) : (eo))))
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListInsertBefore)
#endif
static INLINE
IMG_VOID HandleListInsertBefore(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32InsIndex, struct sHandleList *psIns, IMG_SIZE_T uiParentOffset, IMG_UINT32 ui32EntryIndex, struct sHandleList *psEntry, IMG_SIZE_T uiEntryOffset, IMG_UINT32 ui32ParentIndex)
{
struct sHandleList *psPrevIns = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psIns->ui32Prev, ui32ParentIndex, uiParentOffset, uiEntryOffset);
PVR_ASSERT(psEntry->hParent == IMG_NULL)
PVR_ASSERT(ui32InsIndex == psPrevIns->ui32Next)
PVR_ASSERT(LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32ParentIndex, ui32ParentIndex, uiParentOffset, uiParentOffset)->hParent == INDEX_TO_HANDLE(ui32ParentIndex))
psEntry->ui32Prev = psIns->ui32Prev;
psIns->ui32Prev = ui32EntryIndex;
psEntry->ui32Next = ui32InsIndex;
psPrevIns->ui32Next = ui32EntryIndex;
psEntry->hParent = INDEX_TO_HANDLE(ui32ParentIndex);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(AdoptChild)
#endif
static INLINE
IMG_VOID AdoptChild(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, struct sHandle *psChild)
{
IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psParent->sChildren.hParent);
PVR_ASSERT(ui32Parent == HANDLE_PTR_TO_INDEX(psParent))
HandleListInsertBefore(psBase, ui32Parent, &psParent->sChildren, offsetof(struct sHandle, sChildren), HANDLE_PTR_TO_INDEX(psChild), &psChild->sSiblings, offsetof(struct sHandle, sSiblings), ui32Parent);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListRemove)
#endif
static INLINE
IMG_VOID HandleListRemove(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32EntryIndex, struct sHandleList *psEntry, IMG_SIZE_T uiEntryOffset, IMG_SIZE_T uiParentOffset)
{
if (!HandleListIsEmpty(ui32EntryIndex, psEntry))
{
struct sHandleList *psPrev = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Prev, HANDLE_TO_INDEX(psEntry->hParent), uiParentOffset, uiEntryOffset);
struct sHandleList *psNext = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Next, HANDLE_TO_INDEX(psEntry->hParent), uiParentOffset, uiEntryOffset);
PVR_ASSERT(psEntry->hParent != IMG_NULL)
psPrev->ui32Next = psEntry->ui32Next;
psNext->ui32Prev = psEntry->ui32Prev;
HandleListInit(ui32EntryIndex, psEntry, IMG_NULL);
}
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(UnlinkFromParent)
#endif
static INLINE
IMG_VOID UnlinkFromParent(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
{
HandleListRemove(psBase, HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, offsetof(struct sHandle, sSiblings), offsetof(struct sHandle, sChildren));
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListIterate)
#endif
static INLINE
PVRSRV_ERROR HandleListIterate(PVRSRV_HANDLE_BASE *psBase, struct sHandleList *psHead, IMG_SIZE_T uiParentOffset, IMG_SIZE_T uiEntryOffset, PVRSRV_ERROR (*pfnIterFunc)(PVRSRV_HANDLE_BASE *, struct sHandle *))
{
IMG_UINT32 ui32Index;
IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psHead->hParent);
PVR_ASSERT(psHead->hParent != IMG_NULL)
for(ui32Index = psHead->ui32Next; ui32Index != ui32Parent; )
{
struct sHandle *psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32Index);
struct sHandleList *psEntry = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32Index, ui32Parent, uiParentOffset, uiEntryOffset);
PVRSRV_ERROR eError;
PVR_ASSERT(psEntry->hParent == psHead->hParent)
ui32Index = psEntry->ui32Next;
eError = (*pfnIterFunc)(psBase, psHandle);
if (eError != PVRSRV_OK)
{
return eError;
}
}
return PVRSRV_OK;
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(IterateOverChildren)
#endif
static INLINE
PVRSRV_ERROR IterateOverChildren(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, PVRSRV_ERROR (*pfnIterFunc)(PVRSRV_HANDLE_BASE *, struct sHandle *))
{
return HandleListIterate(psBase, &psParent->sChildren, offsetof(struct sHandle, sChildren), offsetof(struct sHandle, sSiblings), pfnIterFunc);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(GetHandleStructure)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR GetHandleStructure(PVRSRV_HANDLE_BASE *psBase, struct sHandle **ppsHandle, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR GetHandleStructure(PVRSRV_HANDLE_BASE *psBase, struct sHandle **ppsHandle, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
#endif
{
IMG_UINT32 ui32Index = HANDLE_TO_INDEX(hHandle);
struct sHandle *psHandle;
if (!INDEX_IS_VALID(psBase, ui32Index))
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle index out of range (%u >= %u)", ui32Index, psBase->ui32TotalHandCount));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE;
}
psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32Index);
if (psHandle->eType == PVRSRV_HANDLE_TYPE_NONE)
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle not allocated (index: %u)", ui32Index));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return PVRSRV_ERROR_HANDLE_NOT_ALLOCATED;
}
if (eType != PVRSRV_HANDLE_TYPE_NONE && eType != psHandle->eType)
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle type mismatch (%d != %d)", eType, psHandle->eType));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return PVRSRV_ERROR_HANDLE_TYPE_MISMATCH;
}
*ppsHandle = psHandle;
return PVRSRV_OK;
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(ParentIfPrivate)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID ParentIfPrivate(struct sHandle *psHandle)
#else
IMG_HANDLE ParentIfPrivate(struct sHandle *psHandle)
#endif
{
return TEST_ALLOC_FLAG(psHandle, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ?
ParentHandle(psHandle) : IMG_NULL;
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(InitKey)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
IMG_VOID InitKey(HAND_KEY aKey, PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_SID hParent)
#else
IMG_VOID InitKey(HAND_KEY aKey, PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hParent)
#endif
{
PVR_UNREFERENCED_PARAMETER(psBase);
aKey[HAND_KEY_DATA] = (IMG_UINTPTR_T)pvData;
aKey[HAND_KEY_TYPE] = (IMG_UINTPTR_T)eType;
aKey[HAND_KEY_PARENT] = (IMG_UINTPTR_T)hParent;
}
static
PVRSRV_ERROR ReallocHandleArray(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32NewCount)
{
struct sHandleIndex *psOldArray = psBase->psHandleArray;
IMG_HANDLE hOldArrayBlockAlloc = psBase->hArrayBlockAlloc;
IMG_UINT32 ui32OldCount = psBase->ui32TotalHandCount;
struct sHandleIndex *psNewArray = IMG_NULL;
IMG_HANDLE hNewArrayBlockAlloc = IMG_NULL;
PVRSRV_ERROR eError;
PVRSRV_ERROR eReturn = PVRSRV_OK;
IMG_UINT32 ui32Index;
if (ui32NewCount == ui32OldCount)
{
return PVRSRV_OK;
}
if (ui32NewCount != 0 && !psBase->bPurgingEnabled &&
ui32NewCount < ui32OldCount)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (((ui32OldCount % HANDLE_BLOCK_SIZE) != 0) ||
((ui32NewCount % HANDLE_BLOCK_SIZE) != 0))
{
PVR_ASSERT((ui32OldCount % HANDLE_BLOCK_SIZE) == 0)
PVR_ASSERT((ui32NewCount % HANDLE_BLOCK_SIZE) == 0)
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (ui32NewCount != 0)
{
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
HANDLE_ARRAY_SIZE(ui32NewCount) * sizeof(struct sHandleIndex),
(IMG_VOID **)&psNewArray,
&hNewArrayBlockAlloc,
"Memory Area");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't allocate new handle array (%d)", eError));
eReturn = eError;
goto error;
}
if (ui32OldCount != 0)
{
OSMemCopy(psNewArray, psOldArray, HANDLE_ARRAY_SIZE(MIN(ui32NewCount, ui32OldCount)) * sizeof(struct sHandleIndex));
}
}
for(ui32Index = ui32NewCount; ui32Index < ui32OldCount; ui32Index += HANDLE_BLOCK_SIZE)
{
struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psOldArray, ui32Index);
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
psIndex->psHandle,
psIndex->hBlockAlloc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free handle structures (%d)", eError));
}
}
for(ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
{
struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psNewArray, ui32Index);
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
(IMG_VOID **)&psIndex->psHandle,
&psIndex->hBlockAlloc,
"Memory Area");
if (eError != PVRSRV_OK)
{
psIndex->psHandle = IMG_NULL;
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't allocate handle structures (%d)", eError));
eReturn = eError;
}
else
{
IMG_UINT32 ui32SubIndex;
psIndex->ui32FreeHandBlockCount = HANDLE_BLOCK_SIZE;
for(ui32SubIndex = 0; ui32SubIndex < HANDLE_BLOCK_SIZE; ui32SubIndex++)
{
struct sHandle *psHandle = psIndex->psHandle + ui32SubIndex;
psHandle->ui32Index = ui32SubIndex + ui32Index;
psHandle->eType = PVRSRV_HANDLE_TYPE_NONE;
psHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
psHandle->ui32NextIndexPlusOne = 0;
}
}
}
if (eReturn != PVRSRV_OK)
{
goto error;
}
#ifdef DEBUG_MAX_HANDLE_COUNT
if (ui32NewCount > DEBUG_MAX_HANDLE_COUNT)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Max handle count (%u) reached", DEBUG_MAX_HANDLE_COUNT));
eReturn = PVRSRV_ERROR_OUT_OF_MEMORY;
goto error;
}
#endif
if (psOldArray != IMG_NULL)
{
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
HANDLE_ARRAY_SIZE(ui32OldCount) * sizeof(struct sHandleIndex),
psOldArray,
hOldArrayBlockAlloc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free old handle array (%d)", eError));
}
}
psBase->psHandleArray = psNewArray;
psBase->hArrayBlockAlloc = hNewArrayBlockAlloc;
psBase->ui32TotalHandCount = ui32NewCount;
if (ui32NewCount > ui32OldCount)
{
PVR_ASSERT(psBase->ui32FreeHandCount + (ui32NewCount - ui32OldCount) > psBase->ui32FreeHandCount)
psBase->ui32FreeHandCount += (ui32NewCount - ui32OldCount);
if (psBase->ui32FirstFreeIndex == 0)
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0)
psBase->ui32FirstFreeIndex = ui32OldCount;
}
else
{
if (!psBase->bPurgingEnabled)
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0)
PVR_ASSERT(INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0)
INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32OldCount + 1;
}
}
if (!psBase->bPurgingEnabled)
{
psBase->ui32LastFreeIndexPlusOne = ui32NewCount;
}
}
else
{
PVR_ASSERT(ui32NewCount == 0 || psBase->bPurgingEnabled)
PVR_ASSERT(ui32NewCount == 0 || psBase->ui32FirstFreeIndex <= ui32NewCount)
PVR_ASSERT(psBase->ui32FreeHandCount - (ui32OldCount - ui32NewCount) < psBase->ui32FreeHandCount)
psBase->ui32FreeHandCount -= (ui32OldCount - ui32NewCount);
if (ui32NewCount == 0)
{
psBase->ui32FirstFreeIndex = 0;
psBase->ui32LastFreeIndexPlusOne = 0;
}
}
PVR_ASSERT(psBase->ui32FirstFreeIndex <= psBase->ui32TotalHandCount)
return PVRSRV_OK;
error:
PVR_ASSERT(eReturn != PVRSRV_OK)
if (psNewArray != IMG_NULL)
{
for(ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
{
struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psNewArray, ui32Index);
if (psIndex->psHandle != IMG_NULL)
{
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
psIndex->psHandle,
psIndex->hBlockAlloc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free handle structures (%d)", eError));
}
}
}
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
HANDLE_ARRAY_SIZE(ui32NewCount) * sizeof(struct sHandleIndex),
psNewArray,
hNewArrayBlockAlloc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free new handle array (%d)", eError));
}
}
return eReturn;
}
static PVRSRV_ERROR FreeHandleArray(PVRSRV_HANDLE_BASE *psBase)
{
return ReallocHandleArray(psBase, 0);
}
static PVRSRV_ERROR FreeHandle(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
{
HAND_KEY aKey;
IMG_UINT32 ui32Index = HANDLE_PTR_TO_INDEX(psHandle);
PVRSRV_ERROR eError;
InitKey(aKey, psBase, psHandle->pvData, psHandle->eType, ParentIfPrivate(psHandle));
if (!TEST_ALLOC_FLAG(psHandle, PVRSRV_HANDLE_ALLOC_FLAG_MULTI) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hHandle;
hHandle = (IMG_SID) HASH_Remove_Extended(psBase->psHashTab, aKey);
#else
IMG_HANDLE hHandle;
hHandle = (IMG_HANDLE) HASH_Remove_Extended(psBase->psHashTab, aKey);
#endif
PVR_ASSERT(hHandle != IMG_NULL)
PVR_ASSERT(hHandle == INDEX_TO_HANDLE(ui32Index))
PVR_UNREFERENCED_PARAMETER(hHandle);
}
UnlinkFromParent(psBase, psHandle);
eError = IterateOverChildren(psBase, psHandle, FreeHandle);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeHandle: Error whilst freeing subhandles (%d)", eError));
return eError;
}
psHandle->eType = PVRSRV_HANDLE_TYPE_NONE;
if (BATCHED_HANDLE(psHandle) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle);
return PVRSRV_OK;
}
if (!psBase->bPurgingEnabled)
{
if (psBase->ui32FreeHandCount == 0)
{
PVR_ASSERT(psBase->ui32FirstFreeIndex == 0)
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0)
psBase->ui32FirstFreeIndex = ui32Index;
}
else
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0)
PVR_ASSERT(INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0)
INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32Index + 1;
}
PVR_ASSERT(psHandle->ui32NextIndexPlusOne == 0)
psBase->ui32LastFreeIndexPlusOne = ui32Index + 1;
}
psBase->ui32FreeHandCount++;
INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32Index)++;
PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32Index)<= HANDLE_BLOCK_SIZE)
#ifdef DEBUG
{
IMG_UINT32 ui32BlockedIndex;
IMG_UINT32 ui32FreeHandCount = 0;
for (ui32BlockedIndex = 0; ui32BlockedIndex < psBase->ui32TotalHandCount; ui32BlockedIndex += HANDLE_BLOCK_SIZE)
{
ui32FreeHandCount += INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32BlockedIndex);
}
PVR_ASSERT(ui32FreeHandCount == psBase->ui32FreeHandCount)
}
#endif
return PVRSRV_OK;
}
static PVRSRV_ERROR FreeAllHandles(PVRSRV_HANDLE_BASE *psBase)
{
IMG_UINT32 i;
PVRSRV_ERROR eError = PVRSRV_OK;
if (psBase->ui32FreeHandCount == psBase->ui32TotalHandCount)
{
return eError;
}
for (i = 0; i < psBase->ui32TotalHandCount; i++)
{
struct sHandle *psHandle;
psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, i);
if (psHandle->eType != PVRSRV_HANDLE_TYPE_NONE)
{
eError = FreeHandle(psBase, psHandle);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeAllHandles: FreeHandle failed (%d)", eError));
break;
}
if (psBase->ui32FreeHandCount == psBase->ui32TotalHandCount)
{
break;
}
}
}
return eError;
}
static PVRSRV_ERROR FreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
{
PVRSRV_ERROR eError;
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_WARNING, "FreeHandleBase: Uncommitted/Unreleased handle batch"));
PVRSRVReleaseHandleBatch(psBase);
}
eError = FreeAllHandles(psBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handles (%d)", eError));
return eError;
}
eError = FreeHandleArray(psBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handle array (%d)", eError));
return eError;
}
if (psBase->psHashTab != IMG_NULL)
{
HASH_Delete(psBase->psHashTab);
}
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psBase),
psBase,
psBase->hBaseBlockAlloc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handle base (%d)", eError));
return eError;
}
return PVRSRV_OK;
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(FindHandle)
#endif
static INLINE
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID FindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_SID hParent)
#else
IMG_HANDLE FindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hParent)
#endif
{
HAND_KEY aKey;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
InitKey(aKey, psBase, pvData, eType, hParent);
#if defined (SUPPORT_SID_INTERFACE)
return (IMG_SID) HASH_Retrieve_Extended(psBase->psHashTab, aKey);
#else
return (IMG_HANDLE) HASH_Retrieve_Extended(psBase->psHashTab, aKey);
#endif
}
static PVRSRV_ERROR IncreaseHandleArraySize(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32Delta)
{
PVRSRV_ERROR eError;
IMG_UINT32 ui32DeltaAdjusted = ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(ui32Delta);
IMG_UINT32 ui32NewTotalHandCount = psBase->ui32TotalHandCount + ui32DeltaAdjusted;
;
PVR_ASSERT(ui32Delta != 0)
if (ui32NewTotalHandCount > psBase->ui32MaxIndexPlusOne || ui32NewTotalHandCount <= psBase->ui32TotalHandCount)
{
ui32NewTotalHandCount = psBase->ui32MaxIndexPlusOne;
ui32DeltaAdjusted = ui32NewTotalHandCount - psBase->ui32TotalHandCount;
if (ui32DeltaAdjusted < ui32Delta)
{
PVR_DPF((PVR_DBG_ERROR, "IncreaseHandleArraySize: Maximum handle limit reached (%d)", psBase->ui32MaxIndexPlusOne));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
}
PVR_ASSERT(ui32DeltaAdjusted >= ui32Delta)
eError = ReallocHandleArray(psBase, ui32NewTotalHandCount);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "IncreaseHandleArraySize: ReallocHandleArray failed (%d)", eError));
return eError;
}
return PVRSRV_OK;
}
static PVRSRV_ERROR EnsureFreeHandles(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32Free)
{
PVRSRV_ERROR eError;
if (ui32Free > psBase->ui32FreeHandCount)
{
IMG_UINT32 ui32FreeHandDelta = ui32Free - psBase->ui32FreeHandCount;
eError = IncreaseHandleArraySize(psBase, ui32FreeHandDelta);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "EnsureFreeHandles: Couldn't allocate %u handles to ensure %u free handles (IncreaseHandleArraySize failed with error %d)", ui32FreeHandDelta, ui32Free, eError));
return eError;
}
}
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
static PVRSRV_ERROR AllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_SID hParent)
#else
static PVRSRV_ERROR AllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent)
#endif
{
IMG_UINT32 ui32NewIndex = DEFAULT_MAX_INDEX_PLUS_ONE;
struct sHandle *psNewHandle = IMG_NULL;
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hHandle;
#else
IMG_HANDLE hHandle;
#endif
HAND_KEY aKey;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
PVR_ASSERT(psBase != IMG_NULL)
PVR_ASSERT(psBase->psHashTab != IMG_NULL)
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
{
PVR_ASSERT(FindHandle(psBase, pvData, eType, hParent) == IMG_NULL)
}
if (psBase->ui32FreeHandCount == 0 && HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_WARNING, "AllocHandle: Handle batch size (%u) was too small, allocating additional space", psBase->ui32HandBatchSize));
}
eError = EnsureFreeHandles(psBase, 1);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "AllocHandle: EnsureFreeHandles failed (%d)", eError));
return eError;
}
PVR_ASSERT(psBase->ui32FreeHandCount != 0)
if (!psBase->bPurgingEnabled)
{
ui32NewIndex = psBase->ui32FirstFreeIndex;
psNewHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32NewIndex);
}
else
{
IMG_UINT32 ui32BlockedIndex;
PVR_ASSERT((psBase->ui32FirstFreeIndex % HANDLE_BLOCK_SIZE) == 0)
for (ui32BlockedIndex = ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(psBase->ui32FirstFreeIndex); ui32BlockedIndex < psBase->ui32TotalHandCount; ui32BlockedIndex += HANDLE_BLOCK_SIZE)
{
struct sHandleIndex *psIndex = BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, ui32BlockedIndex);
if (psIndex->ui32FreeHandBlockCount == 0)
{
continue;
}
for (ui32NewIndex = ui32BlockedIndex; ui32NewIndex < ui32BlockedIndex + HANDLE_BLOCK_SIZE; ui32NewIndex++)
{
psNewHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32NewIndex);
if (HANDLE_STRUCT_IS_FREE(psNewHandle))
{
break;
}
}
}
psBase->ui32FirstFreeIndex = 0;
PVR_ASSERT(ui32NewIndex < psBase->ui32TotalHandCount)
}
PVR_ASSERT(psNewHandle != IMG_NULL)
hHandle = INDEX_TO_HANDLE(ui32NewIndex);
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
{
InitKey(aKey, psBase, pvData, eType, hParent);
if (!HASH_Insert_Extended(psBase->psHashTab, aKey, (IMG_UINTPTR_T)hHandle))
{
PVR_DPF((PVR_DBG_ERROR, "AllocHandle: Couldn't add handle to hash table"));
return PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE;
}
}
psBase->ui32FreeHandCount--;
PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex) <= HANDLE_BLOCK_SIZE)
PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex) > 0)
INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex)--;
if (!psBase->bPurgingEnabled)
{
if (psBase->ui32FreeHandCount == 0)
{
PVR_ASSERT(psBase->ui32FirstFreeIndex == ui32NewIndex)
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == (ui32NewIndex + 1))
psBase->ui32LastFreeIndexPlusOne = 0;
psBase->ui32FirstFreeIndex = 0;
}
else
{
psBase->ui32FirstFreeIndex = (psNewHandle->ui32NextIndexPlusOne == 0) ?
ui32NewIndex + 1 :
psNewHandle->ui32NextIndexPlusOne - 1;
}
}
PVR_ASSERT(psNewHandle->ui32Index == ui32NewIndex)
psNewHandle->eType = eType;
psNewHandle->pvData = pvData;
psNewHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
psNewHandle->eFlag = eFlag;
InitParentList(psNewHandle);
#if defined(DEBUG)
PVR_ASSERT(NoChildren(psNewHandle))
#endif
InitChildEntry(psNewHandle);
#if defined(DEBUG)
PVR_ASSERT(NoParent(psNewHandle))
#endif
if (HANDLES_BATCHED(psBase))
{
psNewHandle->ui32NextIndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
psBase->ui32FirstBatchIndexPlusOne = ui32NewIndex + 1;
SET_BATCHED_HANDLE(psNewHandle);
}
else
{
psNewHandle->ui32NextIndexPlusOne = 0;
}
*phHandle = hHandle;
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVAllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag)
#else
PVRSRV_ERROR PVRSRVAllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag)
#endif
{
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hHandle;
#else
IMG_HANDLE hHandle;
#endif
PVRSRV_ERROR eError;
#if defined (SUPPORT_SID_INTERFACE)
*phHandle = 0;
#else
*phHandle = IMG_NULL;
#endif
if (HANDLES_BATCHED(psBase))
{
psBase->ui32BatchHandAllocFailures++;
}
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
{
hHandle = FindHandle(psBase, pvData, eType, IMG_NULL);
#if defined (SUPPORT_SID_INTERFACE)
if (hHandle != 0)
#else
if (hHandle != IMG_NULL)
#endif
{
struct sHandle *psHandle;
eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandle: Lookup of existing handle failed"));
return eError;
}
if (TEST_FLAG(psHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED))
{
*phHandle = hHandle;
eError = PVRSRV_OK;
goto exit_ok;
}
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
}
}
eError = AllocHandle(psBase, phHandle, pvData, eType, eFlag, IMG_NULL);
exit_ok:
if (HANDLES_BATCHED(psBase) && (eError == PVRSRV_OK))
{
psBase->ui32BatchHandAllocFailures--;
}
return eError;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_SID hParent)
#else
PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent)
#endif
{
struct sHandle *psPHand;
struct sHandle *psCHand;
PVRSRV_ERROR eError;
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hParentKey;
IMG_SID hHandle;
*phHandle = 0;
#else
IMG_HANDLE hParentKey;
IMG_HANDLE hHandle;
*phHandle = IMG_NULL;
#endif
if (HANDLES_BATCHED(psBase))
{
psBase->ui32BatchHandAllocFailures++;
}
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
hParentKey = TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ?
hParent : IMG_NULL;
eError = GetHandleStructure(psBase, &psPHand, hParent, PVRSRV_HANDLE_TYPE_NONE);
if (eError != PVRSRV_OK)
{
return eError;
}
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
{
hHandle = FindHandle(psBase, pvData, eType, hParentKey);
#if defined (SUPPORT_SID_INTERFACE)
if (hHandle != 0)
#else
if (hHandle != IMG_NULL)
#endif
{
struct sHandle *psCHandle;
PVRSRV_ERROR eErr;
eErr = GetHandleStructure(psBase, &psCHandle, hHandle, eType);
if (eErr != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Lookup of existing handle failed"));
return eErr;
}
PVR_ASSERT(hParentKey != IMG_NULL && ParentHandle(HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle)) == hParent)
if (TEST_FLAG(psCHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED) && ParentHandle(HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle)) == hParent)
{
*phHandle = hHandle;
goto exit_ok;
}
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
}
}
eError = AllocHandle(psBase, &hHandle, pvData, eType, eFlag, hParentKey);
if (eError != PVRSRV_OK)
{
return eError;
}
psPHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hParent);
psCHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle);
AdoptChild(psBase, psPHand, psCHand);
*phHandle = hHandle;
exit_ok:
if (HANDLES_BATCHED(psBase))
{
psBase->ui32BatchHandAllocFailures--;
}
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVFindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR PVRSRVFindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType)
#endif
{
#if defined (SUPPORT_SID_INTERFACE)
IMG_SID hHandle;
#else
IMG_HANDLE hHandle;
#endif
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
#if defined (SUPPORT_SID_INTERFACE)
hHandle = (IMG_SID) FindHandle(psBase, pvData, eType, IMG_NULL);
#else
hHandle = (IMG_HANDLE) FindHandle(psBase, pvData, eType, IMG_NULL);
#endif
if (hHandle == IMG_NULL)
{
return PVRSRV_ERROR_HANDLE_NOT_FOUND;
}
*phHandle = hHandle;
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVLookupHandleAnyType(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, PVRSRV_HANDLE_TYPE *peType, IMG_SID hHandle)
#else
PVRSRV_ERROR PVRSRVLookupHandleAnyType(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, PVRSRV_HANDLE_TYPE *peType, IMG_HANDLE hHandle)
#endif
{
struct sHandle *psHandle;
PVRSRV_ERROR eError;
eError = GetHandleStructure(psBase, &psHandle, hHandle, PVRSRV_HANDLE_TYPE_NONE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupHandleAnyType: Error looking up handle (%d)", eError));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return eError;
}
*ppvData = psHandle->pvData;
*peType = psHandle->eType;
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVLookupHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR PVRSRVLookupHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
#endif
{
struct sHandle *psHandle;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
#if defined (SUPPORT_SID_INTERFACE)
PVR_ASSERT(hHandle != 0)
#endif
eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupHandle: Error looking up handle (%d)", eError));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return eError;
}
*ppvData = psHandle->pvData;
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVLookupSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType, IMG_SID hAncestor)
#else
PVRSRV_ERROR PVRSRVLookupSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hAncestor)
#endif
{
struct sHandle *psPHand;
struct sHandle *psCHand;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
#if defined (SUPPORT_SID_INTERFACE)
PVR_ASSERT(hHandle != 0)
#endif
eError = GetHandleStructure(psBase, &psCHand, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupSubHandle: Error looking up subhandle (%d)", eError));
return eError;
}
for (psPHand = psCHand; ParentHandle(psPHand) != hAncestor; )
{
eError = GetHandleStructure(psBase, &psPHand, ParentHandle(psPHand), PVRSRV_HANDLE_TYPE_NONE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupSubHandle: Subhandle doesn't belong to given ancestor"));
return PVRSRV_ERROR_INVALID_SUBHANDLE;
}
}
*ppvData = psCHand->pvData;
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVGetParentHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID *phParent, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR PVRSRVGetParentHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *phParent, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
#endif
{
struct sHandle *psHandle;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetParentHandle: Error looking up subhandle (%d)", eError));
return eError;
}
*phParent = ParentHandle(psHandle);
return PVRSRV_OK;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVLookupAndReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR PVRSRVLookupAndReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
#endif
{
struct sHandle *psHandle;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupAndReleaseHandle: Error looking up handle (%d)", eError));
#if defined (SUPPORT_SID_INTERFACE)
PVR_DBG_BREAK
#endif
return eError;
}
*ppvData = psHandle->pvData;
eError = FreeHandle(psBase, psHandle);
return eError;
}
#if defined (SUPPORT_SID_INTERFACE)
PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_SID hHandle, PVRSRV_HANDLE_TYPE eType)
#else
PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
#endif
{
struct sHandle *psHandle;
PVRSRV_ERROR eError;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE)
eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVReleaseHandle: Error looking up handle (%d)", eError));
return eError;
}
eError = FreeHandle(psBase, psHandle);
return eError;
}
PVRSRV_ERROR PVRSRVNewHandleBatch(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32BatchSize)
{
PVRSRV_ERROR eError;
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: There is a handle batch already in use (size %u)", psBase->ui32HandBatchSize));
return PVRSRV_ERROR_HANDLE_BATCH_IN_USE;
}
if (ui32BatchSize == 0)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: Invalid batch size (%u)", ui32BatchSize));
return PVRSRV_ERROR_INVALID_PARAMS;
}
eError = EnsureFreeHandles(psBase, ui32BatchSize);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: EnsureFreeHandles failed (error %d)", eError));
return eError;
}
psBase->ui32HandBatchSize = ui32BatchSize;
psBase->ui32TotalHandCountPreBatch = psBase->ui32TotalHandCount;
PVR_ASSERT(psBase->ui32BatchHandAllocFailures == 0)
PVR_ASSERT(psBase->ui32FirstBatchIndexPlusOne == 0)
PVR_ASSERT(HANDLES_BATCHED(psBase))
return PVRSRV_OK;
}
static PVRSRV_ERROR PVRSRVHandleBatchCommitOrRelease(PVRSRV_HANDLE_BASE *psBase, IMG_BOOL bCommit)
{
IMG_UINT32 ui32IndexPlusOne;
IMG_BOOL bCommitBatch = bCommit;
if (!HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: There is no handle batch"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (psBase->ui32BatchHandAllocFailures != 0)
{
if (bCommit)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: Attempting to commit batch with handle allocation failures."));
}
bCommitBatch = IMG_FALSE;
}
PVR_ASSERT(psBase->ui32BatchHandAllocFailures == 0 || !bCommit)
ui32IndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
while(ui32IndexPlusOne != 0)
{
struct sHandle *psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32IndexPlusOne - 1);
IMG_UINT32 ui32NextIndexPlusOne = psHandle->ui32NextIndexPlusOne;
PVR_ASSERT(BATCHED_HANDLE(psHandle))
psHandle->ui32NextIndexPlusOne = 0;
if (!bCommitBatch || BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
PVRSRV_ERROR eError;
if (!BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
SET_UNBATCHED_HANDLE(psHandle);
}
eError = FreeHandle(psBase, psHandle);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: Error freeing handle (%d)", eError));
}
PVR_ASSERT(eError == PVRSRV_OK)
}
else
{
SET_UNBATCHED_HANDLE(psHandle);
}
ui32IndexPlusOne = ui32NextIndexPlusOne;
}
#ifdef DEBUG
if (psBase->ui32TotalHandCountPreBatch != psBase->ui32TotalHandCount)
{
IMG_UINT32 ui32Delta = psBase->ui32TotalHandCount - psBase->ui32TotalHandCountPreBatch;
PVR_ASSERT(psBase->ui32TotalHandCount > psBase->ui32TotalHandCountPreBatch)
PVR_DPF((PVR_DBG_WARNING, "PVRSRVHandleBatchCommitOrRelease: The batch size was too small. Batch size was %u, but needs to be %u", psBase->ui32HandBatchSize, psBase->ui32HandBatchSize + ui32Delta));
}
#endif
psBase->ui32HandBatchSize = 0;
psBase->ui32FirstBatchIndexPlusOne = 0;
psBase->ui32TotalHandCountPreBatch = 0;
psBase->ui32BatchHandAllocFailures = 0;
if (psBase->ui32BatchHandAllocFailures != 0 && bCommit)
{
PVR_ASSERT(!bCommitBatch)
return PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE;
}
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVCommitHandleBatch(PVRSRV_HANDLE_BASE *psBase)
{
return PVRSRVHandleBatchCommitOrRelease(psBase, IMG_TRUE);
}
IMG_VOID PVRSRVReleaseHandleBatch(PVRSRV_HANDLE_BASE *psBase)
{
(IMG_VOID) PVRSRVHandleBatchCommitOrRelease(psBase, IMG_FALSE);
}
PVRSRV_ERROR PVRSRVSetMaxHandle(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32MaxHandle)
{
IMG_UINT32 ui32MaxHandleRounded;
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set whilst in batch mode"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (ui32MaxHandle == 0 || ui32MaxHandle > DEFAULT_MAX_HANDLE)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit must be between %u and %u, inclusive", 0, DEFAULT_MAX_HANDLE));
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (psBase->ui32TotalHandCount != 0)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set because handles have already been allocated"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
ui32MaxHandleRounded = ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(ui32MaxHandle);
if (ui32MaxHandleRounded != 0 && ui32MaxHandleRounded < psBase->ui32MaxIndexPlusOne)
{
psBase->ui32MaxIndexPlusOne = ui32MaxHandleRounded;
}
PVR_ASSERT(psBase->ui32MaxIndexPlusOne != 0)
PVR_ASSERT(psBase->ui32MaxIndexPlusOne <= DEFAULT_MAX_INDEX_PLUS_ONE)
PVR_ASSERT((psBase->ui32MaxIndexPlusOne % HANDLE_BLOCK_SIZE) == 0)
return PVRSRV_OK;
}
IMG_UINT32 PVRSRVGetMaxHandle(PVRSRV_HANDLE_BASE *psBase)
{
return psBase->ui32MaxIndexPlusOne;
}
PVRSRV_ERROR PVRSRVEnableHandlePurging(PVRSRV_HANDLE_BASE *psBase)
{
if (psBase->bPurgingEnabled)
{
PVR_DPF((PVR_DBG_WARNING, "PVRSRVEnableHandlePurging: Purging already enabled"));
return PVRSRV_OK;
}
if (psBase->ui32TotalHandCount != 0)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVEnableHandlePurging: Handles have already been allocated"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psBase->bPurgingEnabled = IMG_TRUE;
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVPurgeHandles(PVRSRV_HANDLE_BASE *psBase)
{
IMG_UINT32 ui32BlockIndex;
IMG_UINT32 ui32NewHandCount;
if (!psBase->bPurgingEnabled)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPurgeHandles: Purging not enabled for this handle base"));
return PVRSRV_ERROR_NOT_SUPPORTED;
}
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPurgeHandles: Purging not allowed whilst in batch mode"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
PVR_ASSERT((psBase->ui32TotalHandCount % HANDLE_BLOCK_SIZE) == 0)
for (ui32BlockIndex = INDEX_TO_BLOCK_INDEX(psBase->ui32TotalHandCount); ui32BlockIndex != 0; ui32BlockIndex--)
{
if (psBase->psHandleArray[ui32BlockIndex - 1].ui32FreeHandBlockCount != HANDLE_BLOCK_SIZE)
{
break;
}
}
ui32NewHandCount = BLOCK_INDEX_TO_INDEX(ui32BlockIndex);
if (ui32NewHandCount <= (psBase->ui32TotalHandCount/2))
{
PVRSRV_ERROR eError;
eError = ReallocHandleArray(psBase, ui32NewHandCount);
if (eError != PVRSRV_OK)
{
return eError;
}
}
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase)
{
PVRSRV_HANDLE_BASE *psBase;
IMG_HANDLE hBlockAlloc;
PVRSRV_ERROR eError;
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(*psBase),
(IMG_PVOID *)&psBase,
&hBlockAlloc,
"Handle Base");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't allocate handle base (%d)", eError));
return eError;
}
OSMemSet(psBase, 0, sizeof(*psBase));
psBase->psHashTab = HASH_Create_Extended(HANDLE_HASH_TAB_INIT_SIZE, sizeof(HAND_KEY), HASH_Func_Default, HASH_Key_Comp_Default);
if (psBase->psHashTab == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't create data pointer hash table\n"));
(IMG_VOID)PVRSRVFreeHandleBase(psBase);
return PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE;
}
psBase->hBaseBlockAlloc = hBlockAlloc;
psBase->ui32MaxIndexPlusOne = DEFAULT_MAX_INDEX_PLUS_ONE;
*ppsBase = psBase;
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVFreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
{
PVRSRV_ERROR eError;
PVR_ASSERT(psBase != gpsKernelHandleBase)
eError = FreeHandleBase(psBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeHandleBase: FreeHandleBase failed (%d)", eError));
}
return eError;
}
PVRSRV_ERROR PVRSRVHandleInit(IMG_VOID)
{
PVRSRV_ERROR eError;
PVR_ASSERT(gpsKernelHandleBase == IMG_NULL)
eError = PVRSRVAllocHandleBase(&gpsKernelHandleBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleInit: PVRSRVAllocHandleBase failed (%d)", eError));
goto error;
}
eError = PVRSRVEnableHandlePurging(gpsKernelHandleBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleInit: PVRSRVEnableHandlePurging failed (%d)", eError));
goto error;
}
return PVRSRV_OK;
error:
(IMG_VOID) PVRSRVHandleDeInit();
return eError;
}
PVRSRV_ERROR PVRSRVHandleDeInit(IMG_VOID)
{
PVRSRV_ERROR eError = PVRSRV_OK;
if (gpsKernelHandleBase != IMG_NULL)
{
eError = FreeHandleBase(gpsKernelHandleBase);
if (eError == PVRSRV_OK)
{
gpsKernelHandleBase = IMG_NULL;
}
else
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleDeInit: FreeHandleBase failed (%d)", eError));
}
}
return eError;
}
#else
#endif