services4/srvkm/common/buffer_manager.c \
services4/srvkm/common/pvrsrv.c \
services4/srvkm/common/handle.c \
+services4/srvkm/common/lists.c \
services4/srvkm/common/ra.c \
services4/srvkm/common/devicemem.c \
services4/srvkm/env/linux/pvr_debug.c \
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie,
+PVRSRV_ERROR IMG_CALLCONV _PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie,
PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevMemHeap,
IMG_UINT32 ui32Flags,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo);
+#if defined(PVRSRV_LOG_MEMORY_ALLOCS)
+ #define PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo, logStr) \
+ (PVR_TRACE(("PVRSRVAllocDeviceMemKM(" #devCookie ", " #perProc ", " #devMemHeap ", " #flags ", " #size \
+ ", " #alignment "," #memInfo "): " logStr " (size = 0x%;x)", size)),\
+ _PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo))
+#else
+ #define PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo, logStr) \
+ _PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo)
+#endif
+
+
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie,
PVRSRV_KERNEL_MEM_INFO *psMemInfo);
IMG_UINT32 ui32RefCount;
+
+ IMG_BOOL bPendingFree;
+
+
+ #if defined(ANDROID)
+ #if !defined(USE_CODE)
+
+ IMG_UINT64 ui64Stamp;
+ #else
+ IMG_UINT32 dummy1;
+ IMG_UINT32 dummy2;
+ #endif
+ #endif
struct _PVRSRV_KERNEL_SYNC_INFO_ *psKernelSyncInfo;
PVRSRV_KERNEL_MEM_INFO *psSyncDataMemInfoKM;
+
+ IMG_HANDLE hResItem;
+
} PVRSRV_KERNEL_SYNC_INFO;
typedef struct _PVRSRV_DEVICE_SYNC_OBJECT_
psAllocDeviceMemIN->ui32Attribs,
psAllocDeviceMemIN->ui32Size,
psAllocDeviceMemIN->ui32Alignment,
- &psMemInfo);
+ &psMemInfo,
+ "" );
if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
{
ASSIGN_AND_EXIT_ON_ERROR(psWrapExtMemOUT->eError,
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageTableSize,
- (IMG_VOID **)&psSysPAddr, 0));
+ (IMG_VOID **)&psSysPAddr, 0,
+ "Page Table"));
if(CopyFromUserWrapper(psPerProc,
ui32BridgeID,
ASSIGN_AND_EXIT_ON_ERROR(psGetMiscInfoOUT->eError,
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
- (IMG_VOID **)&psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0));
+ (IMG_VOID **)&psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0,
+ "Output string buffer"));
psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
allocatedSize,
&pAllocated,
- &hAllocatedHandle));
+ &hAllocatedHandle,
+ "Array of Hardware Performance Circular Buffer Data"));
psTmpUserData = sMiscInfo.uData.sRetrieveCB.psHWPerfData;
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32AllocatedSize,
(IMG_VOID **)&psAllocated,
- &hAllocatedHandle));
+ &hAllocatedHandle,
+ "Array of Hardware Performance Circular Buffer Data"));
psSGXReadHWPerfCBOUT->eError = SGXReadHWPerfCBKM(hDevCookieInt,
psSGXReadHWPerfCBIN->ui32ArraySize,
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32KernelMemInfoHandlesCount * sizeof(IMG_HANDLE),
(IMG_VOID **)&phKernelMemInfoHandles,
- 0);
+ 0,
+ "Array of Handles");
if (eError != PVRSRV_OK)
{
goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32KernelMemInfoHandlesCount * sizeof(PVRSRV_KERNEL_MEM_INFO *),
(IMG_VOID **)&ppsKernelMemInfos,
- 0);
+ 0,
+ "Array of pointers to Kernel Memory Info");
if (eError != PVRSRV_OK)
{
goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32BufferArraySize,
- (IMG_PVOID *)&psKickTADumpBuffer, 0) != PVRSRV_OK)
+ (IMG_PVOID *)&psKickTADumpBuffer, 0,
+ "Array of Kick Tile Accelerator Dump Buffer") != PVRSRV_OK)
{
return -ENOMEM;
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
- (IMG_PVOID *)&pui32Registers, 0) != PVRSRV_OK)
+ (IMG_PVOID *)&pui32Registers, 0,
+ "Array of Registers") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PDump3DSignatureRegistersBW: OSAllocMem failed"));
goto Exit;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
- (IMG_PVOID *)&pui32Registers, 0) != PVRSRV_OK)
+ (IMG_PVOID *)&pui32Registers, 0,
+ "Array of Registers") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PDumpCounterRegistersBW: OSAllocMem failed"));
ret = -ENOMEM;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
- (IMG_PVOID *)&pui32Registers, 0) != PVRSRV_OK)
+ (IMG_PVOID *)&pui32Registers, 0,
+ "Array of Registers") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PDumpTASignatureRegistersBW: OSAllocMem failed"));
ret = -ENOMEM;
#define MIN(a,b) (a > b ? b : a)
+
+#include "lists.h"
+
+DECLARE_LIST_ANY_VA(BM_HEAP);
+DECLARE_LIST_ANY_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_ANY_VA_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_FOR_EACH_VA(BM_HEAP);
+DECLARE_LIST_INSERT(BM_HEAP);
+DECLARE_LIST_REMOVE(BM_HEAP);
+
+DECLARE_LIST_FOR_EACH(BM_CONTEXT);
+DECLARE_LIST_ANY_VA(BM_CONTEXT);
+DECLARE_LIST_ANY_VA_2(BM_CONTEXT, IMG_HANDLE, IMG_NULL);
+DECLARE_LIST_INSERT(BM_CONTEXT);
+DECLARE_LIST_REMOVE(BM_CONTEXT);
+
+
static IMG_BOOL
-ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Flags);
+ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags);
static IMG_VOID
BM_FreeMemory (IMG_VOID *pH, IMG_UINTPTR_T base, BM_MAPPING *psMapping);
static IMG_BOOL
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (struct _BM_MAPPING_),
- (IMG_PVOID *)&pMapping, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pMapping, IMG_NULL,
+ "Buffer Manager Mapping") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "AllocMemory: OSAllocMem(0x%x) FAILED"));
return IMG_FALSE;
static IMG_BOOL
WrapMemory (BM_HEAP *psBMHeap,
IMG_SIZE_T uSize,
- IMG_UINT32 ui32BaseOffset,
+ IMG_SIZE_T ui32BaseOffset,
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psAddr,
IMG_VOID *pvCPUVAddr,
IMG_DEV_VIRTADDR DevVAddr = {0};
BM_MAPPING *pMapping;
IMG_BOOL bResult;
- IMG_UINT32 const ui32PageSize = HOST_PAGESIZE();
+ IMG_SIZE_T const ui32PageSize = HOST_PAGESIZE();
PVR_DPF ((PVR_DBG_MESSAGE,
"WrapMemory(psBMHeap=%08X, size=0x%x, offset=0x%x, bPhysContig=0x%x, pvCPUVAddr = 0x%x, flags=0x%x, pBuf=%08X)",
PVR_ASSERT((psAddr->uiAddr & (ui32PageSize - 1)) == 0);
- PVR_ASSERT(((IMG_UINT32)pvCPUVAddr & (ui32PageSize - 1)) == 0);
+ PVR_ASSERT(((IMG_UINTPTR_T)pvCPUVAddr & (ui32PageSize - 1)) == 0);
uSize += ui32BaseOffset;
uSize = HOST_PAGEALIGN (uSize);
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*pMapping),
- (IMG_PVOID *)&pMapping, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pMapping, IMG_NULL,
+ "Mocked-up mapping") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSAllocMem(0x%x) FAILED",sizeof(*pMapping)));
return IMG_FALSE;
pMapping,
IMG_NULL,
uFlags | PVRSRV_MEM_READ | PVRSRV_MEM_WRITE,
- ui32PageSize,
+ IMG_CAST_TO_DEVVADDR_UINT(ui32PageSize),
&DevVAddr);
if (!bResult)
{
{
pBuf->CpuVAddr = (IMG_VOID*) ((IMG_UINTPTR_T)pMapping->CpuVAddr + ui32BaseOffset);
}
- pBuf->DevVAddr.uiAddr = pMapping->DevVAddr.uiAddr + ui32BaseOffset;
+ pBuf->DevVAddr.uiAddr = pMapping->DevVAddr.uiAddr + IMG_CAST_TO_DEVVADDR_UINT(ui32BaseOffset);
if(uFlags & PVRSRV_MEM_ZERO)
{
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+
return IMG_FALSE;
}
static IMG_BOOL
-ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Flags)
+ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags)
{
IMG_VOID *pvCpuVAddr;
}
else
{
- IMG_UINT32 ui32BytesRemaining = ui32Bytes;
- IMG_UINT32 ui32CurrentOffset = 0;
+ IMG_SIZE_T ui32BytesRemaining = ui32Bytes;
+ IMG_SIZE_T ui32CurrentOffset = 0;
IMG_CPU_PHYADDR CpuPAddr;
while(ui32BytesRemaining > 0)
{
- IMG_UINT32 ui32BlockBytes = MIN(ui32BytesRemaining, HOST_PAGESIZE());
+ IMG_SIZE_T ui32BlockBytes = MIN(ui32BytesRemaining, HOST_PAGESIZE());
CpuPAddr = OSMemHandleToCpuPAddr(pBuf->hOSMemHandle, ui32CurrentOffset);
if(CpuPAddr.uiAddr & (HOST_PAGESIZE() -1))
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+ pBuf->pMapping = IMG_NULL;
}
}
else
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+ pBuf->pMapping = IMG_NULL;
}
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_BUF), pBuf, IMG_NULL);
+
}
+PVRSRV_ERROR BM_DestroyContext_AnyCb(BM_HEAP *psBMHeap)
+{
+ if(psBMHeap->ui32Attribs
+ & (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+ |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+ {
+ if (psBMHeap->pImportArena)
+ {
+ IMG_BOOL bTestDelete = RA_TestDelete(psBMHeap->pImportArena);
+ if (!bTestDelete)
+ {
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext_AnyCb: RA_TestDelete failed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
+ }
+ }
+ return PVRSRV_OK;
+}
PVRSRV_ERROR
{
PVRSRV_ERROR eError;
BM_CONTEXT *pBMContext = (BM_CONTEXT*)hBMContext;
- BM_HEAP *psBMHeap;
PVR_DPF ((PVR_DBG_MESSAGE, "BM_DestroyContext"));
- for (psBMHeap = pBMContext->psBMHeap;
- psBMHeap != IMG_NULL;
- psBMHeap = psBMHeap->psNext)
+ eError = List_BM_HEAP_PVRSRV_ERROR_Any(pBMContext->psBMHeap, BM_DestroyContext_AnyCb);
+ if(eError != PVRSRV_OK)
{
- if(psBMHeap->ui32Attribs
- & (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
- |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: List_BM_HEAP_PVRSRV_ERROR_Any failed"));
+#if 0
+
+
+
+
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: Cleaning up with ResManFreeSpecial"));
+ if(ResManFreeSpecial() != PVRSRV_OK)
{
- if (psBMHeap->pImportArena)
- {
- IMG_BOOL bTestDelete = RA_TestDelete(psBMHeap->pImportArena);
- PVR_ASSERT(bTestDelete);
- if (!bTestDelete)
- {
- return PVRSRV_ERROR_GENERIC;
- }
- }
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeSpecial failed %d",eError));
}
+
+#endif
+ return eError;
}
+ else
+ {
- eError = ResManFreeResByPtr(pBMContext->hResItem);
+ eError = ResManFreeResByPtr(pBMContext->hResItem);
+ if(eError != PVRSRV_OK)
+ {
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeResByPtr failed %d",eError));
+ return eError;
+ }
+
+
+ if (pbDestroyed != IMG_NULL)
+ {
+ *pbDestroyed = IMG_TRUE;
+ }
+ }
+
+ return PVRSRV_OK;
+}
- if (eError != PVRSRV_OK)
+
+PVRSRV_ERROR BM_DestroyContextCallBack_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
+{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ psDeviceNode = va_arg(va, PVRSRV_DEVICE_NODE*);
+
+
+ if(psBMHeap->ui32Attribs
+ & (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+ |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
{
- PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeResByPtr failed %d",eError));
- return eError;
+ if (psBMHeap->pImportArena)
+ {
+ RA_Delete (psBMHeap->pImportArena);
+ }
}
-
- if (pbDestroyed != IMG_NULL)
+ else
{
- *pbDestroyed = IMG_TRUE;
+ PVR_DPF((PVR_DBG_ERROR, "BM_DestroyContext: backing store type unsupported"));
+ return PVRSRV_ERROR_GENERIC;
}
+
+
+ psDeviceNode->pfnMMUDelete(psBMHeap->pMMUHeap);
+
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+
return PVRSRV_OK;
}
IMG_UINT32 ui32Param)
{
BM_CONTEXT *pBMContext = pvParam;
- BM_CONTEXT **ppBMContext;
- BM_HEAP *psBMHeap, *psTmpBMHeap;
PVRSRV_DEVICE_NODE *psDeviceNode;
-
PVR_UNREFERENCED_PARAMETER(ui32Param);
- psBMHeap = pBMContext->psBMHeap;
- while(psBMHeap)
+ if(List_BM_HEAP_PVRSRV_ERROR_Any_va(pBMContext->psBMHeap,
+ BM_DestroyContextCallBack_AnyVaCb,
+ psDeviceNode) != PVRSRV_OK)
{
-
- if(psBMHeap->ui32Attribs
- & (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
- |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
- {
- if (psBMHeap->pImportArena)
- {
- RA_Delete (psBMHeap->pImportArena);
- }
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR, "BM_DestroyContext: backing store type unsupported"));
- return PVRSRV_ERROR_GENERIC;
- }
-
-
- psDeviceNode->pfnMMUDelete(psBMHeap->pMMUHeap);
-
-
- psTmpBMHeap = psBMHeap;
-
-
- psBMHeap = psBMHeap->psNext;
-
-
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psTmpBMHeap, IMG_NULL);
+ return PVRSRV_ERROR_GENERIC;
}
-
if (pBMContext->psMMUContext)
else
{
- for (ppBMContext = &psDeviceNode->sDevMemoryInfo.pBMContext;
- *ppBMContext;
- ppBMContext = &((*ppBMContext)->psNext))
- {
- if(*ppBMContext == pBMContext)
- {
-
- *ppBMContext = pBMContext->psNext;
-
- break;
- }
- }
+ List_BM_CONTEXT_Remove(pBMContext);
}
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, pBMContext, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_CONTEXT), pBMContext, IMG_NULL);
+
return PVRSRV_OK;
}
+IMG_HANDLE BM_CreateContext_IncRefCount_AnyVaCb(BM_CONTEXT *pBMContext, va_list va)
+{
+ PRESMAN_CONTEXT hResManContext;
+ hResManContext = va_arg(va, PRESMAN_CONTEXT);
+ if(ResManFindResourceByPtr(hResManContext, pBMContext->hResItem) == PVRSRV_OK)
+ {
+
+ pBMContext->ui32RefCount++;
+ return pBMContext;
+ }
+ return IMG_NULL;
+}
+
+IMG_VOID BM_CreateContext_InsertHeap_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
+{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ BM_CONTEXT *pBMContext;
+ psDeviceNode = va_arg(va, PVRSRV_DEVICE_NODE*);
+ pBMContext = va_arg(va, BM_CONTEXT*);
+ switch(psBMHeap->sDevArena.DevMemHeapType)
+ {
+ case DEVICE_MEMORY_HEAP_SHARED:
+ case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+ {
+
+ psDeviceNode->pfnMMUInsertHeap(pBMContext->psMMUContext, psBMHeap->pMMUHeap);
+ break;
+ }
+ }
+}
+
IMG_HANDLE
BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode,
IMG_DEV_PHYADDR *psPDDevPAddr,
IMG_BOOL *pbCreated)
{
BM_CONTEXT *pBMContext;
- BM_HEAP *psBMHeap;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
IMG_BOOL bKernelContext;
PRESMAN_CONTEXT hResManContext;
if (bKernelContext == IMG_FALSE)
{
- for (pBMContext = psDevMemoryInfo->pBMContext;
- pBMContext != IMG_NULL;
- pBMContext = pBMContext->psNext)
+ IMG_HANDLE res = (IMG_HANDLE) List_BM_CONTEXT_Any_va(psDevMemoryInfo->pBMContext,
+ BM_CreateContext_IncRefCount_AnyVaCb,
+ hResManContext);
+ if (res)
{
- if(ResManFindResourceByPtr(hResManContext, pBMContext->hResItem) == PVRSRV_OK)
- {
-
- pBMContext->ui32RefCount++;
-
- return (IMG_HANDLE)pBMContext;
- }
+ return res;
}
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (struct _BM_CONTEXT_),
- (IMG_PVOID *)&pBMContext, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pBMContext, IMG_NULL,
+ "Buffer Manager Context") != PVRSRV_OK)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_CreateContext: Alloc failed"));
return IMG_NULL;
- psBMHeap = pBMContext->psBMSharedHeap;
- while(psBMHeap)
- {
- switch(psBMHeap->sDevArena.DevMemHeapType)
- {
- case DEVICE_MEMORY_HEAP_SHARED:
- case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
- {
-
- psDeviceNode->pfnMMUInsertHeap(pBMContext->psMMUContext, psBMHeap->pMMUHeap);
- break;
- }
- }
-
- psBMHeap = psBMHeap->psNext;
- }
+ List_BM_HEAP_ForEach_va(pBMContext->psBMSharedHeap,
+ BM_CreateContext_InsertHeap_ForEachVaCb,
+ psDeviceNode,
+ pBMContext);
- pBMContext->psNext = psDevMemoryInfo->pBMContext;
- psDevMemoryInfo->pBMContext = pBMContext;
+ List_BM_CONTEXT_Insert(&psDevMemoryInfo->pBMContext, pBMContext);
}
return (IMG_HANDLE)pBMContext;
cleanup:
- BM_DestroyContextCallBack(pBMContext, 0);
+ (IMG_VOID)BM_DestroyContextCallBack(pBMContext, 0);
return IMG_NULL;
}
+IMG_VOID *BM_CreateHeap_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
+{
+ DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo;
+ psDevMemHeapInfo = va_arg(va, DEVICE_MEMORY_HEAP_INFO*);
+ if (psBMHeap->sDevArena.ui32HeapID == psDevMemHeapInfo->ui32HeapID)
+ {
+
+ return psBMHeap;
+ }
+ else
+ {
+ return IMG_NULL;
+ }
+}
+
IMG_HANDLE
BM_CreateHeap (IMG_HANDLE hBMContext,
DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo)
if(pBMContext->ui32RefCount > 0)
{
- psBMHeap = pBMContext->psBMHeap;
+ psBMHeap = (BM_HEAP*)List_BM_HEAP_Any_va(pBMContext->psBMHeap,
+ BM_CreateHeap_AnyVaCb,
+ psDevMemHeapInfo);
- while(psBMHeap)
+ if (psBMHeap)
{
- if(psBMHeap->sDevArena.ui32HeapID == psDevMemHeapInfo->ui32HeapID)
-
- {
-
- return psBMHeap;
- }
- psBMHeap = psBMHeap->psNext;
+ return psBMHeap;
}
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (BM_HEAP),
- (IMG_PVOID *)&psBMHeap, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&psBMHeap, IMG_NULL,
+ "Buffer Manager Heap") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: Alloc failed"));
return IMG_NULL;
}
- psBMHeap->psNext = pBMContext->psBMHeap;
- pBMContext->psBMHeap = psBMHeap;
+ List_BM_HEAP_Insert(&pBMContext->psBMHeap, psBMHeap);
return (IMG_HANDLE)psBMHeap;
}
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psBMHeap, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+
return IMG_NULL;
}
PVR_DPF((PVR_DBG_MESSAGE, "BM_DestroyHeap"));
if(psBMHeap)
- {
- BM_HEAP **ppsBMHeap;
-
+ {
if(psBMHeap->ui32Attribs
& (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
psDeviceNode->pfnMMUDelete (psBMHeap->pMMUHeap);
- ppsBMHeap = &psBMHeap->pBMContext->psBMHeap;
- while(*ppsBMHeap)
- {
- if(*ppsBMHeap == psBMHeap)
- {
-
- *ppsBMHeap = psBMHeap->psNext;
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psBMHeap, IMG_NULL);
- break;
- }
- ppsBMHeap = &((*ppsBMHeap)->psNext);
- }
+ List_BM_HEAP_Remove(psBMHeap);
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+
}
else
{
- PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyHeap: invalid heap handle"));
+ PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyHeap: invalid heap handle"));
}
}
"BM_Alloc (uSize=0x%x, uFlags=0x%x, uDevVAddrAlignment=0x%x)",
uSize, uFlags, uDevVAddrAlignment));
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- return IMG_FALSE;
- }
+ SysAcquireData(&psSysData);
psBMHeap = (BM_HEAP*)hDevMemHeap;
pBMContext = psBMHeap->pBMContext;
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (BM_BUF),
- (IMG_PVOID *)&pBuf, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pBuf, IMG_NULL,
+ "Buffer Manager buffer") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "BM_Alloc: BM_Buf alloc FAILED"));
return IMG_FALSE;
pBuf) != IMG_TRUE)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL);
+
PVR_DPF((PVR_DBG_ERROR, "BM_Alloc: AllocMemory FAILED"));
return IMG_FALSE;
}
*phBuf = (BM_HANDLE)pBuf;
*pui32Flags = uFlags | psBMHeap->ui32Attribs;
+
+ if(uFlags & PVRSRV_HAP_CACHETYPE_MASK)
+ {
+ *pui32Flags &= ~PVRSRV_HAP_CACHETYPE_MASK;
+ *pui32Flags |= (uFlags & PVRSRV_HAP_CACHETYPE_MASK);
+ }
+
return IMG_TRUE;
}
#if defined(PVR_LMA)
static IMG_BOOL
-ValidSysPAddrArrayForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR *psSysPAddr, IMG_UINT32 ui32PageCount, IMG_UINT32 ui32PageSize)
+ValidSysPAddrArrayForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR *psSysPAddr, IMG_UINT32 ui32PageCount, IMG_SIZE_T ui32PageSize)
{
IMG_UINT32 i;
}
static IMG_BOOL
-ValidSysPAddrRangeForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR sStartSysPAddr, IMG_UINT32 ui32Range)
+ValidSysPAddrRangeForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR sStartSysPAddr, IMG_SIZE_T ui32Range)
{
IMG_SYS_PHYADDR sEndSysPAddr;
IMG_BOOL
BM_Wrap ( IMG_HANDLE hDevMemHeap,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32Offset,
+ IMG_SIZE_T ui32Size,
+ IMG_SIZE_T ui32Offset,
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psSysAddr,
IMG_VOID *pvCPUVAddr,
uFlags = psBMHeap->ui32Attribs & (PVRSRV_HAP_CACHETYPE_MASK | PVRSRV_HAP_MAPTYPE_MASK);
- if(pui32Flags)
- uFlags |= *pui32Flags;
+ if ((pui32Flags != IMG_NULL) && ((*pui32Flags & PVRSRV_HAP_CACHETYPE_MASK) != 0))
+ {
+ uFlags &= ~PVRSRV_HAP_CACHETYPE_MASK;
+ uFlags |= *pui32Flags & PVRSRV_HAP_CACHETYPE_MASK;
+ }
PVR_DPF ((PVR_DBG_MESSAGE,
"BM_Wrap (uSize=0x%x, uOffset=0x%x, bPhysContig=0x%x, pvCPUVAddr=0x%x, uFlags=0x%x)",
ui32Size, ui32Offset, bPhysContig, pvCPUVAddr, uFlags));
- if(SysAcquireData (&psSysData) != PVRSRV_OK)
- return IMG_FALSE;
+ SysAcquireData(&psSysData);
#if defined(PVR_LMA)
if (bPhysContig)
}
else
{
- IMG_UINT32 ui32HostPageSize = HOST_PAGESIZE();
+ IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
if (!ValidSysPAddrArrayForDev(psBMContext->psDeviceNode, psSysAddr, WRAP_PAGE_COUNT(ui32Size, ui32Offset, ui32HostPageSize), ui32HostPageSize))
{
if(pBuf)
{
- IMG_UINT32 ui32MappingSize = HOST_PAGEALIGN (ui32Size + ui32Offset);
+ IMG_SIZE_T ui32MappingSize = HOST_PAGEALIGN (ui32Size + ui32Offset);
if(pBuf->pMapping->uSize == ui32MappingSize && (pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped ||
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (BM_BUF),
- (IMG_PVOID *)&pBuf, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pBuf, IMG_NULL,
+ "Buffer Manager buffer") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: BM_Buf alloc FAILED"));
return IMG_FALSE;
{
PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: WrapMemory FAILED"));
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL);
+
return IMG_FALSE;
}
if (!HASH_Insert (psBMContext->pBufferHash, (IMG_UINTPTR_T) sHashAddress.uiAddr, (IMG_UINTPTR_T)pBuf))
{
FreeBuf (pBuf, uFlags);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL);
PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: HASH_Insert FAILED"));
return IMG_FALSE;
}
return;
}
- if(SysAcquireData (&psSysData) != PVRSRV_OK)
- return;
+ SysAcquireData(&psSysData);
pBuf->ui32RefCount--;
ui32PSize,
pMapping->pBMHeap->sDevArena.ui32DataPageSize,
(IMG_HANDLE)pMapping,
- (IMG_BOOL)(pMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED));
+ (pMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED) ? IMG_TRUE : IMG_FALSE);
#endif
psDeviceNode = pMapping->pBMHeap->pBMContext->psDeviceNode;
- psDeviceNode->pfnMMUFree (pMapping->pBMHeap->pMMUHeap, pMapping->DevVAddr, pMapping->uSize);
+ psDeviceNode->pfnMMUFree (pMapping->pBMHeap->pMMUHeap, pMapping->DevVAddr, IMG_CAST_TO_DEVVADDR_UINT(pMapping->uSize));
}
static IMG_BOOL
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (BM_MAPPING),
- (IMG_PVOID *)&pMapping, IMG_NULL) != PVRSRV_OK)
+ (IMG_PVOID *)&pMapping, IMG_NULL,
+ "Buffer Manager Mapping") != PVRSRV_OK)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_ImportMemory: failed BM_MAPPING alloc"));
goto fail_exit;
if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
{
+ IMG_UINT32 ui32Attribs = pBMHeap->ui32Attribs;
+
+
+ if (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
+ {
+ ui32Attribs &= ~PVRSRV_HAP_CACHETYPE_MASK;
+ ui32Attribs |= (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK);
+ }
+
- if (OSAllocPages(pBMHeap->ui32Attribs,
+ if (OSAllocPages(ui32Attribs,
uPSize,
pBMHeap->sDevArena.ui32DataPageSize,
(IMG_VOID **)&pMapping->CpuVAddr,
- &pMapping->hOSMemHandle) != PVRSRV_OK)
+ &pMapping->hOSMemHandle) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,
"BM_ImportMemory: OSAllocPages(0x%x) failed",
else if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG)
{
IMG_SYS_PHYADDR sSysPAddr;
+ IMG_UINT32 ui32Attribs = pBMHeap->ui32Attribs;
+
+
+ if (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
+ {
+ ui32Attribs &= ~PVRSRV_HAP_CACHETYPE_MASK;
+ ui32Attribs |= (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK);
+ }
PVR_ASSERT(pBMHeap->pLocalDevMemArena != IMG_NULL);
pMapping->CpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
if(OSReservePhys(pMapping->CpuPAddr,
uPSize,
- pBMHeap->ui32Attribs,
+ ui32Attribs,
&pMapping->CpuVAddr,
&pMapping->hOSMemHandle) != PVRSRV_OK)
{
}
fail_mapping_alloc:
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+
fail_exit:
return IMG_FALSE;
}
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), psMapping, IMG_NULL);
+
PVR_DPF((PVR_DBG_MESSAGE,
"..BM_FreeMemory (h=%08X, base=0x%x, psMapping=0x%x)",
h, _base, psMapping));
}
-PVRSRV_ERROR BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
IMG_DEV_VIRTADDR sDevVPageAddr,
IMG_DEV_PHYADDR *psDevPAddr)
{
PVR_DPF((PVR_DBG_MESSAGE, "BM_GetPhysPageAddr"));
- if(!psMemInfo || !psDevPAddr)
- {
- PVR_DPF((PVR_DBG_ERROR, "BM_GetPhysPageAddr: Invalid params"));
- return PVRSRV_ERROR_INVALID_PARAMS;
- }
+ PVR_ASSERT (psMemInfo && psDevPAddr)
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
*psDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pMMUHeap,
sDevVPageAddr);
-
- return PVRSRV_OK;
}
#include "kernelbuffer.h"
#include "pvr_bridge_km.h"
+#include "lists.h"
+DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_INSERT(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_REMOVE(PVRSRV_DEVICE_NODE);
+
+IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va);
PVRSRV_ERROR AllocateDeviceID(SYS_DATA *psSysData, IMG_UINT32 *pui32DevID);
PVRSRV_ERROR FreeDeviceID(SYS_DATA *psSysData, IMG_UINT32 ui32DevID);
+#if defined(SUPPORT_MISR_IN_THREAD)
+void OSVSyncMISR(IMG_HANDLE, IMG_BOOL);
+#endif
+
+
typedef struct PVRSRV_DC_SRV2DISP_KMJTABLE_TAG *PPVRSRV_DC_SRV2DISP_KMJTABLE;
typedef struct PVRSRV_DC_BUFFER_TAG
return psBCPerContextInfo->psBCInfo;
}
+IMG_VOID PVRSRVEnumerateDCKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+{
+ IMG_UINT *pui32DevCount;
+ IMG_UINT32 **ppui32DevID;
+ PVRSRV_DEVICE_CLASS peDeviceClass;
+
+ pui32DevCount = va_arg(va, IMG_UINT*);
+ ppui32DevID = va_arg(va, IMG_UINT32**);
+ peDeviceClass = va_arg(va, PVRSRV_DEVICE_CLASS);
+
+ if ((psDeviceNode->sDevId.eDeviceClass == peDeviceClass)
+ && (psDeviceNode->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_EXT))
+ {
+ (*pui32DevCount)++;
+ if(*ppui32DevID)
+ {
+ *(*ppui32DevID++) = psDeviceNode->sDevId.ui32DeviceIndex;
+ }
+ }
+}
+
IMG_EXPORT
PVRSRV_ERROR PVRSRVEnumerateDCKM (PVRSRV_DEVICE_CLASS DeviceClass,
IMG_UINT32 *pui32DevCount,
IMG_UINT32 *pui32DevID )
{
- PVRSRV_DEVICE_NODE *psDeviceNode;
+
IMG_UINT ui32DevCount = 0;
SYS_DATA *psSysData;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDCKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
-
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode)
- {
- if ((psDeviceNode->sDevId.eDeviceClass == DeviceClass)
- && (psDeviceNode->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_EXT))
- {
- ui32DevCount++;
- if(pui32DevID)
- {
- *pui32DevID++ = psDeviceNode->sDevId.ui32DeviceIndex;
- }
- }
- psDeviceNode = psDeviceNode->psNext;
- }
+ List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+ PVRSRVEnumerateDCKM_ForEachVaCb,
+ &ui32DevCount,
+ &pui32DevID,
+ DeviceClass);
if(pui32DevCount)
{
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psDCInfo),
- (IMG_VOID **)&psDCInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDCInfo, IMG_NULL,
+ "Display Class Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psDCInfo alloc"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE),
- (IMG_VOID **)&psDCInfo->psFuncTable, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDCInfo->psFuncTable, IMG_NULL,
+ "Function table for SRVKM->DISPLAY") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psFuncTable alloc"));
goto ErrorExit;
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE),
- (IMG_VOID **)&psDeviceNode, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDeviceNode, IMG_NULL,
+ "Device Node") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psDeviceNode alloc"));
goto ErrorExit;
psDeviceNode->psSysData = psSysData;
- AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex);
+ if (AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to allocate Device ID"));
+ goto ErrorExit;
+ }
psDCInfo->ui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
if (pui32DeviceID)
{
SysRegisterExternalDevice(psDeviceNode);
- psDeviceNode->psNext = psSysData->psDeviceNodeList;
- psSysData->psDeviceNodeList = psDeviceNode;
+ List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
return PVRSRV_OK;
if(psDCInfo->psFuncTable)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE), psDCInfo->psFuncTable, IMG_NULL);
+ psDCInfo->psFuncTable = IMG_NULL;
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_INFO), psDCInfo, IMG_NULL);
+
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
-
PVRSRV_ERROR PVRSRVRemoveDCDeviceKM(IMG_UINT32 ui32DevIndex)
{
SYS_DATA *psSysData;
- PVRSRV_DEVICE_NODE **ppsDeviceNode, *psDeviceNode;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- ppsDeviceNode = &psSysData->psDeviceNodeList;
- while(*ppsDeviceNode)
+
+ psDeviceNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ MatchDeviceKM_AnyVaCb,
+ ui32DevIndex,
+ IMG_FALSE,
+ PVRSRV_DEVICE_CLASS_DISPLAY);
+ if (!psDeviceNode)
{
- switch((*ppsDeviceNode)->sDevId.eDeviceClass)
- {
- case PVRSRV_DEVICE_CLASS_DISPLAY :
- {
- if((*ppsDeviceNode)->sDevId.ui32DeviceIndex == ui32DevIndex)
- {
- goto FoundDevice;
- }
- break;
- }
- default:
- {
- break;
- }
- }
- ppsDeviceNode = &((*ppsDeviceNode)->psNext);
+
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: requested device %d not present", ui32DevIndex));
+ return PVRSRV_ERROR_GENERIC;
}
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: requested device %d not present", ui32DevIndex));
-
- return PVRSRV_ERROR_GENERIC;
-
-FoundDevice:
-
- psDeviceNode = *ppsDeviceNode;
psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
{
- *ppsDeviceNode = psDeviceNode->psNext;
-
+ List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
+
SysRemoveExternalDevice(psDeviceNode);
PVR_ASSERT(psDCInfo->ui32RefCount == 0);
- FreeDeviceID(psSysData, ui32DevIndex);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psDCInfo->psFuncTable, IMG_NULL);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psDCInfo, IMG_NULL);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psDeviceNode, IMG_NULL);
+ (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE), psDCInfo->psFuncTable, IMG_NULL);
+ psDCInfo->psFuncTable = IMG_NULL;
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_INFO), psDCInfo, IMG_NULL);
+
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
+
}
else
{
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psBCInfo),
- (IMG_VOID **)&psBCInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psBCInfo, IMG_NULL,
+ "Buffer Class Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psBCInfo alloc"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE),
- (IMG_VOID **)&psBCInfo->psFuncTable, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psBCInfo->psFuncTable, IMG_NULL,
+ "Function table for SRVKM->BUFFER") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psFuncTable alloc"));
goto ErrorExit;
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE),
- (IMG_VOID **)&psDeviceNode, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDeviceNode, IMG_NULL,
+ "Device Node") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psDeviceNode alloc"));
goto ErrorExit;
psDeviceNode->psSysData = psSysData;
- AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex);
+ if (AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to allocate Device ID"));
+ goto ErrorExit;
+ }
psBCInfo->ui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
if (pui32DeviceID)
{
}
- psDeviceNode->psNext = psSysData->psDeviceNodeList;
- psSysData->psDeviceNodeList = psDeviceNode;
+ List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
return PVRSRV_OK;
if(psBCInfo->psFuncTable)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PPVRSRV_BC_SRV2BUFFER_KMJTABLE), psBCInfo->psFuncTable, IMG_NULL);
+ psBCInfo->psFuncTable = IMG_NULL;
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_INFO), psBCInfo, IMG_NULL);
+
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
PVRSRV_ERROR PVRSRVRemoveBCDeviceKM(IMG_UINT32 ui32DevIndex)
{
SYS_DATA *psSysData;
- PVRSRV_DEVICE_NODE **ppsDevNode, *psDevNode;
+ PVRSRV_DEVICE_NODE *psDevNode;
PVRSRV_BUFFERCLASS_INFO *psBCInfo;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- ppsDevNode = &psSysData->psDeviceNodeList;
- while(*ppsDevNode)
+
+ psDevNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ MatchDeviceKM_AnyVaCb,
+ ui32DevIndex,
+ IMG_FALSE,
+ PVRSRV_DEVICE_CLASS_BUFFER);
+
+ if (!psDevNode)
{
- switch((*ppsDevNode)->sDevId.eDeviceClass)
- {
- case PVRSRV_DEVICE_CLASS_BUFFER :
- {
- if((*ppsDevNode)->sDevId.ui32DeviceIndex == ui32DevIndex)
- {
- goto FoundDevice;
- }
- break;
- }
- default:
- {
- break;
- }
- }
- ppsDevNode = &(*ppsDevNode)->psNext;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: requested device %d not present", ui32DevIndex));
+ return PVRSRV_ERROR_GENERIC;
}
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: requested device %d not present", ui32DevIndex));
-
- return PVRSRV_ERROR_GENERIC;
-
-FoundDevice:
-
- psDevNode = *(ppsDevNode);
psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDevNode->pvDevice;
{
- *ppsDevNode = psDevNode->psNext;
-
+ List_PVRSRV_DEVICE_NODE_Remove(psDevNode);
+
- FreeDeviceID(psSysData, ui32DevIndex);
- psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDevNode->pvDevice;
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psBCInfo->psFuncTable, IMG_NULL);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psBCInfo, IMG_NULL);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psDevNode, IMG_NULL);
+ (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+
+
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE), psBCInfo->psFuncTable, IMG_NULL);
+ psBCInfo->psFuncTable = IMG_NULL;
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_INFO), psBCInfo, IMG_NULL);
+
+ (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDevNode, IMG_NULL);
+
}
else
{
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO), psDCPerContextInfo, IMG_NULL);
+
return PVRSRV_OK;
}
PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
+ PVRSRV_ERROR eError;
if(!phDeviceKM || !hDevCookie)
{
return PVRSRV_ERROR_GENERIC;
}
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode)
+
+ psDeviceNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ MatchDeviceKM_AnyVaCb,
+ ui32DeviceID,
+ IMG_FALSE,
+ PVRSRV_DEVICE_CLASS_DISPLAY);
+ if (!psDeviceNode)
{
- if ((psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY) &&
- (psDeviceNode->sDevId.ui32DeviceIndex == ui32DeviceID))
- {
-
-
-
- psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
- goto FoundDevice;
- }
- psDeviceNode = psDeviceNode->psNext;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: no devnode matching index %d", ui32DeviceID));
+ return PVRSRV_ERROR_GENERIC;
}
-
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: no devnode matching index %d", ui32DeviceID));
-
- return PVRSRV_ERROR_GENERIC;
-
-FoundDevice:
+ psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psDCPerContextInfo),
- (IMG_VOID **)&psDCPerContextInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDCPerContextInfo, IMG_NULL,
+ "Display Class per Context Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Failed psDCPerContextInfo alloc"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
if(psDCInfo->ui32RefCount++ == 0)
{
- PVRSRV_ERROR eError;
psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL);
+
return eError;
}
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DC_SWAPCHAIN),
- (IMG_VOID **)&psSwapChain, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psSwapChain, IMG_NULL,
+ "Display Class Swapchain") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed psSwapChain alloc"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
if(psSwapChain)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL);
+
}
return eError;
goto ProcessedQueues;
}
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
- } END_LOOP_UNTIL_TIMEOUT();
+ } END_LOOP_UNTIL_TIMEOUT();
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to process queues"));
{
goto ProcessedQueues;
}
+
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
} END_LOOP_UNTIL_TIMEOUT();
PVR_UNREFERENCED_PARAMETER(ui32ISRSourceMask);
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterSystemISRHandler: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- psDevNode = psSysData->psDeviceNodeList;
- while(psDevNode)
- {
- if(psDevNode->sDevId.ui32DeviceIndex == ui32DeviceID)
- {
- break;
- }
- psDevNode = psDevNode->psNext;
- }
+ psDevNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ MatchDeviceKM_AnyVaCb,
+ ui32DeviceID,
+ IMG_TRUE);
if (psDevNode == IMG_NULL)
{
return PVRSRV_OK;
}
+IMG_VOID PVRSRVSetDCState_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+{
+ PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+ IMG_UINT32 ui32State;
+ ui32State = va_arg(va, IMG_UINT32);
+
+ if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
+ {
+ psDCInfo = (PVRSRV_DISPLAYCLASS_INFO *)psDeviceNode->pvDevice;
+ if (psDCInfo->psFuncTable->pfnSetDCState && psDCInfo->hExtDevice)
+ {
+ psDCInfo->psFuncTable->pfnSetDCState(psDCInfo->hExtDevice, ui32State);
+ }
+ }
+}
+
IMG_VOID IMG_CALLCONV PVRSRVSetDCState(IMG_UINT32 ui32State)
{
- PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
- PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCState: Failed to get SysData"));
- return;
- }
+ SysAcquireData(&psSysData);
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode != IMG_NULL)
- {
- if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
- {
- psDCInfo = (PVRSRV_DISPLAYCLASS_INFO *)psDeviceNode->pvDevice;
- if (psDCInfo->psFuncTable->pfnSetDCState && psDCInfo->hExtDevice)
- {
- psDCInfo->psFuncTable->pfnSetDCState(psDCInfo->hExtDevice, ui32State);
- }
- }
- psDeviceNode = psDeviceNode->psNext;
- }
+ List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+ PVRSRVSetDCState_ForEachVaCb,
+ ui32State);
}
psJTable->pfnPVRSRVOEMFunction = SysOEMFunction;
psJTable->pfnPVRSRVRegisterCmdProcList = PVRSRVRegisterCmdProcListKM;
psJTable->pfnPVRSRVRemoveCmdProcList = PVRSRVRemoveCmdProcListKM;
- psJTable->pfnPVRSRVCmdComplete = PVRSRVCommandCompleteKM;
+#if defined(SUPPORT_MISR_IN_THREAD)
+ psJTable->pfnPVRSRVCmdComplete = OSVSyncMISR;
+#else
+ psJTable->pfnPVRSRVCmdComplete = PVRSRVCommandCompleteKM;
+#endif
psJTable->pfnPVRSRVRegisterSystemISRHandler = PVRSRVRegisterSystemISRHandler;
psJTable->pfnPVRSRVRegisterPowerDevice = PVRSRVRegisterPowerDevice;
-
+
return IMG_TRUE;
}
if(psBCInfo->psBuffer)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER), psBCInfo->psBuffer, IMG_NULL);
+ psBCInfo->psBuffer = IMG_NULL;
}
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_PERCONTEXT_INFO), psBCPerContextInfo, IMG_NULL);
+
return PVRSRV_OK;
}
return PVRSRV_ERROR_GENERIC;
}
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to get SysData"));
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode)
+ psDeviceNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ MatchDeviceKM_AnyVaCb,
+ ui32DeviceID,
+ IMG_FALSE,
+ PVRSRV_DEVICE_CLASS_BUFFER);
+ if (!psDeviceNode)
{
- if ((psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_BUFFER) &&
- (psDeviceNode->sDevId.ui32DeviceIndex == ui32DeviceID))
- {
-
-
-
- psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDeviceNode->pvDevice;
- goto FoundDevice;
- }
- psDeviceNode = psDeviceNode->psNext;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: No devnode matching index %d", ui32DeviceID));
+ return PVRSRV_ERROR_GENERIC;
}
-
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: No devnode matching index %d", ui32DeviceID));
-
- return PVRSRV_ERROR_GENERIC;
-
-FoundDevice:
-
+ psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDeviceNode->pvDevice;
+
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psBCPerContextInfo),
- (IMG_VOID **)&psBCPerContextInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psBCPerContextInfo, IMG_NULL,
+ "Buffer Class per Context Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed psBCPerContextInfo alloc"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_BC_BUFFER) * sBufferInfo.ui32BufferCount,
(IMG_VOID **)&psBCInfo->psBuffer,
- IMG_NULL);
+ IMG_NULL,
+ "Array of Buffer Class Buffer");
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to allocate BC buffers"));
if(psBCInfo->psBuffer)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER), psBCInfo->psBuffer, IMG_NULL);
+ psBCInfo->psBuffer = IMG_NULL;
}
return eError;
static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE hDevCookie,
IMG_HANDLE hDevMemHeap,
IMG_UINT32 ui32Flags,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32Alignment,
+ IMG_SIZE_T ui32Size,
+ IMG_SIZE_T ui32Alignment,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo);
typedef struct _RESMAN_MAP_DEVICE_MEM_DATA_
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapsKM(IMG_HANDLE hDevCookie,
- PVRSRV_HEAP_INFO *psHeapInfo
- )
+ PVRSRV_HEAP_INFO *psHeapInfo)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
IMG_UINT32 ui32HeapCount;
static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE hDevCookie,
IMG_HANDLE hDevMemHeap,
IMG_UINT32 ui32Flags,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32Alignment,
+ IMG_SIZE_T ui32Size,
+ IMG_SIZE_T ui32Alignment,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo;
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
- (IMG_VOID **)&psMemInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psMemInfo, IMG_NULL,
+ "Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"AllocDeviceMem: Failed to alloc memory for block"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
IMG_NULL,
ui32Size,
&psMemInfo->ui32Flags,
- ui32Alignment,
+ IMG_CAST_TO_DEVVADDR_UINT(ui32Alignment),
&hBuffer);
if (!bBMError)
{
PVR_DPF((PVR_DBG_ERROR,"AllocDeviceMem: BM_Alloc Failed"));
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, psMemInfo->ui32AllocSize, psMemInfo->pvSysBackupBuffer, IMG_NULL);
+ psMemInfo->pvSysBackupBuffer = IMG_NULL;
}
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
return(PVRSRV_OK);
}
eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_SYNC_INFO),
- (IMG_VOID **)&psKernelSyncInfo, IMG_NULL);
+ (IMG_VOID **)&psKernelSyncInfo, IMG_NULL,
+ "Kernel Synchronization Info");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSyncInfoKM: Failed to alloc memory"));
PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSyncInfoKM: Failed to alloc memory"));
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL);
+
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psKernelSyncInfo->psSyncDataMemInfoKM,
0,
psKernelSyncInfo->psSyncDataMemInfoKM->ui32AllocSize,
- 0,
+ PDUMP_FLAGS_CONTINUOUS,
MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
#endif
psKernelSyncInfo->psSyncDataMemInfoKM->psKernelSyncInfo = IMG_NULL;
+ psKernelSyncInfo->hResItem = IMG_NULL;
+
+
*ppsKernelSyncInfo = psKernelSyncInfo;
return PVRSRV_OK;
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfoKM(PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo)
{
- FreeDeviceMem(psKernelSyncInfo->psSyncDataMemInfoKM);
- OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL);
+ PVRSRV_ERROR eError;
+
+ eError = FreeDeviceMem(psKernelSyncInfo->psSyncDataMemInfoKM);
+ (IMG_VOID)OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL);
+
- return PVRSRV_OK;
+ return eError;
}
PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie,
PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(hDevCookie);
else
{
- FreeDeviceMemCallBack(psMemInfo, 0);
+ eError = FreeDeviceMemCallBack(psMemInfo, 0);
}
return eError;
IMG_EXPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie,
+PVRSRV_ERROR IMG_CALLCONV _PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie,
PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevMemHeap,
IMG_UINT32 ui32Flags,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32Alignment,
+ IMG_SIZE_T ui32Size,
+ IMG_SIZE_T ui32Alignment,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo;
return PVRSRV_ERROR_INVALID_PARAMS;
}
+
+ if (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
+ {
+ if (((ui32Size % HOST_PAGESIZE()) != 0) ||
+ ((ui32Alignment % HOST_PAGESIZE()) != 0))
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+ }
+
eError = AllocDeviceMem(hDevCookie,
hDevMemHeap,
ui32Flags,
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetFreeDeviceMemKM(IMG_UINT32 ui32Flags,
- IMG_UINT32 *pui32Total,
- IMG_UINT32 *pui32Free,
- IMG_UINT32 *pui32LargestBlock)
+ IMG_SIZE_T *pui32Total,
+ IMG_SIZE_T *pui32Free,
+ IMG_SIZE_T *pui32LargestBlock)
{
if(psMemInfo->sMemBlk.psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
+ psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
}
if (eError == PVRSRV_OK)
PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE hDevCookie,
PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevMemContext,
- IMG_UINT32 ui32ByteSize,
- IMG_UINT32 ui32PageOffset,
+ IMG_SIZE_T ui32ByteSize,
+ IMG_SIZE_T ui32PageOffset,
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psExtSysPAddr,
IMG_VOID *pvLinAddr,
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
- IMG_UINT32 ui32HostPageSize = HOST_PAGESIZE();
- IMG_HANDLE hDevMemHeap = IMG_NULL;
+ IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
+ IMG_HANDLE hDevMemHeap = IMG_NULL;
PVRSRV_DEVICE_NODE* psDeviceNode;
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_SYS_PHYADDR *psIntSysPAddr = IMG_NULL;
IMG_HANDLE hOSWrapMem = IMG_NULL;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
- IMG_UINT32 ui32PageCount = 0;
+ IMG_SIZE_T ui32PageCount = 0;
IMG_UINT32 i;
psDeviceNode = (PVRSRV_DEVICE_NODE*)hDevCookie;
if(pvLinAddr)
{
- ui32PageOffset = (IMG_UINT32)pvLinAddr & (ui32HostPageSize - 1);
+ ui32PageOffset = (IMG_UINTPTR_T)pvLinAddr & (ui32HostPageSize - 1);
ui32PageCount = HOST_PAGEALIGN(ui32ByteSize + ui32PageOffset) / ui32HostPageSize;
- pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINT8 *)pvLinAddr - ui32PageOffset);
+ pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvLinAddr - ui32PageOffset);
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageCount * sizeof(IMG_SYS_PHYADDR),
- (IMG_VOID **)&psIntSysPAddr, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psIntSysPAddr, IMG_NULL,
+ "Array of Page Addresses") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO),
- (IMG_VOID **)&psMemInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psMemInfo, IMG_NULL,
+ "Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
if(psMemInfo)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
}
ErrorExitPhase2:
if(psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageCount * sizeof(IMG_SYS_PHYADDR), psIntSysPAddr, IMG_NULL);
+
}
return eError;
if(psMapData->psMemInfo->sMemBlk.psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMapData->psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
+ psMapData->psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
}
eError = FreeDeviceMem(psMapData->psMemInfo);
psMapData->psSrcMemInfo->ui32RefCount--;
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psMapData, IMG_NULL);
+ if (psMapData->psSrcMemInfo->ui32RefCount == 1 &&
+ psMapData->psSrcMemInfo->bPendingFree == IMG_TRUE)
+ {
+
+
+
+ if (psMapData->psSrcMemInfo->sMemBlk.hResItem != IMG_NULL)
+ {
+
+
+ eError = ResManFreeResByPtr(psMapData->psSrcMemInfo->sMemBlk.hResItem);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free SRC meminfo"));
+ PVR_DBG_BREAK;
+ }
+ }
+ else
+ {
+
+ eError = FreeDeviceMemCallBack(psMapData->psSrcMemInfo, 0);
+ }
+ }
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
+
return eError;
}
{
PVRSRV_ERROR eError;
IMG_UINT32 i;
- IMG_UINT32 ui32PageCount, ui32PageOffset;
- IMG_UINT32 ui32HostPageSize = HOST_PAGESIZE();
+ IMG_SIZE_T ui32PageCount, ui32PageOffset;
+ IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
IMG_SYS_PHYADDR *psSysPAddr = IMG_NULL;
IMG_DEV_PHYADDR sDevPAddr;
BM_BUF *psBuf;
ui32PageOffset = psSrcMemInfo->sDevVAddr.uiAddr & (ui32HostPageSize - 1);
ui32PageCount = HOST_PAGEALIGN(psSrcMemInfo->ui32AllocSize + ui32PageOffset) / ui32HostPageSize;
- pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINT8 *)psSrcMemInfo->pvLinAddrKM - ui32PageOffset);
+ pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)psSrcMemInfo->pvLinAddrKM - ui32PageOffset);
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageCount*sizeof(IMG_SYS_PHYADDR),
- (IMG_VOID **)&psSysPAddr, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psSysPAddr, IMG_NULL,
+ "Array of Page Addresses") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc memory for block"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
psDeviceNode = psBuf->pMapping->pBMHeap->pBMContext->psDeviceNode;
- sDevVAddr.uiAddr = psSrcMemInfo->sDevVAddr.uiAddr - ui32PageOffset;
+ sDevVAddr.uiAddr = psSrcMemInfo->sDevVAddr.uiAddr - IMG_CAST_TO_DEVVADDR_UINT(ui32PageOffset);
for(i=0; i<ui32PageCount; i++)
{
- eError = BM_GetPhysPageAddr(psSrcMemInfo, sDevVAddr, &sDevPAddr);
- if(eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to retrieve page list from device"));
- goto ErrorExit;
- }
+ BM_GetPhysPageAddr(psSrcMemInfo, sDevVAddr, &sDevPAddr);
psSysPAddr[i] = SysDevPAddrToSysPAddr (psDeviceNode->sDevId.eDeviceType, sDevPAddr);
- sDevVAddr.uiAddr += ui32HostPageSize;
+ sDevVAddr.uiAddr += IMG_CAST_TO_DEVVADDR_UINT(ui32HostPageSize);
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(RESMAN_MAP_DEVICE_MEM_DATA),
- (IMG_VOID **)&psMapData, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psMapData, IMG_NULL,
+ "Resource Manager Map Data") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc resman map data"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
- (IMG_VOID **)&psMemInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psMemInfo, IMG_NULL,
+ "Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc memory for block"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+ psMemInfo->ui32Flags = psSrcMemInfo->ui32Flags;
psMemBlock = &(psMemInfo->sMemBlk);
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psSysPAddr, IMG_NULL);
+
}
if(psMemInfo)
{
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
}
if(psMapData)
{
- OSFreeMem(PVRSRV_PAGEABLE_SELECT, 0, psMapData, IMG_NULL);
+ OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
+
}
return eError;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
IMG_HANDLE hDevMemHeap = IMG_NULL;
- IMG_UINT32 ui32ByteSize;
- IMG_UINT32 ui32Offset;
- IMG_UINT32 ui32PageSize = HOST_PAGESIZE();
+ IMG_SIZE_T ui32ByteSize;
+ IMG_SIZE_T ui32Offset;
+ IMG_SIZE_T ui32PageSize = HOST_PAGESIZE();
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
}
- ui32Offset = ((IMG_UINT32)pvCPUVAddr) & (ui32PageSize - 1);
- pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINT8 *)pvCPUVAddr - ui32Offset);
+ ui32Offset = ((IMG_UINTPTR_T)pvCPUVAddr) & (ui32PageSize - 1);
+ pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvCPUVAddr - ui32Offset);
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
- (IMG_VOID **)&psMemInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psMemInfo, IMG_NULL,
+ "Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for block"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: BM_Wrap Failed"));
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
return PVRSRV_ERROR_BAD_MAPPING;
}
#include "services_headers.h"
#include "handle.h"
-#ifdef DEBUG
+#ifdef DEBUG_PVR
#define HANDLE_BLOCK_SIZE 1
#else
#define HANDLE_BLOCK_SIZE 256
#define INDEX_TO_HANDLE_PTR(psBase, i) (((psBase)->psHandleArray) + (i))
#define HANDLE_TO_HANDLE_PTR(psBase, h) (INDEX_TO_HANDLE_PTR(psBase, HANDLE_TO_INDEX(psBase, h)))
-#define HANDLE_PTR_TO_INDEX(psBase, psHandle) ((psHandle) - ((psBase)->psHandleArray))
+#define HANDLE_PTR_TO_INDEX(psBase, psHandle) (IMG_UINT32)((psHandle) - ((psBase)->psHandleArray))
#define HANDLE_PTR_TO_HANDLE(psBase, psHandle) \
INDEX_TO_HANDLE(psBase, HANDLE_PTR_TO_INDEX(psBase, psHandle))
bIsEmpty = (IMG_BOOL)(psList->ui32Next == ui32Index);
-#ifdef DEBUG
+#ifdef DEBUG_PVR
{
IMG_BOOL bIsEmpty2;
return bIsEmpty;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
#ifdef INLINE_IS_PRAGMA
#pragma inline(NoChildren)
#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);
{
IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psBase, psParent->sChildren.hParent);
- PVR_ASSERT(ui32Parent == (IMG_UINT32)HANDLE_PTR_TO_INDEX(psBase, psParent));
+ PVR_ASSERT(ui32Parent == HANDLE_PTR_TO_INDEX(psBase, psParent));
HandleListInsertBefore(psBase, ui32Parent, &psParent->sChildren, offsetof(struct sHandle, sChildren), HANDLE_PTR_TO_INDEX(psBase, psChild), &psChild->sSiblings, offsetof(struct sHandle, sSiblings), ui32Parent);
{
if (!HandleListIsEmpty(ui32EntryIndex, psEntry))
{
+
struct sHandleList *psPrev = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Prev, HANDLE_TO_INDEX(psBase, psEntry->hParent), uiParentOffset, uiEntryOffset);
struct sHandleList *psNext = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Next, HANDLE_TO_INDEX(psBase, psEntry->hParent), uiParentOffset, uiEntryOffset);
for(ui32Index = psHead->ui32Next; ui32Index != ui32Parent; )
{
struct sHandle *psHandle = INDEX_TO_HANDLE_PTR(psBase, ui32Index);
+
struct sHandleList *psEntry = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32Index, ui32Parent, uiParentOffset, uiEntryOffset);
PVRSRV_ERROR eError;
if (BATCHED_HANDLE(psHandle) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
+
SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle);
return PVRSRV_OK;
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32NewSize,
&pvNewMem,
- &hNewBlockAlloc);
+ &hNewBlockAlloc,
+ "Memory Area");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ReallocMem: Couldn't allocate new memory area (%d)", eError));
psNewHandle->ui32Index = ui32NewIndex;
InitParentList(psBase, psNewHandle);
+#if defined(DEBUG_PVR)
PVR_ASSERT(NoChildren(psBase, psNewHandle));
+#endif
InitChildEntry(psBase, psNewHandle);
+#if defined(DEBUG_PVR)
PVR_ASSERT(NoParent(psBase, psNewHandle));
+#endif
if (HANDLES_BATCHED(psBase))
{
psBase->ui32FirstBatchIndexPlusOne = ui32NewIndex + 1;
+
SET_BATCHED_HANDLE(psNewHandle);
}
else
if (!BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
- SET_UNBATCHED_HANDLE(psHandle);
+ SET_UNBATCHED_HANDLE(psHandle);
}
eError = FreeHandle(psBase, psHandle);
}
else
{
- SET_UNBATCHED_HANDLE(psHandle);
+ SET_UNBATCHED_HANDLE(psHandle);
}
ui32IndexPlusOne = ui32NextIndexPlusOne;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
if (psBase->ui32TotalHandCountPreBatch != psBase->ui32TotalHandCount)
{
IMG_UINT32 ui32Delta = psBase->ui32TotalHandCount - psBase->ui32TotalHandCountPreBatch;
}
- if (ui32MaxHandle == 0 || ui32MaxHandle > DEFAULT_MAX_HANDLE)
+ 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));
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psBase),
(IMG_PVOID *)&psBase,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "Handle Base");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't allocate handle base (%d)", eError));
IMG_UINTPTR_T v;
- IMG_UINTPTR_T k[];
+ IMG_UINTPTR_T k[];
};
typedef struct _BUCKET_ BUCKET;
return PVRSRV_ERROR_INVALID_PARAMS;
}
- uIndex = KEY_TO_INDEX(pHash, pBucket->k, uSize);
+ uIndex = KEY_TO_INDEX(pHash, pBucket->k, uSize);
pBucket->pNext = ppBucketTable[uIndex];
ppBucketTable[uIndex] = pBucket;
"HASH_Resize: oldsize=0x%x newsize=0x%x count=0x%x",
pHash->uSize, uNewSize, pHash->uCount));
- OSAllocMem (PVRSRV_PAGEABLE_SELECT,
+ OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof (BUCKET *) * uNewSize,
- (IMG_PVOID*)&ppNewTable, IMG_NULL);
+ (IMG_PVOID*)&ppNewTable, IMG_NULL,
+ "Hash Table Buckets");
if (ppNewTable == IMG_NULL)
return IMG_FALSE;
return IMG_FALSE;
}
- OSFreeMem (PVRSRV_PAGEABLE_SELECT, 0, pHash->ppBucketTable, IMG_NULL);
+ OSFreeMem (PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET *)*pHash->uSize, pHash->ppBucketTable, IMG_NULL);
+
pHash->ppBucketTable = ppNewTable;
pHash->uSize = uNewSize;
}
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(HASH_TABLE),
- (IMG_VOID **)&pHash, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pHash, IMG_NULL,
+ "Hash Table") != PVRSRV_OK)
{
return IMG_NULL;
}
pHash->pfnHashFunc = pfnHashFunc;
pHash->pfnKeyComp = pfnKeyComp;
- OSAllocMem (PVRSRV_PAGEABLE_SELECT,
+ OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof (BUCKET *) * pHash->uSize,
- (IMG_PVOID*)&pHash->ppBucketTable, IMG_NULL);
+ (IMG_PVOID*)&pHash->ppBucketTable, IMG_NULL,
+ "Hash Table Buckets");
if (pHash->ppBucketTable == IMG_NULL)
{
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(HASH_TABLE), pHash, IMG_NULL);
+
return IMG_NULL;
}
PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Delete"));
PVR_ASSERT (pHash->uCount==0);
- OSFreeMem(PVRSRV_PAGEABLE_SELECT, 0, pHash->ppBucketTable, IMG_NULL);
+ if(pHash->uCount != 0)
+ {
+ PVR_DPF ((PVR_DBG_ERROR, "HASH_Delete: leak detected in hash table!"));
+ PVR_DPF ((PVR_DBG_ERROR, "Likely Cause: client drivers not freeing alocations before destroying devmemcontext"));
+ }
+ OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET *)*pHash->uSize, pHash->ppBucketTable, IMG_NULL);
+ pHash->ppBucketTable = IMG_NULL;
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(HASH_TABLE), pHash, IMG_NULL);
+
}
}
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(BUCKET) + pHash->uKeySize,
- (IMG_VOID **)&pBucket, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pBucket, IMG_NULL,
+ "Hash Table entry") != PVRSRV_OK)
{
return IMG_FALSE;
}
pBucket->v = v;
+
OSMemCopy(pBucket->k, pKey, pHash->uKeySize);
if (_ChainInsert (pHash, pBucket, pHash->ppBucketTable, pHash->uSize) != PVRSRV_OK)
{
BUCKET **ppBucket;
IMG_UINT32 uIndex;
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove: Hash=%08X, pKey=%08X", pHash, pKey));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove_Extended: Hash=%08X, pKey=%08X", pHash, pKey));
PVR_ASSERT (pHash != IMG_NULL);
if (pHash == IMG_NULL)
{
- PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: invalid parameter"));
+ PVR_DPF((PVR_DBG_ERROR, "HASH_Remove_Extended: Null hash table"));
return 0;
}
for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext))
{
+
if (KEY_COMPARE(pHash, (*ppBucket)->k, pKey))
{
BUCKET *pBucket = *ppBucket;
(*ppBucket) = pBucket->pNext;
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET) + pHash->uKeySize, pBucket, IMG_NULL);
+
pHash->uCount--;
BUCKET **ppBucket;
IMG_UINT32 uIndex;
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve: Hash=%08X, pKey=%08X", pHash,pKey));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve_Extended: Hash=%08X, pKey=%08X", pHash,pKey));
PVR_ASSERT (pHash != IMG_NULL);
if (pHash == IMG_NULL)
{
- PVR_DPF((PVR_DBG_ERROR, "HASH_Retrieve_Extended: invalid parameter"));
+ PVR_DPF((PVR_DBG_ERROR, "HASH_Retrieve_Extended: Null hash table"));
return 0;
}
for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext))
{
+
if (KEY_COMPARE(pHash, (*ppBucket)->k, pKey))
{
BUCKET *pBucket = *ppBucket;
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 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
+ *
+ ******************************************************************************/
+
+#include "lists.h"
+#include "services_headers.h"
+
+IMPLEMENT_LIST_ANY_VA(BM_HEAP)
+IMPLEMENT_LIST_ANY_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_ANY_VA_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH_VA(BM_HEAP)
+IMPLEMENT_LIST_REMOVE(BM_HEAP)
+IMPLEMENT_LIST_INSERT(BM_HEAP)
+
+IMPLEMENT_LIST_ANY_VA(BM_CONTEXT)
+IMPLEMENT_LIST_ANY_VA_2(BM_CONTEXT, IMG_HANDLE, IMG_NULL)
+IMPLEMENT_LIST_ANY_VA_2(BM_CONTEXT, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH(BM_CONTEXT)
+IMPLEMENT_LIST_REMOVE(BM_CONTEXT)
+IMPLEMENT_LIST_INSERT(BM_CONTEXT)
+
+IMPLEMENT_LIST_ANY_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_ANY_VA(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_ANY_VA_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_INSERT(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_REMOVE(PVRSRV_DEVICE_NODE)
+
+IMPLEMENT_LIST_ANY_VA(PVRSRV_POWER_DEV)
+IMPLEMENT_LIST_ANY_VA_2(PVRSRV_POWER_DEV, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_INSERT(PVRSRV_POWER_DEV)
+IMPLEMENT_LIST_REMOVE(PVRSRV_POWER_DEV)
+
+
+IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va)
+{
+ IMG_UINT32 ui32DevIndex;
+ IMG_BOOL bIgnoreClass;
+ PVRSRV_DEVICE_CLASS eDevClass;
+
+ ui32DevIndex = va_arg(va, IMG_UINT32);
+ bIgnoreClass = va_arg(va, IMG_BOOL);
+ if (!bIgnoreClass)
+ {
+ eDevClass = va_arg(va, PVRSRV_DEVICE_CLASS);
+ }
+ else
+ {
+
+
+ eDevClass = PVRSRV_DEVICE_CLASS_FORCE_I32;
+ }
+
+ if ((bIgnoreClass || psDeviceNode->sDevId.eDeviceClass == eDevClass) &&
+ psDeviceNode->sDevId.ui32DeviceIndex == ui32DevIndex)
+ {
+ return psDeviceNode;
+ }
+ return IMG_NULL;
+}
+
+IMG_VOID* MatchPowerDeviceIndex_AnyVaCb(PVRSRV_POWER_DEV *psPowerDev, va_list va)
+{
+ IMG_UINT32 ui32DeviceIndex;
+
+ ui32DeviceIndex = va_arg(va, IMG_UINT32);
+
+ if (psPowerDev->ui32DeviceIndex == ui32DeviceIndex)
+ {
+ return psPowerDev;
+ }
+ else
+ {
+ return IMG_NULL;
+ }
+}
******************************************************************************/
#include "services_headers.h"
-
-#if defined(SUPPORT_VGX)
-#include "vgxapi_km.h"
-#endif
-
-#if defined(SUPPORT_SGX)
-#include "sgxapi_km.h"
-#endif
-
#include "pvr_bridge_km.h"
sizeof(PVRSRV_KERNEL_MEM_INFO),
psKernelMemInfo,
IMG_NULL);
+
return PVRSRV_OK;
}
IMG_EXPORT PVRSRV_ERROR
PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_UINT32 ui32Flags,
- IMG_UINT32 ui32Size,
+ IMG_SIZE_T ui32Size,
PVRSRV_KERNEL_MEM_INFO **ppsKernelMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO),
- (IMG_VOID **)&psKernelMemInfo, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psKernelMemInfo, IMG_NULL,
+ "Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for meminfo"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 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
+ *
+ ******************************************************************************/
+
+#ifndef MEM_DEBUG_C
+#define MEM_DEBUG_C
+
+#if defined(PVRSRV_DEBUG_OS_MEMORY)
+
+#include "img_types.h"
+#include "services_headers.h"
+
+#if defined (__cplusplus)
+extern "C"
+{
+#endif
+
+#define STOP_ON_ERROR 0
+
+
+
+
+
+
+
+
+
+ IMG_BOOL MemCheck(const IMG_PVOID pvAddr, const IMG_UINT8 ui8Pattern, IMG_SIZE_T uSize)
+ {
+ IMG_UINT8 *pui8Addr;
+ for (pui8Addr = (IMG_UINT8*)pvAddr; uSize > 0; uSize--, pui8Addr++)
+ {
+ if (*pui8Addr != ui8Pattern)
+ {
+ return IMG_FALSE;
+ }
+ }
+ return IMG_TRUE;
+ }
+
+
+
+ IMG_VOID OSCheckMemDebug(IMG_PVOID pvCpuVAddr, IMG_SIZE_T uSize, const IMG_CHAR *pszFileName, const IMG_UINT32 uLine)
+ {
+ OSMEM_DEBUG_INFO const *psInfo = (OSMEM_DEBUG_INFO *)((IMG_UINT32)pvCpuVAddr - TEST_BUFFER_PADDING_STATUS);
+
+
+ if (pvCpuVAddr == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : null pointer"
+ " - referenced %s:%d - allocated %s:%d",
+ pvCpuVAddr,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+
+
+ if (((IMG_UINT32)pvCpuVAddr&3) != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : invalid alignment"
+ " - referenced %s:%d - allocated %s:%d",
+ pvCpuVAddr,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+
+
+ if (!MemCheck((IMG_PVOID)psInfo->sGuardRegionBefore, 0xB1, sizeof(psInfo->sGuardRegionBefore)))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : guard region before overwritten"
+ " - referenced %s:%d - allocated %s:%d",
+ pvCpuVAddr,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+
+
+ if (uSize != psInfo->uSize)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "Pointer 0x%X : supplied size was different to stored size (0x%X != 0x%X)"
+ " - referenced %s:%d - allocated %s:%d",
+ pvCpuVAddr, uSize, psInfo->uSize,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+
+
+ if ((0x01234567 ^ psInfo->uSizeParityCheck) != psInfo->uSize)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "Pointer 0x%X : stored size parity error (0x%X != 0x%X)"
+ " - referenced %s:%d - allocated %s:%d",
+ pvCpuVAddr, psInfo->uSize, 0x01234567 ^ psInfo->uSizeParityCheck,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+ else
+ {
+
+ uSize = psInfo->uSize;
+ }
+
+
+ if (uSize)
+ {
+ if (!MemCheck((IMG_VOID*)((IMG_UINT32)pvCpuVAddr + uSize), 0xB2, TEST_BUFFER_PADDING_AFTER))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : guard region after overwritten"
+ " - referenced from %s:%d - allocated from %s:%d",
+ pvCpuVAddr,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ }
+ }
+
+
+ if (psInfo->eValid != isAllocated)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : not allocated (freed? %d)"
+ " - referenced %s:%d - freed %s:%d",
+ pvCpuVAddr, psInfo->eValid == isFree,
+ pszFileName, uLine,
+ psInfo->sFileName, psInfo->uLineNo));
+ while (STOP_ON_ERROR);
+ }
+ }
+
+ IMG_VOID debug_strcpy(IMG_CHAR *pDest, const IMG_CHAR *pSrc)
+ {
+ IMG_SIZE_T i = 0;
+
+ for (; i < 128; i++)
+ {
+ *pDest = *pSrc;
+ if (*pSrc == '\0') break;
+ pDest++;
+ pSrc++;
+ }
+ }
+
+ PVRSRV_ERROR OSAllocMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+ IMG_UINT32 ui32Size,
+ IMG_PVOID *ppvCpuVAddr,
+ IMG_HANDLE *phBlockAlloc,
+ IMG_CHAR *pszFilename,
+ IMG_UINT32 ui32Line)
+ {
+ OSMEM_DEBUG_INFO *psInfo;
+
+ PVRSRV_ERROR eError;
+
+ eError = OSAllocMem_Debug_Linux_Memory_Allocations(ui32Flags,
+ ui32Size + TEST_BUFFER_PADDING,
+ ppvCpuVAddr,
+ phBlockAlloc,
+ pszFilename,
+ ui32Line);
+
+ if (eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+
+
+ OSMemSet((IMG_CHAR *)(*ppvCpuVAddr) + TEST_BUFFER_PADDING_STATUS, 0xBB, ui32Size);
+ OSMemSet((IMG_CHAR *)(*ppvCpuVAddr) + ui32Size + TEST_BUFFER_PADDING_STATUS, 0xB2, TEST_BUFFER_PADDING_AFTER);
+
+
+ psInfo = (OSMEM_DEBUG_INFO *)(*ppvCpuVAddr);
+
+ OSMemSet(psInfo->sGuardRegionBefore, 0xB1, sizeof(psInfo->sGuardRegionBefore));
+ debug_strcpy(psInfo->sFileName, pszFilename);
+ psInfo->uLineNo = ui32Line;
+ psInfo->eValid = isAllocated;
+ psInfo->uSize = ui32Size;
+ psInfo->uSizeParityCheck = 0x01234567 ^ ui32Size;
+
+
+ *ppvCpuVAddr = (IMG_PVOID) ((IMG_UINT32)*ppvCpuVAddr)+TEST_BUFFER_PADDING_STATUS;
+
+#ifdef PVRSRV_LOG_MEMORY_ALLOCS
+
+ PVR_TRACE(("Allocated pointer (after debug info): 0x%X from %s:%d", *ppvCpuVAddr, pszFilename, ui32Line));
+#endif
+
+ return PVRSRV_OK;
+ }
+
+ PVRSRV_ERROR OSFreeMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+ IMG_UINT32 ui32Size,
+ IMG_PVOID pvCpuVAddr,
+ IMG_HANDLE hBlockAlloc,
+ IMG_CHAR *pszFilename,
+ IMG_UINT32 ui32Line)
+ {
+ OSMEM_DEBUG_INFO *psInfo;
+
+
+ OSCheckMemDebug(pvCpuVAddr, ui32Size, pszFilename, ui32Line);
+
+
+ OSMemSet(pvCpuVAddr, 0xBF, ui32Size + TEST_BUFFER_PADDING_AFTER);
+
+
+ psInfo = (OSMEM_DEBUG_INFO *)((IMG_UINT32) pvCpuVAddr - TEST_BUFFER_PADDING_STATUS);
+
+
+ psInfo->uSize = 0;
+ psInfo->uSizeParityCheck = 0;
+ psInfo->eValid = isFree;
+ psInfo->uLineNo = ui32Line;
+ debug_strcpy(psInfo->sFileName, pszFilename);
+
+ return OSFreeMem_Debug_Linux_Memory_Allocations(ui32Flags, ui32Size + TEST_BUFFER_PADDING, psInfo, hBlockAlloc, pszFilename, ui32Line);
+ }
+
+#if defined (__cplusplus)
+
+}
+#endif
+
+#endif
+
+#endif
#include "sgxapi_km.h"
#endif
-#if defined(DEBUG) || defined(TIMING)
+#if defined(DEBUG_PVR) || defined(TIMING)
static volatile IMG_UINT32 *pui32TimerRegister = 0;
******************************************************************************/
#if defined(PDUMP)
+#include <stdarg.h>
+
#include "services_headers.h"
+#if defined(SUPPORT_SGX)
+#include "sgxdefs.h"
+#include "sgxmmu.h"
+#endif
#include "pdump_km.h"
-#if !defined(PDUMP_TEMP_BUFFER_SIZE)
-#define PDUMP_TEMP_BUFFER_SIZE (64 * 1024L)
+#if !defined(PDUMP_TEMP_BUFFER_SIZE)
+#define PDUMP_TEMP_BUFFER_SIZE (64 * 1024L)
+#endif
+
+#if 1
+#define PDUMP_DBG(a) PDumpOSDebugPrintf a
+#else
+#define PDUMP_DBG(a)
+#endif
+
+#define PDUMP_DATAMASTER_PIXEL (1)
+#define PDUMP_DATAMASTER_EDM (3)
+
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+#define PTR_PLUS(t, p, x) ((t *)(((IMG_CHAR *)(p)) + (x)))
+#define VPTR_PLUS(p, x) PTR_PLUS(IMG_VOID, p, x)
+#define VPTR_INC(p, x) (p = VPTR_PLUS(p, x))
+#define MAX_PDUMP_MMU_CONTEXTS (32)
+static IMG_VOID *gpvTempBuffer = IMG_NULL;
+static IMG_HANDLE ghTempBufferBlockAlloc;
+static IMG_UINT16 gui16MMUContextUsage = 0;
+
+
+
+static IMG_VOID *GetTempBuffer(IMG_VOID)
+{
+
+ if (gpvTempBuffer == IMG_NULL)
+ {
+ PVRSRV_ERROR eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ PDUMP_TEMP_BUFFER_SIZE,
+ &gpvTempBuffer,
+ &ghTempBufferBlockAlloc,
+ "PDUMP Temporary Buffer");
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "GetTempBuffer: OSAllocMem failed: %d", eError));
+ }
+ }
+
+ return gpvTempBuffer;
+}
+
+static IMG_VOID FreeTempBuffer(IMG_VOID)
+{
+
+ if (gpvTempBuffer != IMG_NULL)
+ {
+ PVRSRV_ERROR eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+ PDUMP_TEMP_BUFFER_SIZE,
+ gpvTempBuffer,
+ ghTempBufferBlockAlloc);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "FreeTempBuffer: OSFreeMem failed: %d", eError));
+ }
+ else
+ {
+ gpvTempBuffer = IMG_NULL;
+ }
+ }
+}
+
+IMG_VOID PDumpInitCommon(IMG_VOID)
+{
+
+ (IMG_VOID) GetTempBuffer();
+
+
+ PDumpInit();
+}
+
+IMG_VOID PDumpDeInitCommon(IMG_VOID)
+{
+
+ FreeTempBuffer();
+
+
+ PDumpDeInit();
+}
+
+#if defined(SGX_SUPPORT_COMMON_PDUMP)
+
+IMG_BOOL PDumpIsSuspended(IMG_VOID)
+{
+ return PDumpOSIsSuspended();
+}
+
+PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_UINT32 ui32Reg, IMG_UINT32 ui32Data, IMG_UINT32 ui32Flags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING()
+ PDUMP_DBG(("PDumpRegWithFlagsKM"));
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :SGXREG:0x%8.8lX 0x%8.8lX\r\n", ui32Reg, ui32Data);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpRegKM(IMG_UINT32 ui32Reg,IMG_UINT32 ui32Data)
+{
+ return PDumpRegWithFlagsKM(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask, IMG_UINT32 ui32Flags)
+{
+
+ #define POLL_DELAY 1000UL
+ #define POLL_COUNT_LONG (2000000000UL / POLL_DELAY)
+ #define POLL_COUNT_SHORT (1000000UL / POLL_DELAY)
+
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32PollCount;
+
+ PDUMP_GET_SCRIPT_STRING();
+ PDUMP_DBG(("PDumpRegPolWithFlagsKM"));
+
+ if (((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
+ (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_TA_FINISHED_MASK) != 0) ||
+ ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
+ (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK) != 0) ||
+ ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
+ (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK) != 0))
+ {
+ ui32PollCount = POLL_COUNT_LONG;
+ }
+ else
+ {
+ ui32PollCount = POLL_COUNT_SHORT;
+ }
+
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "POL :SGXREG:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %lu %d\r\n",
+ ui32RegAddr, ui32RegValue, ui32Mask, 0, ui32PollCount, POLL_DELAY);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask)
+{
+ return PDumpRegPolWithFlagsKM(ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpMallocPages (PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_UINT32 ui32DevVAddr,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag)
+{
+ PVRSRV_ERROR eErr;
+ IMG_PUINT8 pui8LinAddr;
+ IMG_UINT32 ui32Offset;
+ IMG_UINT32 ui32NumPages;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32Page;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+#if defined(LINUX)
+ PVR_ASSERT(hOSMemHandle);
+#else
+
+ PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+ PVR_ASSERT(((IMG_UINT32) pvLinAddr & (SGX_MMU_PAGE_MASK)) == 0);
+#endif
+
+ PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & (SGX_MMU_PAGE_MASK)) == 0);
+ PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (SGX_MMU_PAGE_MASK)) == 0);
+
+
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :SGXMEM:VA_%8.8lX 0x%8.8lX %lu\r\n",
+ ui32DevVAddr, ui32NumBytes, ui32PageSize);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+
+
+ pui8LinAddr = (IMG_PUINT8) pvLinAddr;
+ ui32Offset = 0;
+ ui32NumPages = ui32NumBytes / ui32PageSize;
+ while (ui32NumPages)
+ {
+ ui32NumPages--;
+
+
+ PDumpOSCPUVAddrToDevPAddr(eDeviceType,
+ hOSMemHandle,
+ ui32Offset,
+ pui8LinAddr,
+ ui32PageSize,
+ &sDevPAddr);
+ ui32Page = sDevPAddr.uiAddr / ui32PageSize;
+
+ pui8LinAddr += ui32PageSize;
+ ui32Offset += ui32PageSize;
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX %lu %lu 0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag,
+ ui32Page * ui32PageSize,
+ ui32PageSize,
+ ui32PageSize,
+ ui32Page * ui32PageSize);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpMallocPageTable (PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32PTSize,
+ IMG_HANDLE hUniqueTag)
+{
+ PVRSRV_ERROR eErr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32Page;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+ PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize - 1)) == 0);
+
+
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :SGXMEM:PAGE_TABLE 0x%8.8lX %lu\r\n", ui32PTSize, SGX_MMU_PAGE_SIZE);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {
+
+
+ PDumpOSCPUVAddrToDevPAddr(eDeviceType,
+ IMG_NULL,
+ 0,
+ (IMG_PUINT8) pvLinAddr,
+ SGX_MMU_PAGE_SIZE,
+ &sDevPAddr);
+ ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX 0x%lX %lu 0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag,
+ ui32Page * SGX_MMU_PAGE_SIZE,
+ SGX_MMU_PAGE_SIZE,
+ SGX_MMU_PAGE_SIZE,
+ ui32Page * SGX_MMU_PAGE_SIZE);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpFreePages (BM_HEAP *psBMHeap,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag,
+ IMG_BOOL bInterleaved)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32NumPages, ui32PageCounter;
+ IMG_DEV_PHYADDR sDevPAddr;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+ PVR_ASSERT(((IMG_UINT32) sDevVAddr.uiAddr & (ui32PageSize - 1)) == 0);
+ PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (ui32PageSize - 1)) == 0);
+
+
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :SGXMEM:VA_%8.8lX\r\n", sDevVAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+
+
+ ui32NumPages = ui32NumBytes / ui32PageSize;
+ psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
+ for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages; ui32PageCounter++)
+ {
+ if (!bInterleaved || (ui32PageCounter % 2) == 0)
+ {
+ sDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->pMMUHeap, sDevVAddr);
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, sDevPAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ }
+ else
+ {
+
+ }
+
+ sDevVAddr.uiAddr += ui32PageSize;
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpFreePageTable (PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32PTSize,
+ IMG_HANDLE hUniqueTag)
+{
+ PVRSRV_ERROR eErr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32Page;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+ PVR_UNREFERENCED_PARAMETER(ui32PTSize);
+
+
+ PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize-1UL)) == 0);
+
+
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :SGXMEM:PAGE_TABLE\r\n");
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+
+
+
+
+
+
+
+
+
+
+
+ {
+ PDumpOSCPUVAddrToDevPAddr(eDeviceType,
+ IMG_NULL,
+ 0,
+ (IMG_PUINT8) pvLinAddr,
+ SGX_MMU_PAGE_SIZE,
+ &sDevPAddr);
+ ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, ui32Page * SGX_MMU_PAGE_SIZE);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING()
+
+
+
+#if defined(SGX_FEATURE_36BIT_MMU)
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
+ "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ (IMG_UINT32)hUniqueTag,
+ (ui32Data & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PDE_ADDR_ALIGNSHIFT);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
+ "WRW :SGXREG:0x%8.8lX: SGXMEM:$1\r\n",
+ ui32Reg);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+#else
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXREG:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
+ ui32Reg,
+ (IMG_UINT32) hUniqueTag,
+ (ui32Data & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PDE_ADDR_ALIGNSHIFT,
+ ui32Data & ~SGX_MMU_PDE_ADDR_MASK);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+#endif
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpPDReg (IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data,
+ IMG_HANDLE hUniqueTag)
+{
+ return PDumpPDRegWithFlags(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS, hUniqueTag);
+}
+
+PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32Offset,
+ IMG_UINT32 ui32Value,
+ IMG_UINT32 ui32Mask,
+ PDUMP_POLL_OPERATOR eOperator,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
+{
+ #define MEMPOLL_DELAY (1000)
+ #define MEMPOLL_COUNT (2000000000 / MEMPOLL_DELAY)
+
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32PageOffset;
+ IMG_UINT8 *pui8LinAddr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_DEV_VIRTADDR sDevVPageAddr;
+ PDUMP_GET_SCRIPT_STRING();
+
+
+ PVR_ASSERT((ui32Offset + sizeof(IMG_UINT32)) <= psMemInfo->ui32AllocSize);
+
+
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "-- POL :SGXMEM:VA_%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
+ psMemInfo->sDevVAddr.uiAddr + ui32Offset,
+ ui32Value,
+ ui32Mask,
+ eOperator,
+ MEMPOLL_COUNT,
+ MEMPOLL_DELAY);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+
+ pui8LinAddr = psMemInfo->pvLinAddrKM;
+
+
+ pui8LinAddr += ui32Offset;
+
+
+
+
+ PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
+ ui32Offset,
+ pui8LinAddr,
+ &ui32PageOffset);
+
+
+ sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;
+
+ PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+
+ BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+
+
+ sDevPAddr.uiAddr += ui32PageOffset;
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "POL :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
+ (IMG_UINT32) hUniqueTag,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ ui32Value,
+ ui32Mask,
+ eOperator,
+ MEMPOLL_COUNT,
+ MEMPOLL_DELAY);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpMemKM(IMG_PVOID pvAltLinAddr,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32Offset,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32NumPages;
+ IMG_UINT32 ui32PageByteOffset;
+ IMG_UINT32 ui32BlockBytes;
+ IMG_UINT8* pui8LinAddr;
+ IMG_UINT8* pui8DataLinAddr = IMG_NULL;
+ IMG_DEV_VIRTADDR sDevVPageAddr;
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32ParamOutPos;
+
+ PDUMP_GET_SCRIPT_AND_FILE_STRING();
+
+
+ PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
+
+ if (!PDumpOSJTInitialised())
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ if (ui32Bytes == 0 || PDumpOSIsSuspended())
+ {
+ return PVRSRV_OK;
+ }
+
+
+ if(pvAltLinAddr)
+ {
+ pui8DataLinAddr = pvAltLinAddr;
+ }
+ else if(psMemInfo->pvLinAddrKM)
+ {
+ pui8DataLinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM + ui32Offset;
+ }
+ pui8LinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM;
+ sDevVAddr = psMemInfo->sDevVAddr;
+
+
+ sDevVAddr.uiAddr += ui32Offset;
+ pui8LinAddr += ui32Offset;
+
+ PVR_ASSERT(pui8DataLinAddr);
+
+ PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);
+
+ ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
+
+
+
+ if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
+ pui8DataLinAddr,
+ ui32Bytes,
+ ui32Flags))
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ if (PDumpOSGetParamFileNum() == 0)
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");
+ }
+ else
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%%lu.prm", PDumpOSGetParamFileNum());
+ }
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "-- LDB :SGXMEM:VA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
+ (IMG_UINT32)hUniqueTag,
+ psMemInfo->sDevVAddr.uiAddr,
+ ui32Offset,
+ ui32Bytes,
+ ui32ParamOutPos,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+
+
+
+ PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
+ ui32Offset,
+ pui8LinAddr,
+ &ui32PageByteOffset);
+ ui32NumPages = (ui32PageByteOffset + ui32Bytes + HOST_PAGESIZE() - 1) / HOST_PAGESIZE();
+
+ while(ui32NumPages)
+ {
+#if 0
+ IMG_UINT32 ui32BlockBytes = MIN(ui32BytesRemaining, PAGE_SIZE);
+ CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
+ ui32CurrentOffset);
+#endif
+ ui32NumPages--;
+
+
+ sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
+
+ PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+
+ BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+
+
+ sDevPAddr.uiAddr += ui32PageByteOffset;
+#if 0
+ if(ui32PageByteOffset)
+ {
+ ui32BlockBytes =
+ MIN(ui32BytesRemaining, PAGE_ALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
+
+ ui32PageByteOffset = 0;
+ }
+#endif
+
+ if (ui32PageByteOffset + ui32Bytes > HOST_PAGESIZE())
+ {
+
+ ui32BlockBytes = HOST_PAGESIZE() - ui32PageByteOffset;
+ }
+ else
+ {
+
+ ui32BlockBytes = ui32Bytes;
+ }
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
+ (IMG_UINT32) hUniqueTag,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ ui32BlockBytes,
+ ui32ParamOutPos,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+
+
+
+ ui32PageByteOffset = 0;
+
+ ui32Bytes -= ui32BlockBytes;
+
+ sDevVAddr.uiAddr += ui32BlockBytes;
+
+ pui8LinAddr += ui32BlockBytes;
+
+ ui32ParamOutPos += ui32BlockBytes;
+ }
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_BOOL bInitialisePages,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32NumPages;
+ IMG_UINT32 ui32PageOffset;
+ IMG_UINT32 ui32BlockBytes;
+ IMG_UINT8* pui8LinAddr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_CPU_PHYADDR sCpuPAddr;
+ IMG_UINT32 ui32Offset;
+ IMG_UINT32 ui32ParamOutPos;
+
+ PDUMP_GET_SCRIPT_AND_FILE_STRING();
+
+ if (!pvLinAddr || !PDumpOSJTInitialised())
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ if (PDumpOSIsSuspended())
+ {
+ return PVRSRV_OK;
+ }
+
+ PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);
+
+ ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
+
+ if (bInitialisePages)
+ {
+
+
+
+ if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
+ pvLinAddr,
+ ui32Bytes,
+ PDUMP_FLAGS_CONTINUOUS))
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ if (PDumpOSGetParamFileNum() == 0)
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");
+ }
+ else
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%%lu.prm", PDumpOSGetParamFileNum());
+ }
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ }
+
+
+
+
+ ui32PageOffset = (IMG_UINT32) pvLinAddr & (HOST_PAGESIZE() - 1);
+ ui32NumPages = (ui32PageOffset + ui32Bytes + HOST_PAGESIZE() - 1) / HOST_PAGESIZE();
+ pui8LinAddr = (IMG_UINT8*) pvLinAddr;
+
+ while (ui32NumPages)
+ {
+ ui32NumPages--;
+ sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
+ sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
+
+
+ if (ui32PageOffset + ui32Bytes > HOST_PAGESIZE())
+ {
+
+ ui32BlockBytes = HOST_PAGESIZE() - ui32PageOffset;
+ }
+ else
+ {
+
+ ui32BlockBytes = ui32Bytes;
+ }
+
+
+
+ if (bInitialisePages)
+ {
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
+ (IMG_UINT32) hUniqueTag1,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ ui32BlockBytes,
+ ui32ParamOutPos,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ }
+ else
+ {
+ for (ui32Offset = 0; ui32Offset < ui32BlockBytes; ui32Offset += sizeof(IMG_UINT32))
+ {
+ IMG_UINT32 ui32PTE = *((IMG_UINT32 *) (pui8LinAddr + ui32Offset));
+
+ if ((ui32PTE & SGX_MMU_PDE_ADDR_MASK) != 0)
+ {
+#if defined(SGX_FEATURE_36BIT_MMU)
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ (IMG_UINT32)hUniqueTag2,
+ (ui32PTE & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PTE_ADDR_ALIGNSHIFT);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "OR :SGXMEM:$1 :SGXMEM:$1 0x%8.8lX\r\n", ui32PTE & ~SGX_MMU_PDE_ADDR_MASK);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$1\r\n",
+ (IMG_UINT32)hUniqueTag1,
+ (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
+ (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK));
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+#else
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag1,
+ (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
+ (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK),
+ (IMG_UINT32) hUniqueTag2,
+ (ui32PTE & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PTE_ADDR_ALIGNSHIFT,
+ ui32PTE & ~SGX_MMU_PDE_ADDR_MASK);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
#endif
+ }
+ else
+ {
+ PVR_ASSERT((ui32PTE & SGX_MMU_PTE_VALID) == 0UL);
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag1,
+ (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
+ (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK),
+ (ui32PTE << SGX_MMU_PTE_ADDR_ALIGNSHIFT),
+ (IMG_UINT32) hUniqueTag2);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ }
+ }
-#define MIN(x, y) (((x) < (y)) ? (x) : (y))
-#define PTR_PLUS(t, p, x) ((t *)(((IMG_CHAR *)(p)) + (x)))
-#define VPTR_PLUS(p, x) PTR_PLUS(IMG_VOID, p, x)
-#define VPTR_INC(p, x) (p = VPTR_PLUS(p, x))
-#define MAX_PDUMP_MMU_CONTEXTS (10)
-static IMG_VOID *gpvTempBuffer = IMG_NULL;
-static IMG_HANDLE ghTempBufferBlockAlloc;
-static IMG_UINT16 gui16MMUContextUsage = 0;
+
+
+ ui32PageOffset = 0;
+
+ ui32Bytes -= ui32BlockBytes;
+
+ pui8LinAddr += ui32BlockBytes;
+
+ ui32ParamOutPos += ui32BlockBytes;
+ }
+ return PVRSRV_OK;
+}
-static IMG_VOID *GetTempBuffer(IMG_VOID)
+PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32Offset,
+ IMG_DEV_PHYADDR sPDDevPAddr,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32PageByteOffset;
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEV_VIRTADDR sDevVPageAddr;
+ IMG_DEV_PHYADDR sDevPAddr;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+ if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
+ (IMG_UINT8 *)&sPDDevPAddr,
+ sizeof(IMG_DEV_PHYADDR),
+ PDUMP_FLAGS_CONTINUOUS))
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ sDevVAddr = psMemInfo->sDevVAddr;
+ ui32PageByteOffset = sDevVAddr.uiAddr & (SGX_MMU_PAGE_MASK);
+
+ sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
+ PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+ BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+ sDevPAddr.uiAddr += ui32PageByteOffset + ui32Offset;
+
+ if ((sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK) != 0UL)
+ {
+#if defined(SGX_FEATURE_36BIT_MMU)
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ (IMG_UINT32)hUniqueTag2,
+ sPDDevPAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "AND :SGXMEM:$2 :SGXMEM:$1 0xFFFFFFFF\r\n");
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
+ (IMG_UINT32)hUniqueTag1,
+ (sDevPAddr.uiAddr) & ~(SGX_MMU_PAGE_MASK),
+ (sDevPAddr.uiAddr) & (SGX_MMU_PAGE_MASK));
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :SGXMEM:$2 :SGXMEM:$1 0x20\r\n");
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
+ (IMG_UINT32)hUniqueTag1,
+ (sDevPAddr.uiAddr + 4) & ~(SGX_MMU_PAGE_MASK),
+ (sDevPAddr.uiAddr + 4) & (SGX_MMU_PAGE_MASK));
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+#else
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag1,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ (IMG_UINT32) hUniqueTag2,
+ sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK,
+ sPDDevPAddr.uiAddr & ~SGX_MMU_PDE_ADDR_MASK);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+#endif
+ }
+ else
+ {
+ PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag1,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ sPDDevPAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ }
+ PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags)
{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_MSG_STRING();
+ PDUMP_DBG(("PDumpCommentKM"));
+
- if (gpvTempBuffer == IMG_NULL)
+ if (!PDumpOSWriteString2("-- ", ui32Flags))
{
- PVRSRV_ERROR eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- PDUMP_TEMP_BUFFER_SIZE,
- &gpvTempBuffer,
- &ghTempBufferBlockAlloc);
- if (eError != PVRSRV_OK)
+ if(ui32Flags & PDUMP_FLAGS_CONTINUOUS)
{
- PVR_DPF((PVR_DBG_ERROR, "GetTempBuffer: OSAllocMem failed: %d", eError));
+ return PVRSRV_ERROR_GENERIC;
+ }
+ else
+ {
+ return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
}
- return gpvTempBuffer;
+
+ eErr = PDumpOSBufprintf(hMsg, ui32MaxLen, "%s", pszComment);
+ if( (eErr != PVRSRV_OK) &&
+ (eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW))
+ {
+ return eErr;
+ }
+
+
+ PDumpOSVerifyLineEnding(hMsg, ui32MaxLen);
+ PDumpOSWriteString2(hMsg, ui32Flags);
+
+ return PVRSRV_OK;
}
-static IMG_VOID FreeTempBuffer(IMG_VOID)
+PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags, IMG_CHAR * pszFormat, ...)
{
+ PVRSRV_ERROR eErr;
+ PDUMP_va_list ap;
+ PDUMP_GET_MSG_STRING();
- if (gpvTempBuffer != IMG_NULL)
+
+ PDUMP_va_start(ap, pszFormat);
+ eErr = PDumpOSVSprintf(hMsg, ui32MaxLen, pszFormat, ap);
+ PDUMP_va_end(ap);
+
+ if(eErr != PVRSRV_OK)
{
- PVRSRV_ERROR eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- PDUMP_TEMP_BUFFER_SIZE,
- gpvTempBuffer,
- ghTempBufferBlockAlloc);
- if (eError != PVRSRV_OK)
+ return eErr;
+ }
+ return PDumpCommentKM(hMsg, ui32Flags);
+}
+
+PVRSRV_ERROR PDumpComment(IMG_CHAR *pszFormat, ...)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_va_list ap;
+ PDUMP_GET_MSG_STRING();
+
+
+ PDUMP_va_start(ap, pszFormat);
+ eErr = PDumpOSVSprintf(hMsg, ui32MaxLen, pszFormat, ap);
+ PDUMP_va_end(ap);
+
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ return PDumpCommentKM(hMsg, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32MsgLen;
+ PDUMP_GET_MSG_STRING();
+
+
+ eErr = PDumpOSBufprintf(hMsg, ui32MaxLen, "%s", pszString);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+
+ PDumpOSVerifyLineEnding(hMsg, ui32MaxLen);
+ ui32MsgLen = PDumpOSBuflen(hMsg, ui32MaxLen);
+
+ if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_DRIVERINFO),
+ (IMG_UINT8 *)hMsg,
+ ui32MsgLen,
+ ui32Flags))
+ {
+ if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
{
- PVR_DPF((PVR_DBG_ERROR, "FreeTempBuffer: OSFreeMem failed: %d", eError));
+ return PVRSRV_ERROR_GENERIC;
}
else
{
- gpvTempBuffer = IMG_NULL;
+ return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
}
+
+ return PVRSRV_OK;
}
-IMG_VOID PDumpInitCommon(IMG_VOID)
+PVRSRV_ERROR PDumpBitmapKM( IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_UINT32 ui32Width,
+ IMG_UINT32 ui32Height,
+ IMG_UINT32 ui32StrideInBytes,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ PDUMP_PIXEL_FORMAT ePixelFormat,
+ PDUMP_MEM_FORMAT eMemFormat,
+ IMG_UINT32 ui32PDumpFlags)
{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+ PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump bitmap of render\r\n");
+
+#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
- (IMG_VOID) GetTempBuffer();
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "SII %s %s.bin :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
+ pszFileName,
+ pszFileName,
+ PDUMP_DATAMASTER_PIXEL,
+ sDevBaseAddr.uiAddr,
+ ui32Size,
+ ui32FileOffset,
+ ePixelFormat,
+ ui32Width,
+ ui32Height,
+ ui32StrideInBytes,
+ eMemFormat);
+#else
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "SII %s %s.bin :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
+ pszFileName,
+ pszFileName,
+ sDevBaseAddr.uiAddr,
+ ui32Size,
+ ui32FileOffset,
+ ePixelFormat,
+ ui32Width,
+ ui32Height,
+ ui32StrideInBytes,
+ eMemFormat);
+#endif
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpOSWriteString2( hScript, ui32PDumpFlags);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_UINT32 ui32Address,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+
+ PVR_UNREFERENCED_PARAMETER(ui32Size);
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "SAB :SGXREG:0x%08lX 0x%08lX %s\r\n",
+ ui32Address,
+ ui32FileOffset,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpOSWriteString2( hScript, ui32PDumpFlags);
+
+ return PVRSRV_OK;
+}
+
+IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame)
+{
+ IMG_BOOL bFrameDumped;
- PDumpInit();
+
+ (IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame + 1);
+ bFrameDumped = PDumpIsCaptureFrameKM();
+ (IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame);
+
+ return bFrameDumped;
}
-IMG_VOID PDumpDeInitCommon(IMG_VOID)
+static PVRSRV_ERROR PDumpSignatureRegister (IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32Address,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 *pui32FileOffset,
+ IMG_UINT32 ui32Flags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "SAB :SGXREG:0x%08X 0x%08X %s\r\n",
+ ui32Address,
+ *pui32FileOffset,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpOSWriteString2(hScript, ui32Flags);
+ *pui32FileOffset += ui32Size;
+ return PVRSRV_OK;
+}
+
+static IMG_VOID PDumpRegisterRange(IMG_CHAR *pszFileName,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters,
+ IMG_UINT32 *pui32FileOffset,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32Flags)
+{
+ IMG_UINT32 i;
+ for (i = 0; i < ui32NumRegisters; i++)
+ {
+ PDumpSignatureRegister(pszFileName, pui32Registers[i], ui32Size, pui32FileOffset, ui32Flags);
+ }
+}
+
+PVRSRV_ERROR PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32FileOffset, ui32Flags;
+
+ PDUMP_GET_FILE_STRING();
+
+ ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
+ ui32FileOffset = 0;
+
+ PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump 3D signature registers\r\n");
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu_3d.sig", ui32DumpFrameNum);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpTASignatureRegisters (IMG_UINT32 ui32DumpFrameNum,
+ IMG_UINT32 ui32TAKickCount,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32FileOffset, ui32Flags;
+
+ PDUMP_GET_FILE_STRING();
+
+ ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
+ ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(IMG_UINT32);
+
+ PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump TA signature registers\r\n");
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu_ta.sig", ui32DumpFrameNum);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCounterRegisters (IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters)
+{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32FileOffset, ui32Flags;
+
+ PDUMP_GET_FILE_STRING();
+
+ ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0UL;
+ ui32FileOffset = 0UL;
+
+ PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump counter registers\r\n");
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu.perf", ui32DumpFrameNum);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpRegRead(const IMG_UINT32 ui32RegOffset, IMG_UINT32 ui32Flags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCycleCountRegRead(const IMG_UINT32 ui32RegOffset, IMG_BOOL bLastFrame)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpHWPerfCBKM (IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+ PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump Hardware Performance Circular Buffer\r\n");
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+ "SAB :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
+ PDUMP_DATAMASTER_EDM,
+#else
+ "SAB :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
+#endif
+ sDevBaseAddr.uiAddr,
+ ui32Size,
+ ui32FileOffset,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+ PDumpOSWriteString2(hScript, ui32PDumpFlags);
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
+ IMG_UINT32 ui32ROffOffset,
+ IMG_UINT32 ui32WPosVal,
+ IMG_UINT32 ui32PacketSize,
+ IMG_UINT32 ui32BufferSize,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
{
+ PVRSRV_ERROR eErr;
+ IMG_UINT32 ui32PageOffset;
+ IMG_UINT8 *pui8LinAddr;
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_DEV_VIRTADDR sDevVPageAddr;
+
+
+ PDUMP_GET_SCRIPT_STRING();
+
- FreeTempBuffer();
+ PVR_ASSERT((ui32ROffOffset + sizeof(IMG_UINT32)) <= psROffMemInfo->ui32AllocSize);
+
+ pui8LinAddr = psROffMemInfo->pvLinAddrKM;
+ sDevVAddr = psROffMemInfo->sDevVAddr;
- PDumpDeInit();
+ pui8LinAddr += ui32ROffOffset;
+ sDevVAddr.uiAddr += ui32ROffOffset;
+
+
+
+
+
+
+ PDumpOSCPUVAddrToPhysPages(psROffMemInfo->sMemBlk.hOSMemHandle,
+ ui32ROffOffset,
+ pui8LinAddr,
+ &ui32PageOffset);
+
+
+ sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageOffset;
+
+ PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+
+ BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);
+
+
+ sDevPAddr.uiAddr += ui32PageOffset;
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "CBP :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX 0x%8.8lX\r\n",
+ (IMG_UINT32) hUniqueTag,
+ sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
+ sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ ui32WPosVal,
+ ui32PacketSize,
+ ui32BufferSize);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags)
+{
+ PVRSRV_ERROR eErr;
+ PDUMP_GET_SCRIPT_STRING();
+ PDUMP_DBG(("PDumpIDLWithFlags"));
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %lu\r\n", ui32Clocks);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks)
+{
+ return PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS);
}
+#endif
+
PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_PVOID pvAltLinAddrUM,
PVRSRV_ERROR eError;
IMG_UINT32 ui32BytesToDump = MIN(PDUMP_TEMP_BUFFER_SIZE, ui32Bytes - ui32BytesDumped);
- eError = OSCopyFromUser(psPerProc,
+ eError = OSCopyFromUser(psPerProc,
pvAddrKM,
pvAddrUM,
ui32BytesToDump);
}
return PVRSRV_OK;
-}
+}
static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID)
for(i=0; i<MAX_PDUMP_MMU_CONTEXTS; i++)
{
- if((gui16MMUContextUsage & (1UL << i)) == 0)
+ if((gui16MMUContextUsage & (1U << i)) == 0)
{
- gui16MMUContextUsage |= 1UL << i;
+ gui16MMUContextUsage |= 1U << i;
*pui32MMUContextID = i;
return PVRSRV_OK;
}
}
-
+
PVR_DPF((PVR_DBG_ERROR, "_PdumpAllocMMUContext: no free MMU context ids"));
-
+
return PVRSRV_ERROR_GENERIC;
}
if(ui32MMUContextID < MAX_PDUMP_MMU_CONTEXTS)
{
- gui16MMUContextUsage &= ~(1UL << ui32MMUContextID);
+ gui16MMUContextUsage &= ~(1U << ui32MMUContextID);
return PVRSRV_OK;
}
eError = _PdumpAllocMMUContext(&ui32MMUContextID);
if(eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "PDumpSetMMUContext: _PdumpAllocMMUContext failed: %d", eError));
+ PVR_DPF((PVR_DBG_ERROR, "PDumpSetMMUContext: _PdumpAllocMMUContext failed: %d", eError));
return eError;
}
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- sDevPAddr.uiAddr &= ~PVRSRV_4K_PAGE_SIZE;
-
+ sDevPAddr.uiAddr &= ~((PVRSRV_4K_PAGE_SIZE) -1);
+
PDumpComment("Set MMU Context\r\n");
PDumpComment("MMU :%s:v%d %d :%s:PA_%8.8lX%8.8lX\r\n",
IMG_UINT32 ui32MMUType)
{
PVRSRV_ERROR eError;
-
+
PVR_UNREFERENCED_PARAMETER(eDeviceType);
- PDumpComment("Clear MMU Context\r\n");
+
+ PDumpComment("Clear MMU Context for memory space %s\r\n", pszMemSpace);
PDumpComment("MMU :%s:v%d %d\r\n",
pszMemSpace,
eError = _PdumpFreeMMUContext(ui32MMUContextID);
if(eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "PDumpClearMMUContext: _PdumpFreeMMUContext failed: %d", eError));
+ PVR_DPF((PVR_DBG_ERROR, "PDumpClearMMUContext: _PdumpFreeMMUContext failed: %d", eError));
return eError;
}
sizeof(*psPerProc),
psPerProc,
psPerProc->hBlockAlloc);
+
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't free per-process data (%d)", eError));
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(*psPerProc),
(IMG_PVOID *)&psPerProc,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "Per Process Data");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't allocate per-process data (%d)", eError));
eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_POWER_DEV),
- (IMG_VOID **)&psPowerDevice, IMG_NULL);
+ (IMG_VOID **)&psPowerDevice, IMG_NULL,
+ "Power Device");
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterPowerDevice: Failed to alloc PVRSRV_POWER_DEV"));
if(OSAllocMem( PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_EVENTOBJECT) ,
- (IMG_VOID **)&psSysData->psGlobalEventObject, 0) != PVRSRV_OK)
+ (IMG_VOID **)&psSysData->psGlobalEventObject, 0,
+ "Event Object") != PVRSRV_OK)
{
goto Error;
if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE),
- (IMG_VOID **)&psDeviceNode, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psDeviceNode, IMG_NULL,
+ "Device Node") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to alloc memory for psDeviceNode"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
#include "services_headers.h"
+#include "lists.h"
+
+DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
+
#if defined(__linux__) && defined(__KERNEL__)
+
#include "proc.h"
static IMG_INT
{
off_t off = 0;
IMG_INT cmds = 0;
- IMG_UINT32 ui32ReadOffset = psQueue->ui32ReadOffset;
- IMG_UINT32 ui32WriteOffset = psQueue->ui32WriteOffset;
+ IMG_SIZE_T ui32ReadOffset = psQueue->ui32ReadOffset;
+ IMG_SIZE_T ui32WriteOffset = psQueue->ui32WriteOffset;
PVRSRV_COMMAND * psCmd;
while (ui32ReadOffset != ui32WriteOffset)
{
- psCmd= (PVRSRV_COMMAND *)((IMG_UINT32)psQueue->pvLinQueueKM + ui32ReadOffset);
+ psCmd= (PVRSRV_COMMAND *)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + ui32ReadOffset);
off = printAppend(buffer, size, off, "%p %p %5lu %6lu %3lu %5lu %2lu %2lu %3lu \n",
psQueue,
}
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+void ProcSeqShowQueue(struct seq_file *sfile,void* el)
+{
+ PVRSRV_QUEUE_INFO * psQueue = (PVRSRV_QUEUE_INFO*)el;
+ IMG_INT cmds = 0;
+ IMG_SIZE_T ui32ReadOffset;
+ IMG_SIZE_T ui32WriteOffset;
+ PVRSRV_COMMAND * psCmd;
+
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+ seq_printf( sfile,
+ "Command Queues\n"
+ "Queue CmdPtr Pid Command Size DevInd DSC SSC #Data ...\n");
+ return;
+ }
+
+ ui32ReadOffset = psQueue->ui32ReadOffset;
+ ui32WriteOffset = psQueue->ui32WriteOffset;
+
+ while (ui32ReadOffset != ui32WriteOffset)
+ {
+ psCmd= (PVRSRV_COMMAND *)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + ui32ReadOffset);
+
+ seq_printf(sfile, "%p %p %5lu %6lu %3lu %5lu %2lu %2lu %3lu \n",
+ psQueue,
+ psCmd,
+ psCmd->ui32ProcessID,
+ psCmd->CommandType,
+ psCmd->ui32CmdSize,
+ psCmd->ui32DevIndex,
+ psCmd->ui32DstSyncCount,
+ psCmd->ui32SrcSyncCount,
+ psCmd->ui32DataSize);
+
+ ui32ReadOffset += psCmd->ui32CmdSize;
+ ui32ReadOffset &= psQueue->ui32QueueSize - 1;
+ cmds++;
+ }
+
+ if (cmds == 0)
+ seq_printf(sfile, "%p <empty>\n", psQueue);
+}
+
+void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off)
+{
+ PVRSRV_QUEUE_INFO * psQueue;
+ SYS_DATA * psSysData;
+
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+
+ SysAcquireData(&psSysData);
+
+ for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM);
+ return psQueue;
+}
+
+#endif
+
off_t
QueuePrintQueues (IMG_CHAR * buffer, size_t size, off_t off)
{
SYS_DATA * psSysData;
PVRSRV_QUEUE_INFO * psQueue;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- return END_OF_FILE;
+ SysAcquireData(&psSysData);
if (!off)
return printAppend (buffer, size, 0,
- for (psQueue = psSysData->psQueueList; --off && psQueue; psQueue = psQueue->psNextKM)
+ for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM)
;
return psQueue ? QueuePrintCommands (psQueue, buffer, size) : END_OF_FILE;
#define SYNCOPS_STALE(ui32OpsComplete, ui32OpsPending) \
(ui32OpsComplete >= ui32OpsPending)
-IMG_UINT32 NearestPower2(IMG_UINT32 ui32Value)
+
+DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
+
+static IMG_VOID QueueDumpCmdComplete(COMMAND_COMPLETE_DATA *psCmdCompleteData,
+ IMG_UINT32 i,
+ IMG_BOOL bIsSrc)
{
- IMG_UINT32 ui32Temp, ui32Result = 1;
+ PVRSRV_SYNC_OBJECT *psSyncObject;
+
+ psSyncObject = bIsSrc ? psCmdCompleteData->psSrcSync : psCmdCompleteData->psDstSync;
+
+ if (psCmdCompleteData->bInUse)
+ {
+ PVR_LOG(("\t%s %lu: ROC DevVAddr:0x%lX ROP:0x%lx ROC:0x%lx, WOC DevVAddr:0x%lX WOP:0x%lx WOC:0x%lx",
+ bIsSrc ? "SRC" : "DEST", i,
+ psSyncObject[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsPending,
+ psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsComplete,
+ psSyncObject[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsPending,
+ psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete));
+ }
+ else
+ {
+ PVR_LOG(("\t%s %lu: (Not in use)", bIsSrc ? "SRC" : "DEST", i));
+ }
+}
+
+
+static IMG_VOID QueueDumpDebugInfo_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
+ {
+ IMG_UINT32 i;
+ SYS_DATA *psSysData;
+ COMMAND_COMPLETE_DATA **ppsCmdCompleteData;
+ COMMAND_COMPLETE_DATA *psCmdCompleteData;
+
+ SysAcquireData(&psSysData);
+
+ ppsCmdCompleteData = psSysData->ppsCmdCompleteData[psDeviceNode->sDevId.ui32DeviceIndex];
+
+ if (ppsCmdCompleteData != IMG_NULL)
+ {
+ psCmdCompleteData = ppsCmdCompleteData[DC_FLIP_COMMAND];
+
+ PVR_LOG(("Command Complete Data for display device %lu:", psDeviceNode->sDevId.ui32DeviceIndex));
+
+ for (i = 0; i < psCmdCompleteData->ui32SrcSyncCount; i++)
+ {
+ QueueDumpCmdComplete(psCmdCompleteData, i, IMG_TRUE);
+ }
+
+ for (i = 0; i < psCmdCompleteData->ui32DstSyncCount; i++)
+ {
+ QueueDumpCmdComplete(psCmdCompleteData, i, IMG_FALSE);
+ }
+ }
+ else
+ {
+ PVR_LOG(("There is no Command Complete Data for display device %u", psDeviceNode->sDevId.ui32DeviceIndex));
+ }
+ }
+}
+
+
+IMG_VOID QueueDumpDebugInfo(IMG_VOID)
+{
+ SYS_DATA *psSysData;
+ SysAcquireData(&psSysData);
+ List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList, QueueDumpDebugInfo_ForEachCb);
+}
+
+
+IMG_SIZE_T NearestPower2(IMG_SIZE_T ui32Value)
+{
+ IMG_SIZE_T ui32Temp, ui32Result = 1;
if(!ui32Value)
return 0;
IMG_EXPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_UINT32 ui32QueueSize,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_SIZE_T ui32QueueSize,
PVRSRV_QUEUE_INFO **ppsQueueInfo)
{
PVRSRV_QUEUE_INFO *psQueueInfo;
- IMG_UINT32 ui32Power2QueueSize = NearestPower2(ui32QueueSize);
+ IMG_SIZE_T ui32Power2QueueSize = NearestPower2(ui32QueueSize);
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
IMG_HANDLE hMemBlock;
- eError = SysAcquireData(&psSysData);
- if (eError != PVRSRV_OK)
- {
- return eError;
- }
+ SysAcquireData(&psSysData);
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_QUEUE_INFO),
- (IMG_VOID **)&psQueueInfo, &hMemBlock) != PVRSRV_OK)
+ (IMG_VOID **)&psQueueInfo, &hMemBlock,
+ "Queue Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue struct"));
goto ErrorExit;
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
ui32Power2QueueSize + PVRSRV_MAX_CMD_SIZE,
- &psQueueInfo->pvLinQueueKM, &hMemBlock) != PVRSRV_OK)
+ &psQueueInfo->pvLinQueueKM, &hMemBlock,
+ "Command Queue") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue buffer"));
goto ErrorExit;
psQueueInfo->ui32QueueSize,
psQueueInfo->pvLinQueueKM,
psQueueInfo->hMemBlock[1]);
+ psQueueInfo->pvLinQueueKM = IMG_NULL;
}
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_QUEUE_INFO),
psQueueInfo,
psQueueInfo->hMemBlock[0]);
+
}
return PVRSRV_ERROR_GENERIC;
PVRSRV_ERROR eError;
IMG_BOOL bTimeout = IMG_TRUE;
- eError = SysAcquireData(&psSysData);
- if (eError != PVRSRV_OK)
- {
- return eError;
- }
+ SysAcquireData(&psSysData);
psQueue = psSysData->psQueueList;
{
bTimeout = IMG_FALSE;
break;
- }
+ }
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
} END_LOOP_UNTIL_TIMEOUT();
psSysData->psQueueList = psQueueInfo->psNextKM;
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- psQueueInfo->ui32QueueSize,
+ NearestPower2(psQueueInfo->ui32QueueSize) + PVRSRV_MAX_CMD_SIZE,
psQueueInfo->pvLinQueueKM,
psQueueInfo->hMemBlock[1]);
+ psQueueInfo->pvLinQueueKM = IMG_NULL;
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_QUEUE_INFO),
psQueueInfo,
psQueueInfo->hMemBlock[0]);
+
+ psQueueInfo = IMG_NULL;
}
else
{
psQueueInfo->ui32QueueSize,
psQueueInfo->pvLinQueueKM,
psQueueInfo->hMemBlock[1]);
+ psQueueInfo->pvLinQueueKM = IMG_NULL;
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_QUEUE_INFO),
psQueueInfo,
psQueueInfo->hMemBlock[0]);
+
+ psQueueInfo = IMG_NULL;
break;
}
psQueue = psQueue->psNextKM;
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetQueueSpaceKM(PVRSRV_QUEUE_INFO *psQueue,
- IMG_UINT32 ui32ParamSize,
+ IMG_SIZE_T ui32ParamSize,
IMG_VOID **ppvSpace)
{
IMG_BOOL bTimeout = IMG_TRUE;
if (GET_SPACE_IN_CMDQ(psQueue) > ui32ParamSize)
{
bTimeout = IMG_FALSE;
- break;
+ break;
}
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
} END_LOOP_UNTIL_TIMEOUT();
}
else
{
- *ppvSpace = (IMG_VOID *)(psQueue->ui32WriteOffset + (IMG_UINT32)psQueue->pvLinQueueUM);
+ *ppvSpace = (IMG_VOID *)((IMG_UINTPTR_T)psQueue->pvLinQueueUM + psQueue->ui32WriteOffset);
}
return PVRSRV_OK;
PVRSRV_KERNEL_SYNC_INFO *apsDstSync[],
IMG_UINT32 ui32SrcSyncCount,
PVRSRV_KERNEL_SYNC_INFO *apsSrcSync[],
- IMG_UINT32 ui32DataByteSize )
+ IMG_SIZE_T ui32DataByteSize )
{
PVRSRV_ERROR eError;
PVRSRV_COMMAND *psCommand;
- IMG_UINT32 ui32CommandSize;
+ IMG_SIZE_T ui32CommandSize;
IMG_UINT32 i;
- ui32DataByteSize = (ui32DataByteSize + 3) & 0xFFFFFFFC;
+ ui32DataByteSize = (ui32DataByteSize + 3UL) & ~3UL;
ui32CommandSize = sizeof(PVRSRV_COMMAND)
psCommand->ui32SrcSyncCount = ui32SrcSyncCount;
- psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psCommand) + sizeof(PVRSRV_COMMAND));
+ psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand) + sizeof(PVRSRV_COMMAND));
- psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psCommand->psDstSync)
+ psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psDstSync)
+ (ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
- psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psCommand->psSrcSync)
+ psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psSrcSync)
+ (ui32SrcSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
psCommand->ui32DataSize = ui32DataByteSize;
psCommand->psDstSync[i].psKernelSyncInfoKM = apsDstSync[i];
psCommand->psDstSync[i].ui32WriteOpsPending = PVRSRVGetWriteOpsPending(apsDstSync[i], IMG_FALSE);
psCommand->psDstSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsDstSync[i], IMG_FALSE);
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCommand->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCommand->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCommand->psDstSync[i].ui32ReadOpsPending,
+ psCommand->psDstSync[i].ui32WriteOpsPending));
}
psCommand->psSrcSync[i].psKernelSyncInfoKM = apsSrcSync[i];
psCommand->psSrcSync[i].ui32WriteOpsPending = PVRSRVGetWriteOpsPending(apsSrcSync[i], IMG_TRUE);
psCommand->psSrcSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsSrcSync[i], IMG_TRUE);
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCommand->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCommand->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCommand->psSrcSync[i].ui32ReadOpsPending,
+ psCommand->psSrcSync[i].ui32WriteOpsPending));
}
if (psCommand->ui32DstSyncCount > 0)
{
- psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psQueue->pvLinQueueKM)
+ psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND));
}
if (psCommand->ui32SrcSyncCount > 0)
{
- psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psQueue->pvLinQueueKM)
+ psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND)
+ (psCommand->ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
}
- psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINT8 *)psQueue->pvLinQueueKM)
+ psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND)
+ (psCommand->ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT))
+ (psCommand->ui32SrcSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
for (i=0; i<psCommand->ui32DstSyncCount; i++)
{
psCmdCompleteData->psDstSync[i] = psCommand->psDstSync[i];
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psDstSync[i].ui32ReadOpsPending,
+ psCmdCompleteData->psDstSync[i].ui32WriteOpsPending));
}
for (i=0; i<psCommand->ui32SrcSyncCount; i++)
{
psCmdCompleteData->psSrcSync[i] = psCommand->psSrcSync[i];
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psSrcSync[i].ui32ReadOpsPending,
+ psCmdCompleteData->psSrcSync[i].ui32WriteOpsPending));
}
}
+IMG_VOID PVRSRVProcessQueues_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ if (psDeviceNode->bReProcessDeviceCommandComplete &&
+ psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
+ {
+ (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
+ }
+}
+
IMG_EXPORT
PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32 ui32CallerID,
IMG_BOOL bFlush)
PVRSRV_QUEUE_INFO *psQueue;
SYS_DATA *psSysData;
PVRSRV_COMMAND *psCommand;
- PVRSRV_DEVICE_NODE *psDeviceNode;
PVRSRV_ERROR eError;
- eError = SysAcquireData(&psSysData);
- if (eError != PVRSRV_OK)
- {
- return eError;
- }
+ SysAcquireData(&psSysData);
psSysData->bReProcessQueues = IMG_FALSE;
{
while (psQueue->ui32ReadOffset != psQueue->ui32WriteOffset)
{
- psCommand = (PVRSRV_COMMAND*)((IMG_UINT32)psQueue->pvLinQueueKM + psQueue->ui32ReadOffset);
+ psCommand = (PVRSRV_COMMAND*)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + psQueue->ui32ReadOffset);
if (PVRSRVProcessCommand(psSysData, psCommand, bFlush) == PVRSRV_OK)
{
}
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode != IMG_NULL)
- {
- if (psDeviceNode->bReProcessDeviceCommandComplete &&
- psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
- {
- (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
- }
- psDeviceNode = psDeviceNode->psNext;
- }
+ List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
+ PVRSRVProcessQueues_ForEachCb);
+
OSUnlockResource(&psSysData->sQProcessResource, ui32CallerID);
IMG_EXPORT
-IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie, IMG_BOOL bScheduleMISR)
+IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie,
+ IMG_BOOL bScheduleMISR)
{
IMG_UINT32 i;
COMMAND_COMPLETE_DATA *psCmdCompleteData = (COMMAND_COMPLETE_DATA *)hCmdCookie;
SYS_DATA *psSysData;
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- return;
- }
+ SysAcquireData(&psSysData);
for (i=0; i<psCmdCompleteData->ui32DstSyncCount; i++)
{
psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete++;
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psDstSync[i].ui32ReadOpsPending,
+ psCmdCompleteData->psDstSync[i].ui32WriteOpsPending));
}
for (i=0; i<psCmdCompleteData->ui32SrcSyncCount; i++)
{
psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsComplete++;
+
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ i, psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
+ psCmdCompleteData->psSrcSync[i].ui32ReadOpsPending,
+ psCmdCompleteData->psSrcSync[i].ui32WriteOpsPending));
}
}
-IMG_VOID PVRSRVCommandCompleteCallbacks(IMG_VOID)
+IMG_VOID PVRSRVCommandCompleteCallbacks_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
{
- SYS_DATA *psSysData;
- PVRSRV_DEVICE_NODE *psDeviceNode;
-
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
+ if(psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVCommandCompleteCallbacks: SysAcquireData failed"));
- return;
+
+ (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
}
+}
- psDeviceNode = psSysData->psDeviceNodeList;
- while(psDeviceNode != IMG_NULL)
- {
- if(psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
- {
-
- (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
- }
- psDeviceNode = psDeviceNode->psNext;
- }
+IMG_VOID PVRSRVCommandCompleteCallbacks(IMG_VOID)
+{
+ SYS_DATA *psSysData;
+ SysAcquireData(&psSysData);
+
+
+ List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
+ PVRSRVCommandCompleteCallbacks_ForEachCb);
}
IMG_EXPORT
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
IMG_UINT32 i;
- IMG_UINT32 ui32AllocSize;
+ IMG_SIZE_T ui32AllocSize;
PFN_CMD_PROC *ppfnCmdProc;
COMMAND_COMPLETE_DATA *psCmdCompleteData;
}
- eError = SysAcquireData(&psSysData);
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: SysAcquireData failed"));
- return eError;
- }
+ SysAcquireData(&psSysData);
eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
ui32CmdCount * sizeof(PFN_CMD_PROC),
- (IMG_VOID **)&psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL);
+ (IMG_VOID **)&psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL,
+ "Internal Queue Info structure");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc queue"));
ui32AllocSize = ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*);
eError = OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
ui32AllocSize,
- (IMG_VOID **)&psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL);
+ (IMG_VOID **)&psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL,
+ "Array of Pointers for Command Store");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc CC data"));
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
ui32AllocSize,
(IMG_VOID **)&psSysData->ppsCmdCompleteData[ui32DevIndex][i],
- IMG_NULL);
+ IMG_NULL,
+ "Command Complete Data");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc cmd %d",i));
psCmdCompleteData->psDstSync = (PVRSRV_SYNC_OBJECT*)
- (((IMG_UINT32)psCmdCompleteData)
+ (((IMG_UINTPTR_T)psCmdCompleteData)
+ sizeof(COMMAND_COMPLETE_DATA));
psCmdCompleteData->psSrcSync = (PVRSRV_SYNC_OBJECT*)
- (((IMG_UINT32)psCmdCompleteData->psDstSync)
+ (((IMG_UINTPTR_T)psCmdCompleteData->psDstSync)
+ (sizeof(PVRSRV_SYNC_OBJECT) * ui32MaxSyncsPerCmd[i][0]));
+
+ psCmdCompleteData->ui32AllocSize = ui32AllocSize;
}
return PVRSRV_OK;
{
if (psSysData->ppsCmdCompleteData[ui32DevIndex][i] != IMG_NULL)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppsCmdCompleteData[ui32DevIndex][i], IMG_NULL);
+ ui32AllocSize = sizeof(COMMAND_COMPLETE_DATA)
+ + ((ui32MaxSyncsPerCmd[i][0]
+ + ui32MaxSyncsPerCmd[i][1])
+ * sizeof(PVRSRV_SYNC_OBJECT));
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppsCmdCompleteData[ui32DevIndex][i], IMG_NULL);
+ psSysData->ppsCmdCompleteData[ui32DevIndex][i] = IMG_NULL;
}
}
-
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL);
+ ui32AllocSize = ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL);
+ psSysData->ppsCmdCompleteData[ui32DevIndex] = IMG_NULL;
}
if(psSysData->ppfnCmdProcList[ui32DevIndex] != IMG_NULL)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL);
+ ui32AllocSize = ui32CmdCount * sizeof(PFN_CMD_PROC);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL);
+ psSysData->ppfnCmdProcList[ui32DevIndex] = IMG_NULL;
}
return eError;
IMG_UINT32 ui32CmdCount)
{
SYS_DATA *psSysData;
- PVRSRV_ERROR eError;
IMG_UINT32 i;
}
- eError = SysAcquireData(&psSysData);
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveCmdProcListKM: SysAcquireData failed"));
- return eError;
- }
+ SysAcquireData(&psSysData);
if(psSysData->ppsCmdCompleteData[ui32DevIndex] == IMG_NULL)
{
if(psSysData->ppsCmdCompleteData[ui32DevIndex][i] != IMG_NULL)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppsCmdCompleteData[ui32DevIndex][i], IMG_NULL);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ psSysData->ppsCmdCompleteData[ui32DevIndex][i]->ui32AllocSize,
+ psSysData->ppsCmdCompleteData[ui32DevIndex][i],
+ IMG_NULL);
+ psSysData->ppsCmdCompleteData[ui32DevIndex][i] = IMG_NULL;
}
}
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*),
+ psSysData->ppsCmdCompleteData[ui32DevIndex],
+ IMG_NULL);
+ psSysData->ppsCmdCompleteData[ui32DevIndex] = IMG_NULL;
}
if(psSysData->ppfnCmdProcList[ui32DevIndex] != IMG_NULL)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, 0, psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ ui32CmdCount * sizeof(PFN_CMD_PROC),
+ psSysData->ppfnCmdProcList[ui32DevIndex],
+ IMG_NULL);
+ psSysData->ppfnCmdProcList[ui32DevIndex] = IMG_NULL;
}
return PVRSRV_OK;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(BT),
- (IMG_VOID **)&pNeighbour, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pNeighbour, IMG_NULL,
+ "Boundary Tag") != PVRSRV_OK)
{
return IMG_NULL;
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(BT),
- (IMG_VOID **)&pBT, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pBT, IMG_NULL,
+ "Boundary Tag") != PVRSRV_OK)
{
return IMG_NULL;
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(BT),
- (IMG_VOID **)&pBT, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pBT, IMG_NULL,
+ "Boundary Tag") != PVRSRV_OK)
{
return IMG_NULL;
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (*pArena),
- (IMG_VOID **)&pArena, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&pArena, IMG_NULL,
+ "Resource Arena") != PVRSRV_OK)
{
goto arena_fail;
}
typedef struct _RESMAN_ITEM_
{
-#ifdef DEBUG
+#ifdef DEBUG_PVR
IMG_UINT32 ui32Signature;
#endif
struct _RESMAN_ITEM_ **ppsThis;
typedef struct _RESMAN_CONTEXT_
{
-#ifdef DEBUG
+#ifdef DEBUG_PVR
IMG_UINT32 ui32Signature;
#endif
struct _RESMAN_CONTEXT_ **ppsThis;
PRESMAN_LIST gpsResList = IMG_NULL;
+#include "lists.h"
+
+static IMPLEMENT_LIST_ANY_VA(RESMAN_ITEM)
+static IMPLEMENT_LIST_ANY_VA_2(RESMAN_ITEM, IMG_BOOL, IMG_FALSE)
+static IMPLEMENT_LIST_INSERT(RESMAN_ITEM)
+static IMPLEMENT_LIST_REMOVE(RESMAN_ITEM)
+
+static IMPLEMENT_LIST_REMOVE(RESMAN_CONTEXT)
+static IMPLEMENT_LIST_INSERT(RESMAN_CONTEXT)
+
#define PRINT_RESLIST(x, y, z)
IMG_BOOL bExecuteCallback);
-#ifdef DEBUG
+#ifdef DEBUG_PVR
static IMG_VOID ValidateResList(PRESMAN_LIST psResList);
#define VALIDATERESLIST() ValidateResList(gpsResList)
#else
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*gpsResList),
- (IMG_VOID **)&gpsResList, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&gpsResList, IMG_NULL,
+ "Resource Manager List") != PVRSRV_OK)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*gpsResList), gpsResList, IMG_NULL);
+ gpsResList = IMG_NULL;
}
}
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psResManContext),
- (IMG_VOID **)&psResManContext, IMG_NULL);
+ (IMG_VOID **)&psResManContext, IMG_NULL,
+ "Resource Manager Context");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVResManConnect: ERROR allocating new RESMAN context struct"));
return eError;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
psResManContext->ui32Signature = RESMAN_SIGNATURE;
#endif
psResManContext->psResItemList = IMG_NULL;
psResManContext->psPerProc = hPerProc;
- psResManContext->psNext = gpsResList->psContextList;
- psResManContext->ppsThis = &gpsResList->psContextList;
- gpsResList->psContextList = psResManContext;
- if (psResManContext->psNext)
- {
- psResManContext->psNext->ppsThis = &(psResManContext->psNext);
- }
+ List_RESMAN_CONTEXT_Insert(&gpsResList->psContextList, psResManContext);
VALIDATERESLIST();
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_EVENT_OBJECT, 0, 0, IMG_TRUE);
+
+
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_MODIFY_SYNC_OPS, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_RENDER_CONTEXT, 0, 0, IMG_TRUE);
PVR_ASSERT(psResManContext->psResItemList == IMG_NULL);
- *(psResManContext->ppsThis) = psResManContext->psNext;
- if (psResManContext->psNext)
- {
- psResManContext->psNext->ppsThis = psResManContext->ppsThis;
- }
+ List_RESMAN_CONTEXT_Remove(psResManContext);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_CONTEXT), psResManContext, IMG_NULL);
+
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(RESMAN_ITEM), (IMG_VOID **)&psNewResItem,
- IMG_NULL) != PVRSRV_OK)
+ IMG_NULL,
+ "Resource Manager Item") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "ResManRegisterRes: "
"ERROR allocating new resource item"));
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
psNewResItem->ui32Signature = RESMAN_SIGNATURE;
#endif
psNewResItem->ui32ResType = ui32ResType;
psNewResItem->ui32Flags = 0;
- psNewResItem->ppsThis = &psResManContext->psResItemList;
- psNewResItem->psNext = psResManContext->psResItemList;
- psResManContext->psResItemList = psNewResItem;
- if (psNewResItem->psNext)
- {
- psNewResItem->psNext->ppsThis = &psNewResItem->psNext;
- }
+ List_RESMAN_ITEM_Insert(&psResManContext->psResItemList, psNewResItem);
VALIDATERESLIST();
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
PVR_ASSERT(psResItem->ui32Signature == RESMAN_SIGNATURE);
#endif
if (psNewResManContext != IMG_NULL)
{
- if (psResItem->psNext)
- {
- psResItem->psNext->ppsThis = psResItem->ppsThis;
- }
- *psResItem->ppsThis = psResItem->psNext;
+ List_RESMAN_ITEM_Remove(psResItem);
- psResItem->ppsThis = &psNewResManContext->psResItemList;
- psResItem->psNext = psNewResManContext->psResItemList;
- psNewResManContext->psResItemList = psResItem;
- if (psResItem->psNext)
- {
- psResItem->psNext->ppsThis = &psResItem->psNext;
- }
+ List_RESMAN_ITEM_Insert(&psNewResManContext->psResItemList, psResItem);
+
}
else
{
return eError;
}
+IMG_BOOL ResManFindResourceByPtr_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
+{
+ RESMAN_ITEM *psItem;
+
+ psItem = va_arg(va, RESMAN_ITEM*);
+
+ return (IMG_BOOL)(psCurItem == psItem);
+}
+
IMG_INTERNAL PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT psResManContext,
RESMAN_ITEM *psItem)
{
- RESMAN_ITEM *psCurItem;
+ PVRSRV_ERROR eResult;
PVR_ASSERT(psResManContext != IMG_NULL);
PVR_ASSERT(psItem != IMG_NULL);
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
#endif
psItem->pfnFreeResource, psItem->ui32Flags));
- psCurItem = psResManContext->psResItemList;
-
- while(psCurItem != IMG_NULL)
+ if(List_RESMAN_ITEM_IMG_BOOL_Any_va(psResManContext->psResItemList,
+ ResManFindResourceByPtr_AnyVaCb,
+ psItem))
{
-
- if(psCurItem != psItem)
- {
-
- psCurItem = psCurItem->psNext;
- }
- else
- {
-
- RELEASE_SYNC_OBJ;
- return PVRSRV_OK;
- }
+ eResult = PVRSRV_OK;
+ }
+ else
+ {
+ eResult = PVRSRV_ERROR_NOT_OWNER;
}
RELEASE_SYNC_OBJ;
- return PVRSRV_ERROR_NOT_OWNER;
+ return eResult;
}
static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem,
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
#endif
psItem->pfnFreeResource, psItem->ui32Flags));
- if (psItem->psNext)
- {
- psItem->psNext->ppsThis = psItem->ppsThis;
- }
- *psItem->ppsThis = psItem->psNext;
+ List_RESMAN_ITEM_Remove(psItem);
+
RELEASE_SYNC_OBJ;
return(eError);
}
+IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
+{
+ IMG_UINT32 ui32SearchCriteria;
+ IMG_UINT32 ui32ResType;
+ IMG_PVOID pvParam;
+ IMG_UINT32 ui32Param;
+
+ ui32SearchCriteria = va_arg(va, IMG_UINT32);
+ ui32ResType = va_arg(va, IMG_UINT32);
+ pvParam = va_arg(va, IMG_PVOID);
+ ui32Param = va_arg(va, IMG_UINT32);
+
+
+ if(
+
+ (((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) == 0UL) ||
+ (psCurItem->ui32ResType == ui32ResType))
+ &&
+
+ (((ui32SearchCriteria & RESMAN_CRITERIA_PVOID_PARAM) == 0UL) ||
+ (psCurItem->pvParam == pvParam))
+ &&
+
+ (((ui32SearchCriteria & RESMAN_CRITERIA_UI32_PARAM) == 0UL) ||
+ (psCurItem->ui32Param == ui32Param))
+ )
+ {
+ return psCurItem;
+ }
+ else
+ {
+ return IMG_NULL;
+ }
+}
static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psResManContext,
IMG_UINT32 ui32SearchCriteria,
IMG_BOOL bExecuteCallback)
{
PRESMAN_ITEM psCurItem;
- IMG_BOOL bMatch;
PVRSRV_ERROR eError = PVRSRV_OK;
- psCurItem = psResManContext->psResItemList;
-
- while(psCurItem != IMG_NULL)
+
+ while((psCurItem = (PRESMAN_ITEM)
+ List_RESMAN_ITEM_Any_va(psResManContext->psResItemList,
+ FreeResourceByCriteria_AnyVaCb,
+ ui32SearchCriteria,
+ ui32ResType,
+ pvParam,
+ ui32Param)) != IMG_NULL
+ && eError == PVRSRV_OK)
{
-
- bMatch = IMG_TRUE;
-
-
- if(((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) != 0UL) &&
- (psCurItem->ui32ResType != ui32ResType))
- {
- bMatch = IMG_FALSE;
- }
-
-
- else if(((ui32SearchCriteria & RESMAN_CRITERIA_PVOID_PARAM) != 0UL) &&
- (psCurItem->pvParam != pvParam))
- {
- bMatch = IMG_FALSE;
- }
-
-
- else if(((ui32SearchCriteria & RESMAN_CRITERIA_UI32_PARAM) != 0UL) &&
- (psCurItem->ui32Param != ui32Param))
- {
- bMatch = IMG_FALSE;
- }
-
- if(!bMatch)
- {
-
- psCurItem = psCurItem->psNext;
- }
- else
- {
-
- eError = FreeResourceByPtr(psCurItem, bExecuteCallback);
-
- if(eError != PVRSRV_OK)
- {
- return eError;
- }
-
-
-
-
- psCurItem = psResManContext->psResItemList;
- }
+ eError = FreeResourceByPtr(psCurItem, bExecuteCallback);
}
return eError;
}
-#ifdef DEBUG
+#ifdef DEBUG_PVR
static IMG_VOID ValidateResList(PRESMAN_LIST psResList)
{
PRESMAN_ITEM psCurItem, *ppsThisItem;
{
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (MMU_PT_INFO),
- (IMG_VOID **)&ppsPTInfoList[i], IMG_NULL);
+ (IMG_VOID **)&ppsPTInfoList[i], IMG_NULL,
+ "MMU Page Table Info");
if (ppsPTInfoList[i] == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "_DeferredAllocPagetables: ERROR call to OSAllocMem failed"));
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (MMU_CONTEXT),
- (IMG_VOID **)&psMMUContext, IMG_NULL);
+ (IMG_VOID **)&psMMUContext, IMG_NULL,
+ "MMU Context");
if (psMMUContext == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocMem failed"));
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (MMU_HEAP),
- (IMG_VOID **)&pMMUHeap, IMG_NULL);
+ (IMG_VOID **)&pMMUHeap, IMG_NULL,
+ "MMU Heap");
if (pMMUHeap == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Create: ERROR call to OSAllocMem failed"));
sizeof(PVRSRV_KERNEL_MEM_INFO *)
* psStubPBDesc->ui32SubKernelMemInfosCount,
(IMG_VOID **)&ppsSharedPBDescSubKernelMemInfos,
- IMG_NULL) != PVRSRV_OK)
+ IMG_NULL,
+ "Array of Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: OSAllocMem failed"));
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_STUB_PBDESC),
(IMG_VOID **)&psStubPBDesc,
- 0) != PVRSRV_OK)
+ 0,
+ "Stub Parameter Buffer Description") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: Failed to alloc "
"StubPBDesc"));
sizeof(PVRSRV_KERNEL_MEM_INFO *)
* ui32SharedPBDescSubKernelMemInfosCount,
(IMG_VOID **)&psStubPBDesc->ppsSubKernelMemInfos,
- 0) != PVRSRV_OK)
+ 0,
+ "Array of Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to alloc "
\r
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,\r
sizeof(PVRSRV_SGX_CCB_INFO),\r
- (IMG_VOID **)&psKernelCCBInfo, 0);\r
+ (IMG_VOID **)&psKernelCCBInfo, 0,\r
+ "SGX Circular Command Buffer Info");\r
if (eError != PVRSRV_OK)\r
{\r
PVR_DPF((PVR_DBG_ERROR,"InitDevInfo: Failed to alloc memory"));\r
\r
if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,\r
sizeof(PVRSRV_SGXDEV_INFO),\r
- (IMG_VOID **)&psDevInfo, IMG_NULL) != PVRSRV_OK)\r
+ (IMG_VOID **)&psDevInfo, IMG_NULL,\r
+ "SGX Device Info") != PVRSRV_OK)\r
{\r
PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart1 : Failed to alloc memory for DevInfo"));\r
return (PVRSRV_ERROR_OUT_OF_MEMORY);\r
\r
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,\r
sizeof(DEVICE_MEMORY_HEAP_INFO) * psDevMemoryInfo->ui32HeapCount,\r
- (IMG_VOID **)&psDevMemoryInfo->psDeviceMemoryHeap, 0) != PVRSRV_OK)\r
+ (IMG_VOID **)&psDevMemoryInfo->psDeviceMemoryHeap, 0,\r
+ "Array of Device Memory Heap Info") != PVRSRV_OK)\r
{\r
PVR_DPF((PVR_DBG_ERROR,"SGXRegisterDevice : Failed to alloc memory for DEVICE_MEMORY_HEAP_INFO"));\r
return (PVRSRV_ERROR_OUT_OF_MEMORY);\r
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(SGX_HW_RENDER_CONTEXT_CLEANUP),
(IMG_VOID **)&psCleanup,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "SGX Hardware Render Context Cleanup");
if (eError != PVRSRV_OK)
{
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(SGX_HW_TRANSFER_CONTEXT_CLEANUP),
(IMG_VOID **)&psCleanup,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "SGX Hardware Transfer Context Cleanup");
if (eError != PVRSRV_OK)
{
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(SGX_HW_2D_CONTEXT_CLEANUP),
(IMG_VOID **)&psCleanup,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "SGX Hardware 2D Context Cleanup");
if (eError != PVRSRV_OK)
{
#include <linux/interrupt.h>
#include <linux/pci.h>
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+#include <linux/workqueue.h>
+#endif
+
#define PVRSRV_MAX_BRIDGE_IN_SIZE 0x1000
#define PVRSRV_MAX_BRIDGE_OUT_SIZE 0x1000
IMG_BOOL bMISRInstalled;
IMG_UINT32 ui32IRQ;
IMG_VOID *pvISRCookie;
+#if defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+ struct workqueue_struct *psWorkQueue;
+#endif
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+ struct work_struct sMISRWork;
+ IMG_VOID *pvMISRData;
+#else
struct tasklet_struct sMISRTasklet;
+#endif
} ENV_DATA;
#endif
PVRSRV_ERROR LinuxMMapPerProcessHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase);
+IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID);
+
#endif
{
atomic_t sTimeStamp;
IMG_UINT32 ui32TimeStampPrevious;
-#if defined(DEBUG)
+#if defined(DEBUG_PVR)
IMG_UINT ui32Stats;
#endif
wait_queue_head_t sWait;
PVRSRV_LINUX_EVENT_OBJECT_LIST *psEvenObjectList;
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST),
- (IMG_VOID **)&psEvenObjectList, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psEvenObjectList, IMG_NULL,
+ "Linux Event Object List") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectCreate: failed to allocate memory for event list"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
return PVRSRV_ERROR_GENERIC;
}
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), psEvenObjectList, IMG_NULL);
+
}
return PVRSRV_OK;
}
if(hOSEventObject)
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)hOSEventObject;
-#if defined(DEBUG)
+#if defined(DEBUG_PVR)
PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectListDelete: Event object waits: %lu", psLinuxEventObject->ui32Stats));
#endif
if(ResManFreeResByPtr(psLinuxEventObject->hResItem) != PVRSRV_OK)
list_del(&psLinuxEventObject->sList);
write_unlock_bh(&psLinuxEventObjectList->sLock);
-#if defined(DEBUG)
+#if defined(DEBUG_PVR)
PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectDeleteCallback: Event object waits: %lu", psLinuxEventObject->ui32Stats));
#endif
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT), psLinuxEventObject, IMG_NULL);
+
return PVRSRV_OK;
}
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT),
- (IMG_VOID **)&psLinuxEventObject, IMG_NULL) != PVRSRV_OK)
+ (IMG_VOID **)&psLinuxEventObject, IMG_NULL,
+ "Linux Event Object") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: failed to allocate memory "));
return PVRSRV_ERROR_OUT_OF_MEMORY;
atomic_set(&psLinuxEventObject->sTimeStamp, 0);
psLinuxEventObject->ui32TimeStampPrevious = 0;
-#if defined(DEBUG)
+#if defined(DEBUG_PVR)
psLinuxEventObject->ui32Stats = 0;
#endif
init_waitqueue_head(&psLinuxEventObject->sWait);
ui32TimeOutJiffies = (IMG_UINT32)schedule_timeout((IMG_INT32)ui32TimeOutJiffies);
LinuxLockMutex(&gPVRSRVLock);
-#if defined(DEBUG)
+#if defined(DEBUG_PVR)
psLinuxEventObject->ui32Stats++;
#endif
#
#
-include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
-
-MODULE = pvrsrvkm
+MODULE ?= pvrsrvkm
-#MODULE_CFLAGS = -E
+MODULE_CFLAGS =
+ifeq ($(PVR_KBUILD_IN_KERNEL),1)
+# PVRKROOT is the relative path to the PVR sources.
+# DRVKROOT should point to the non-PVR sources, if any.
+PVRKROOT ?= .
+KBUILDROOT = $(PVRKROOT)/services4
+else
KBUILDROOT = ../../../..
+endif
+
+clean-dirs :=
INCLUDES = -I$(EURASIAROOT)/include4 \
-I$(EURASIAROOT)/services4/include \
$(KBUILDROOT)/srvkm/bridged/bridged_pvr_bridge.c \
$(KBUILDROOT)/srvkm/common/perproc.c \
$(KBUILDROOT)/../services4/system/$(PVR_SYSTEM)/sysconfig.c \
- $(KBUILDROOT)/../services4/system/$(PVR_SYSTEM)/sysutils.c
+ $(KBUILDROOT)/../services4/system/$(PVR_SYSTEM)/sysutils.c \
+ $(KBUILDROOT)/srvkm/common/lists.c \
+ $(KBUILDROOT)/srvkm/common/mem_debug.c
INCLUDES += -I$(EURASIAROOT)/services4/srvkm/hwdefs
ifeq ($(SUPPORT_DRI_DRM),1)
SOURCES += $(KBUILDROOT)/srvkm/env/linux/pvr_drm.c
- INCLUDES += -I$(KERNELDIR)/drivers/char/drm -I$(KERNELDIR)/include/drm
+ INCLUDES += -I$(KERNELDIR)/include/drm \
+ -I$(EURASIAROOT)/services4/include/env/linux
+
+ifneq ("$(DISPLAY_CONTROLLER_DIR)","")
+include $(EURASIAROOT)/services4/$(DISPLAY_CONTROLLER_DIR)/makefile.linux.common
+endif
+
+ifeq ($(PDUMP),1)
+include $(EURASIAROOT)/tools/intern/debug/dbgdriv/linux/makefile.linux.common
+endif
+
endif
ifeq ($(PVR_MODULE_TEST),1)
SOURCES += $(KBUILDROOT)/../moduletests/services_test/kern_test.c
SYS_CFLAGS += -DMODULE_TEST
endif
+
+include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
#ifndef __LINKAGE_H__
#define __LINKAGE_H__
+#if !defined(SUPPORT_DRI_DRM)
IMG_INT32 PVRSRV_BridgeDispatchKM(struct file *file, IMG_UINT cmd, IMG_UINT32 arg);
+#endif
+
IMG_VOID PVRDPFInit(IMG_VOID);
-#ifdef DEBUG
+#ifdef DEBUG_PVR
IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
-IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
IMG_VOID PVRDebugSetLevel(IMG_UINT32 uDebugLevel);
+#ifdef PVR_PROC_USE_SEQ_FILE
+void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el);
+#else
+IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
+#endif
+
#ifdef PVR_MANUAL_POWER_CONTROL
IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el);
+#else
IMG_INT PVRProcGetPowerLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
+#endif
+
+
#endif
#endif
#include "mutex.h"
#include "lock.h"
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+ #include "lists.h"
+#endif
+
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
typedef enum {
DEBUG_MEM_ALLOC_TYPE_KMALLOC,
IMG_UINT32 ui32Line;
struct _DEBUG_MEM_ALLOC_REC *psNext;
+ struct _DEBUG_MEM_ALLOC_REC **ppsThis;
}DEBUG_MEM_ALLOC_REC;
+static IMPLEMENT_LIST_ANY_VA_2(DEBUG_MEM_ALLOC_REC, IMG_BOOL, IMG_FALSE)
+static IMPLEMENT_LIST_ANY_VA(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_FOR_EACH(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_INSERT(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_REMOVE(DEBUG_MEM_ALLOC_REC)
+
+
static DEBUG_MEM_ALLOC_REC *g_MemoryRecords;
static IMG_UINT32 g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_COUNT];
static IMG_CHAR *DebugMemAllocRecordTypeToString(DEBUG_MEM_ALLOC_TYPE eAllocType);
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+static struct proc_dir_entry *g_SeqFileMemoryRecords =0;
+static void* ProcSeqNextMemoryRecords(struct seq_file *sfile,void* el,loff_t off);
+static void ProcSeqShowMemoryRecords(struct seq_file *sfile,void* el);
+static void* ProcSeqOff2ElementMemoryRecords(struct seq_file * sfile, loff_t off);
+
+#else
static off_t printMemoryRecords(IMG_CHAR * buffer, size_t size, off_t off);
+#endif
+
#endif
pid_t pid;
struct _DEBUG_LINUX_MEM_AREA_REC *psNext;
+ struct _DEBUG_LINUX_MEM_AREA_REC **ppsThis;
}DEBUG_LINUX_MEM_AREA_REC;
+
+static IMPLEMENT_LIST_ANY_VA(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_FOR_EACH(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_INSERT(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_REMOVE(DEBUG_LINUX_MEM_AREA_REC)
+
+
+
#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
static PVRSRV_LINUX_MUTEX g_sDebugMutex;
#endif
static IMG_UINT32 g_LinuxMemAreaWaterMark;
static IMG_UINT32 g_LinuxMemAreaHighWaterMark;
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+static struct proc_dir_entry *g_SeqFileMemArea=0;
+
+static void* ProcSeqNextMemArea(struct seq_file *sfile,void* el,loff_t off);
+static void ProcSeqShowMemArea(struct seq_file *sfile,void* el);
+static void* ProcSeqOff2ElementMemArea(struct seq_file *sfile, loff_t off);
+
+#else
static off_t printLinuxMemAreaRecords(IMG_CHAR * buffer, size_t size, off_t off);
+#endif
+
+#endif
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+#if (defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS))
+static void ProcSeqStartstopDebugMutex(struct seq_file *sfile,IMG_BOOL start);
+#endif
#endif
static LinuxKMemCache *psLinuxMemAreaCache;
#if defined(DEBUG_LINUX_MEM_AREAS)
{
IMG_INT iStatus;
- iStatus = CreateProcReadEntry("mem_areas", printLinuxMemAreaRecords);
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_SeqFileMemArea = CreateProcReadEntrySeq(
+ "mem_areas",
+ NULL,
+ ProcSeqNextMemArea,
+ ProcSeqShowMemArea,
+ ProcSeqOff2ElementMemArea,
+ ProcSeqStartstopDebugMutex
+ );
+ iStatus = !g_SeqFileMemArea ? -1 : 0;
+#else
+ iStatus = CreateProcReadEntry("mem_areas", printLinuxMemAreaRecords);
+#endif
if(iStatus!=0)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
{
IMG_INT iStatus;
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_SeqFileMemoryRecords =CreateProcReadEntrySeq(
+ "meminfo",
+ NULL,
+ ProcSeqNextMemoryRecords,
+ ProcSeqShowMemoryRecords,
+ ProcSeqOff2ElementMemoryRecords,
+ ProcSeqStartstopDebugMutex
+ );
+
+ iStatus = !g_SeqFileMemoryRecords ? -1 : 0;
+#else
iStatus = CreateProcReadEntry("meminfo", printMemoryRecords);
+#endif
if(iStatus!=0)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
return PVRSRV_OK;
}
+#if defined(DEBUG_LINUX_MEM_AREAS)
+IMG_VOID LinuxMMCleanup_MemAreas_ForEachCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord)
+{
+ LinuxMemArea *psLinuxMemArea;
+
+ psLinuxMemArea = psCurrentRecord->psLinuxMemArea;
+ PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up Linux memory area (%p), type=%s, size=%ld bytes",
+ __FUNCTION__,
+ psCurrentRecord->psLinuxMemArea,
+ LinuxMemAreaTypeToString(psCurrentRecord->psLinuxMemArea->eAreaType),
+ psCurrentRecord->psLinuxMemArea->ui32ByteSize));
+
+ LinuxMemAreaDeepFree(psLinuxMemArea);
+}
+#endif
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+IMG_VOID LinuxMMCleanup_MemRecords_ForEachVa(DEBUG_MEM_ALLOC_REC *psCurrentRecord)
+
+{
+
+ PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up memory: "
+ "type=%s "
+ "CpuVAddr=%p "
+ "CpuPAddr=0x%08lx, "
+ "allocated @ file=%s,line=%d",
+ __FUNCTION__,
+ DebugMemAllocRecordTypeToString(psCurrentRecord->eAllocType),
+ psCurrentRecord->pvCpuVAddr,
+ psCurrentRecord->ulCpuPAddr,
+ psCurrentRecord->pszFileName,
+ psCurrentRecord->ui32Line));
+ switch(psCurrentRecord->eAllocType)
+ {
+ case DEBUG_MEM_ALLOC_TYPE_KMALLOC:
+ KFreeWrapper(psCurrentRecord->pvCpuVAddr);
+ break;
+ case DEBUG_MEM_ALLOC_TYPE_IOREMAP:
+ IOUnmapWrapper(psCurrentRecord->pvCpuVAddr);
+ break;
+ case DEBUG_MEM_ALLOC_TYPE_IO:
+
+ DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IO, psCurrentRecord->pvKey, __FILE__, __LINE__);
+ break;
+ case DEBUG_MEM_ALLOC_TYPE_VMALLOC:
+ VFreeWrapper(psCurrentRecord->pvCpuVAddr);
+ break;
+ case DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES:
+
+ DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, psCurrentRecord->pvKey, __FILE__, __LINE__);
+ break;
+ case DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE:
+ KMemCacheFreeWrapper(psCurrentRecord->pvPrivateData, psCurrentRecord->pvCpuVAddr);
+ break;
+ default:
+ PVR_ASSERT(0);
+ }
+}
+#endif
+
IMG_VOID
LinuxMMCleanup(IMG_VOID)
#if defined(DEBUG_LINUX_MEM_AREAS)
{
- DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord = g_LinuxMemAreaRecords, *psNextRecord;
-
if(g_LinuxMemAreaCount)
{
PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: There are %d LinuxMemArea allocation unfreed (%ld bytes)",
__FUNCTION__, g_LinuxMemAreaCount, g_LinuxMemAreaWaterMark));
}
+
+ List_DEBUG_LINUX_MEM_AREA_REC_ForEach(g_LinuxMemAreaRecords,
+ LinuxMMCleanup_MemAreas_ForEachCb);
- while(psCurrentRecord)
- {
- LinuxMemArea *psLinuxMemArea;
-
- psNextRecord = psCurrentRecord->psNext;
- psLinuxMemArea = psCurrentRecord->psLinuxMemArea;
- PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up Linux memory area (%p), type=%s, size=%ld bytes",
- __FUNCTION__,
- psCurrentRecord->psLinuxMemArea,
- LinuxMemAreaTypeToString(psCurrentRecord->psLinuxMemArea->eAreaType),
- psCurrentRecord->psLinuxMemArea->ui32ByteSize));
-
- LinuxMemAreaDeepFree(psLinuxMemArea);
-
- psCurrentRecord = psNextRecord;
- }
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq( g_SeqFileMemArea );
+#else
RemoveProcEntry("mem_areas");
+#endif
}
#endif
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
{
- DEBUG_MEM_ALLOC_REC *psCurrentRecord = g_MemoryRecords, *psNextRecord;
- while(psCurrentRecord)
- {
- psNextRecord = psCurrentRecord->psNext;
- PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up memory: "
- "type=%s "
- "CpuVAddr=%p "
- "CpuPAddr=0x%08lx, "
- "allocated @ file=%s,line=%d",
- __FUNCTION__,
- DebugMemAllocRecordTypeToString(psCurrentRecord->eAllocType),
- psCurrentRecord->pvCpuVAddr,
- psCurrentRecord->ulCpuPAddr,
- psCurrentRecord->pszFileName,
- psCurrentRecord->ui32Line));
- switch(psCurrentRecord->eAllocType)
- {
- case DEBUG_MEM_ALLOC_TYPE_KMALLOC:
- KFreeWrapper(psCurrentRecord->pvCpuVAddr);
- break;
- case DEBUG_MEM_ALLOC_TYPE_IOREMAP:
- IOUnmapWrapper(psCurrentRecord->pvCpuVAddr);
- break;
- case DEBUG_MEM_ALLOC_TYPE_IO:
-
- DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IO, psCurrentRecord->pvKey, __FILE__, __LINE__);
- break;
- case DEBUG_MEM_ALLOC_TYPE_VMALLOC:
- VFreeWrapper(psCurrentRecord->pvCpuVAddr);
- break;
- case DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES:
-
- DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, psCurrentRecord->pvKey, __FILE__, __LINE__);
- break;
- case DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE:
- KMemCacheFreeWrapper(psCurrentRecord->pvPrivateData, psCurrentRecord->pvCpuVAddr);
- break;
- default:
- PVR_ASSERT(0);
- }
- psCurrentRecord = psNextRecord;
- }
+ List_DEBUG_MEM_ALLOC_REC_ForEach(g_MemoryRecords,
+ LinuxMMCleanup_MemRecords_ForEachVa);
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq( g_SeqFileMemoryRecords );
+#else
RemoveProcEntry("meminfo");
+#endif
+
}
#endif
ui32Line
);
}
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
return pvRet;
}
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_KMALLOC, pvCpuVAddr, pszFileName, ui32Line);
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
kfree(pvCpuVAddr);
}
psRecord->pszFileName = pszFileName;
psRecord->ui32Line = ui32Line;
- psRecord->psNext = g_MemoryRecords;
- g_MemoryRecords = psRecord;
+ List_DEBUG_MEM_ALLOC_REC_Insert(&g_MemoryRecords, psRecord);
g_WaterMarkData[eAllocType] += ui32Bytes;
if(g_WaterMarkData[eAllocType] > g_HighWaterMarkData[eAllocType])
}
+IMG_BOOL DebugMemAllocRecordRemove_AnyVaCb(DEBUG_MEM_ALLOC_REC *psCurrentRecord, va_list va)
+{
+ DEBUG_MEM_ALLOC_TYPE eAllocType;
+ IMG_VOID *pvKey;
+
+ eAllocType = va_arg(va, DEBUG_MEM_ALLOC_TYPE);
+ pvKey = va_arg(va, IMG_VOID*);
+
+ if(psCurrentRecord->eAllocType == eAllocType
+ && psCurrentRecord->pvKey == pvKey)
+ {
+ eAllocType = psCurrentRecord->eAllocType;
+ g_WaterMarkData[eAllocType] -= psCurrentRecord->ui32Bytes;
+
+ if(eAllocType == DEBUG_MEM_ALLOC_TYPE_KMALLOC
+ || eAllocType == DEBUG_MEM_ALLOC_TYPE_VMALLOC
+ || eAllocType == DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES
+ || eAllocType == DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
+ {
+ g_SysRAMWaterMark -= psCurrentRecord->ui32Bytes;
+ }
+ else if(eAllocType == DEBUG_MEM_ALLOC_TYPE_IOREMAP
+ || eAllocType == DEBUG_MEM_ALLOC_TYPE_IO)
+ {
+ g_IOMemWaterMark -= psCurrentRecord->ui32Bytes;
+ }
+
+ List_DEBUG_MEM_ALLOC_REC_Remove(psCurrentRecord);
+ kfree(psCurrentRecord);
+
+ return IMG_TRUE;
+ }
+ else
+ {
+ return IMG_FALSE;
+ }
+}
+
static IMG_VOID
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE eAllocType, IMG_VOID *pvKey, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
{
- DEBUG_MEM_ALLOC_REC **ppsCurrentRecord;
-
LinuxLockMutex(&g_sDebugMutex);
- for(ppsCurrentRecord = &g_MemoryRecords;
- *ppsCurrentRecord;
- ppsCurrentRecord = &((*ppsCurrentRecord)->psNext))
- {
- if((*ppsCurrentRecord)->eAllocType == eAllocType
- && (*ppsCurrentRecord)->pvKey == pvKey)
- {
- DEBUG_MEM_ALLOC_REC *psNextRecord;
- DEBUG_MEM_ALLOC_TYPE eAllocType;
-
- psNextRecord = (*ppsCurrentRecord)->psNext;
- eAllocType = (*ppsCurrentRecord)->eAllocType;
- g_WaterMarkData[eAllocType] -= (*ppsCurrentRecord)->ui32Bytes;
-
- if(eAllocType == DEBUG_MEM_ALLOC_TYPE_KMALLOC
- || eAllocType == DEBUG_MEM_ALLOC_TYPE_VMALLOC
- || eAllocType == DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES
- || eAllocType == DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
- {
- g_SysRAMWaterMark -= (*ppsCurrentRecord)->ui32Bytes;
- }
- else if(eAllocType == DEBUG_MEM_ALLOC_TYPE_IOREMAP
- || eAllocType == DEBUG_MEM_ALLOC_TYPE_IO)
- {
- g_IOMemWaterMark -= (*ppsCurrentRecord)->ui32Bytes;
- }
-
- kfree(*ppsCurrentRecord);
- *ppsCurrentRecord = psNextRecord;
- goto exit_unlock;
- }
- }
-
- PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for type=%s with pvKey=%p (called from %s, line %d\n",
- __FUNCTION__, DebugMemAllocRecordTypeToString(eAllocType), pvKey,
- pszFileName, ui32Line));
+ if(!List_DEBUG_MEM_ALLOC_REC_IMG_BOOL_Any_va(g_MemoryRecords,
+ DebugMemAllocRecordRemove_AnyVaCb,
+ eAllocType,
+ pvKey))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for type=%s with pvKey=%p (called from %s, line %d\n",
+ __FUNCTION__, DebugMemAllocRecordTypeToString(eAllocType), pvKey,
+ pszFileName, ui32Line));
+ }
-exit_unlock:
LinuxUnLockMutex(&g_sDebugMutex);
}
ui32Line
);
}
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
return pvRet;
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_VMALLOC, pvCpuVAddr, pszFileName, ui32Line);
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
vfree(pvCpuVAddr);
}
IMG_CHAR *pszFileName,
IMG_UINT32 ui32Line)
{
- IMG_VOID *pvIORemapCookie = IMG_NULL;
+ IMG_VOID *pvIORemapCookie;
switch(ui32MappingFlags & PVRSRV_HAP_CACHETYPE_MASK)
{
ui32Line
);
}
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
return pvIORemapCookie;
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IOREMAP, pvIORemapCookie, pszFileName, ui32Line);
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
iounmap(pvIORemapCookie);
}
static IMG_BOOL
-PagesAreContiguous(IMG_SYS_PHYADDR *psSysPhysAddr, IMG_UINT32 ui32Bytes)
+TreatExternalPagesAsContiguous(IMG_SYS_PHYADDR *psSysPhysAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig)
{
IMG_UINT32 ui32;
IMG_UINT32 ui32AddrChk;
IMG_UINT32 ui32NumPages = RANGE_TO_PAGES(ui32Bytes);
+
for (ui32 = 0, ui32AddrChk = psSysPhysAddr[0].uiAddr;
ui32 < ui32NumPages;
- ui32++, ui32AddrChk += PAGE_SIZE)
+ ui32++, ui32AddrChk = (bPhysContig) ? (ui32AddrChk + PAGE_SIZE) : psSysPhysAddr[ui32].uiAddr)
+ {
+ if (!pfn_valid(PHYS_TO_PFN(ui32AddrChk)))
+ {
+ break;
+ }
+ }
+ if (ui32 == ui32NumPages)
+ {
+ return IMG_FALSE;
+ }
+
+ if (!bPhysContig)
{
- if (psSysPhysAddr[ui32].uiAddr != ui32AddrChk)
+ for (ui32 = 0, ui32AddrChk = psSysPhysAddr[0].uiAddr;
+ ui32 < ui32NumPages;
+ ui32++, ui32AddrChk += PAGE_SIZE)
{
- return IMG_FALSE;
+ if (psSysPhysAddr[ui32].uiAddr != ui32AddrChk)
+ {
+ return IMG_FALSE;
+ }
}
}
psLinuxMemArea->eAreaType = LINUX_MEM_AREA_EXTERNAL_KV;
psLinuxMemArea->uData.sExternalKV.pvExternalKV = pvCPUVAddr;
- psLinuxMemArea->uData.sExternalKV.bPhysContig = bPhysContig || PagesAreContiguous(pBasePAddr, ui32Bytes);
+ psLinuxMemArea->uData.sExternalKV.bPhysContig = (IMG_BOOL)(bPhysContig || TreatExternalPagesAsContiguous(pBasePAddr, ui32Bytes, bPhysContig));
if (psLinuxMemArea->uData.sExternalKV.bPhysContig)
{
}
ui32PageCount = RANGE_TO_PAGES(ui32Bytes);
- eError = OSAllocMem(0, sizeof(*pvPageList) * ui32PageCount, (IMG_VOID **)&pvPageList, &hBlockPageList);
+ eError = OSAllocMem(0, sizeof(*pvPageList) * ui32PageCount, (IMG_VOID **)&pvPageList, &hBlockPageList,
+ "Array of pages");
if(eError != PVRSRV_OK)
{
goto failed_page_list_alloc;
}
- for(i=0; i<ui32PageCount; i++)
+ for(i=0; i<(IMG_INT32)ui32PageCount; i++)
{
pvPageList[i] = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, 0);
if(!pvPageList[i])
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
SetPageReserved(pvPageList[i]);
#else
- mem_map_reserve(pvPageList[i]);
+ mem_map_reserve(pvPageList[i]);
#endif
#endif
__free_pages(pvPageList[i], 0);
}
(IMG_VOID) OSFreeMem(0, sizeof(*pvPageList) * ui32PageCount, pvPageList, hBlockPageList);
+ psLinuxMemArea->uData.sPageList.pvPageList = IMG_NULL;
failed_page_list_alloc:
LinuxMemAreaStructFree(psLinuxMemArea);
failed_area_alloc:
IMG_UINT32 ui32PageCount;
struct page **pvPageList;
IMG_HANDLE hBlockPageList;
- IMG_UINT32 i;
+ IMG_INT32 i;
PVR_ASSERT(psLinuxMemArea);
PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_ALLOC_PAGES);
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, pvPageList, __FILE__, __LINE__);
#endif
- for(i=0;i<ui32PageCount;i++)
+ for(i=0;i<(IMG_INT32)ui32PageCount;i++)
{
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
- ClearPageReserved(pvPageList[i]);
+ ClearPageReserved(pvPageList[i]);
#else
- mem_map_reserve(pvPageList[i]);
+ mem_map_reserve(pvPageList[i]);
#endif
#endif
__free_pages(pvPageList[i], 0);
}
(IMG_VOID) OSFreeMem(0, sizeof(*pvPageList) * ui32PageCount, pvPageList, hBlockPageList);
+ psLinuxMemArea->uData.sPageList.pvPageList = IMG_NULL;
LinuxMemAreaStructFree(psLinuxMemArea);
}
case LINUX_MEM_AREA_ALLOC_PAGES:
ui32PageIndex = PHYS_TO_PFN(ui32ByteOffset);
return psLinuxMemArea->uData.sPageList.pvPageList[ui32PageIndex];
- break;
+
case LINUX_MEM_AREA_VMALLOC:
pui8Addr = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress;
pui8Addr += ui32ByteOffset;
return vmalloc_to_page(pui8Addr);
- break;
+
case LINUX_MEM_AREA_SUB_ALLOC:
+
return LinuxMemAreaOffsetToPage(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea,
psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset
+ ui32ByteOffset);
default:
PVR_DPF((PVR_DBG_ERROR,
"%s: Unsupported request for struct page from LinuxMemArea with type=%s",
- LinuxMemAreaTypeToString(psLinuxMemArea->eAreaType)));
+ __FUNCTION__, LinuxMemAreaTypeToString(psLinuxMemArea->eAreaType)));
return NULL;
}
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
gfp_t Flags,
#else
- IMG_INT Flags,
+ IMG_INT Flags,
#endif
IMG_CHAR *pszFileName,
IMG_UINT32 ui32Line)
pszFileName,
ui32Line
);
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
return pvRet;
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE, pvObject, pszFileName, ui32Line);
+#else
+ PVR_UNREFERENCED_PARAMETER(pszFileName);
+ PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
kmem_cache_free(psCache, pvObject);
const IMG_CHAR *
KMemCacheNameWrapper(LinuxKMemCache *psCache)
{
+ PVR_UNREFERENCED_PARAMETER(psCache);
+
return "";
}
default:
PVR_DPF((PVR_DBG_ERROR, "%s: Unknown are type (%d)\n",
__FUNCTION__, psLinuxMemArea->eAreaType));
+ break;
}
}
psNewRecord->psLinuxMemArea = psLinuxMemArea;
psNewRecord->ui32Flags = ui32Flags;
psNewRecord->pid = current->pid;
- psNewRecord->psNext = g_LinuxMemAreaRecords;
- g_LinuxMemAreaRecords = psNewRecord;
+
+ List_DEBUG_LINUX_MEM_AREA_REC_Insert(&g_LinuxMemAreaRecords, psNewRecord);
}
else
{
}
+
+IMG_VOID* MatchLinuxMemArea_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord,
+ va_list va)
+{
+ LinuxMemArea *psLinuxMemArea;
+
+ psLinuxMemArea = va_arg(va, LinuxMemArea*);
+ if(psCurrentRecord->psLinuxMemArea == psLinuxMemArea)
+ {
+ return psCurrentRecord;
+ }
+ else
+ {
+ return IMG_NULL;
+ }
+}
+
+
static DEBUG_LINUX_MEM_AREA_REC *
DebugLinuxMemAreaRecordFind(LinuxMemArea *psLinuxMemArea)
{
DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord;
LinuxLockMutex(&g_sDebugMutex);
-
- for(psCurrentRecord = g_LinuxMemAreaRecords;
- psCurrentRecord;
- psCurrentRecord = psCurrentRecord->psNext)
- {
- if(psCurrentRecord->psLinuxMemArea == psLinuxMemArea)
- {
- goto exit_unlock;
- }
- }
-
-exit_unlock:
+ psCurrentRecord = List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+ MatchLinuxMemArea_AnyVaCb,
+ psLinuxMemArea);
+
LinuxUnLockMutex(&g_sDebugMutex);
return psCurrentRecord;
static IMG_VOID
DebugLinuxMemAreaRecordRemove(LinuxMemArea *psLinuxMemArea)
{
- DEBUG_LINUX_MEM_AREA_REC **ppsCurrentRecord;
+ DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord;
LinuxLockMutex(&g_sDebugMutex);
g_LinuxMemAreaCount--;
- for(ppsCurrentRecord = &g_LinuxMemAreaRecords;
- *ppsCurrentRecord;
- ppsCurrentRecord = &((*ppsCurrentRecord)->psNext))
- {
- if((*ppsCurrentRecord)->psLinuxMemArea == psLinuxMemArea)
- {
- DEBUG_LINUX_MEM_AREA_REC *psNextRecord;
-
- psNextRecord = (*ppsCurrentRecord)->psNext;
- kfree(*ppsCurrentRecord);
- *ppsCurrentRecord = psNextRecord;
- goto exit_unlock;
- }
- }
-
- PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for psLinuxMemArea=%p\n",
- __FUNCTION__, psLinuxMemArea));
+ psCurrentRecord = List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+ MatchLinuxMemArea_AnyVaCb,
+ psLinuxMemArea);
+ if(psCurrentRecord)
+ {
+
+ List_DEBUG_LINUX_MEM_AREA_REC_Remove(psCurrentRecord);
+ kfree(psCurrentRecord);
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for psLinuxMemArea=%p\n",
+ __FUNCTION__, psLinuxMemArea));
+ }
-exit_unlock:
LinuxUnLockMutex(&g_sDebugMutex);
}
#endif
case LINUX_MEM_AREA_SUB_ALLOC:
{
IMG_CHAR *pAddr =
- LinuxMemAreaToCpuVAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea);
+ LinuxMemAreaToCpuVAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea);
if(!pAddr)
{
return NULL;
default:
PVR_DPF((PVR_DBG_ERROR, "%s: Unknown LinuxMemArea type (%d)\n",
__FUNCTION__, psLinuxMemArea->eAreaType));
- }
+ break;
+ }
PVR_ASSERT(CpuPAddr.uiAddr);
return CpuPAddr;
return IMG_FALSE;
case LINUX_MEM_AREA_SUB_ALLOC:
+
return LinuxMemAreaPhysIsContig(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea);
default:
}
+#ifdef PVR_PROC_USE_SEQ_FILE
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+static void ProcSeqStartstopDebugMutex(struct seq_file *sfile, IMG_BOOL start)
+{
+ if(start)
+ {
+ LinuxLockMutex(&g_sDebugMutex);
+ }
+ else
+ {
+ LinuxUnLockMutex(&g_sDebugMutex);
+ }
+}
+#endif
+#endif
+
#if defined(DEBUG_LINUX_MEM_AREAS)
+
+IMG_VOID* DecOffMemAreaRec_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psNode, va_list va)
+{
+ off_t *pOff = va_arg(va, off_t*);
+ if (--(*pOff))
+ {
+ return IMG_NULL;
+ }
+ else
+ {
+ return psNode;
+ }
+}
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void* ProcSeqNextMemArea(struct seq_file *sfile,void* el,loff_t off)
+{
+ DEBUG_LINUX_MEM_AREA_REC *psRecord;
+ psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
+ List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+ DecOffMemAreaRec_AnyVaCb,
+ &off);
+ return (void*)psRecord;
+}
+
+static void* ProcSeqOff2ElementMemArea(struct seq_file * sfile, loff_t off)
+{
+ DEBUG_LINUX_MEM_AREA_REC *psRecord;
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+ psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
+ List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+ DecOffMemAreaRec_AnyVaCb,
+ &off);
+ return (void*)psRecord;
+}
+
+
+static void ProcSeqShowMemArea(struct seq_file *sfile,void* el)
+{
+ DEBUG_LINUX_MEM_AREA_REC *psRecord = (DEBUG_LINUX_MEM_AREA_REC*)el;
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ seq_printf( sfile,
+ "Number of Linux Memory Areas: %lu\n"
+ "At the current water mark these areas correspond to %lu bytes (excluding SUB areas)\n"
+ "At the highest water mark these areas corresponded to %lu bytes (excluding SUB areas)\n"
+ "\nDetails for all Linux Memory Areas:\n"
+ "%s %-24s %s %s %-8s %-5s %s\n",
+ g_LinuxMemAreaCount,
+ g_LinuxMemAreaWaterMark,
+ g_LinuxMemAreaHighWaterMark,
+ "psLinuxMemArea",
+ "LinuxMemType",
+ "CpuVAddr",
+ "CpuPAddr",
+ "Bytes",
+ "Pid",
+ "Flags"
+ );
+#else
+ seq_printf( sfile,
+ "<mem_areas_header>\n"
+ "\t<count>%lu</count>\n"
+ "\t<watermark key=\"mar0\" description=\"current\" bytes=\"%lu\"/>\n"
+ "\t<watermark key=\"mar1\" description=\"high\" bytes=\"%lu\"/>\n"
+ "</mem_areas_header>\n",
+ g_LinuxMemAreaCount,
+ g_LinuxMemAreaWaterMark,
+ g_LinuxMemAreaHighWaterMark
+ );
+#endif
+ return;
+ }
+
+ seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ "%8p %-24s %8p %08lx %-8ld %-5u %08lx=(%s)\n",
+#else
+ "<linux_mem_area>\n"
+ "\t<pointer>%8p</pointer>\n"
+ "\t<type>%s</type>\n"
+ "\t<cpu_virtual>%8p</cpu_virtual>\n"
+ "\t<cpu_physical>%08lx</cpu_physical>\n"
+ "\t<bytes>%ld</bytes>\n"
+ "\t<pid>%u</pid>\n"
+ "\t<flags>%08lx</flags>\n"
+ "\t<flags_string>%s</flags_string>\n"
+ "</linux_mem_area>\n",
+#endif
+ psRecord->psLinuxMemArea,
+ LinuxMemAreaTypeToString(psRecord->psLinuxMemArea->eAreaType),
+ LinuxMemAreaToCpuVAddr(psRecord->psLinuxMemArea),
+ LinuxMemAreaToCpuPAddr(psRecord->psLinuxMemArea,0).uiAddr,
+ psRecord->psLinuxMemArea->ui32ByteSize,
+ psRecord->pid,
+ psRecord->ui32Flags,
+ HAPFlagsToString(psRecord->ui32Flags)
+ );
+
+}
+
+#else
+
static off_t
printLinuxMemAreaRecords(IMG_CHAR * buffer, size_t count, off_t off)
{
goto unlock_and_return;
}
- for(psRecord=g_LinuxMemAreaRecords; --off && psRecord; psRecord=psRecord->psNext)
- ;
+ psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
+ List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+ DecOffMemAreaRec_AnyVaCb,
+ &off);
+
if(!psRecord)
{
Ret = END_OF_FILE;
}
#endif
+#endif
+
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+
+IMG_VOID* DecOffMemAllocRec_AnyVaCb(DEBUG_MEM_ALLOC_REC *psNode, va_list va)
+{
+ off_t *pOff = va_arg(va, off_t*);
+ if (--(*pOff))
+ {
+ return IMG_NULL;
+ }
+ else
+ {
+ return psNode;
+ }
+}
+
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void* ProcSeqNextMemoryRecords(struct seq_file *sfile,void* el,loff_t off)
+{
+ DEBUG_MEM_ALLOC_REC *psRecord;
+ psRecord = (DEBUG_MEM_ALLOC_REC*)
+ List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
+ DecOffMemAllocRec_AnyVaCb,
+ &off);
+#if defined(DEBUG_LINUX_XML_PROC_FILES)
+ if(!psRecord)
+ {
+ seq_printf( sfile, "</meminfo>\n");
+ }
+#endif
+
+ return (void*)psRecord;
+}
+
+static void* ProcSeqOff2ElementMemoryRecords(struct seq_file *sfile, loff_t off)
+{
+ DEBUG_MEM_ALLOC_REC *psRecord;
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+ psRecord = (DEBUG_MEM_ALLOC_REC*)
+ List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
+ DecOffMemAllocRec_AnyVaCb,
+ &off);
+
+#if defined(DEBUG_LINUX_XML_PROC_FILES)
+ if(!psRecord)
+ {
+ seq_printf( sfile, "</meminfo>\n");
+ }
+#endif
+
+ return (void*)psRecord;
+}
+
+static void ProcSeqShowMemoryRecords(struct seq_file *sfile,void* el)
+{
+ DEBUG_MEM_ALLOC_REC *psRecord = (DEBUG_MEM_ALLOC_REC*)el;
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes allocated via kmalloc",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated via kmalloc",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes allocated via vmalloc",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated via vmalloc",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes allocated via alloc_pages",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated via alloc_pages",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes allocated via ioremap",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated via ioremap",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes reserved for \"IO\" memory areas",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated for \"IO\" memory areas",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Current Water Mark of bytes allocated via kmem_cache_alloc",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "Highest Water Mark of bytes allocated via kmem_cache_alloc",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
+ seq_printf( sfile, "\n");
+
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "The Current Water Mark for memory allocated from system RAM",
+ g_SysRAMWaterMark);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "The Highest Water Mark for memory allocated from system RAM",
+ g_SysRAMHighWaterMark);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "The Current Water Mark for memory allocated from IO memory",
+ g_IOMemWaterMark);
+ seq_printf( sfile, "%-60s: %ld bytes\n",
+ "The Highest Water Mark for memory allocated from IO memory",
+ g_IOMemHighWaterMark);
+
+ seq_printf( sfile, "\n");
+
+ seq_printf( sfile, "Details for all known allocations:\n"
+ "%-16s %-8s %-8s %-10s %-5s %-10s %s\n",
+ "Type",
+ "CpuVAddr",
+ "CpuPAddr",
+ "Bytes",
+ "PID",
+ "PrivateData",
+ "Filename:Line");
+
+#else
+
+
+ seq_printf( sfile, "<meminfo>\n<meminfo_header>\n");
+ seq_printf( sfile,
+ "<watermark key=\"mr0\" description=\"kmalloc_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+ seq_printf( sfile,
+ "<watermark key=\"mr1\" description=\"kmalloc_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+ seq_printf( sfile,
+ "<watermark key=\"mr2\" description=\"vmalloc_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+ seq_printf( sfile,
+ "<watermark key=\"mr3\" description=\"vmalloc_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+ seq_printf( sfile,
+ "<watermark key=\"mr4\" description=\"alloc_pages_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+ seq_printf( sfile,
+ "<watermark key=\"mr5\" description=\"alloc_pages_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+ seq_printf( sfile,
+ "<watermark key=\"mr6\" description=\"ioremap_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+ seq_printf( sfile,
+ "<watermark key=\"mr7\" description=\"ioremap_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+ seq_printf( sfile,
+ "<watermark key=\"mr8\" description=\"io_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+ seq_printf( sfile,
+ "<watermark key=\"mr9\" description=\"io_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+ seq_printf( sfile,
+ "<watermark key=\"mr10\" description=\"kmem_cache_current\" bytes=\"%ld\"/>\n",
+ g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
+ seq_printf( sfile,
+ "<watermark key=\"mr11\" description=\"kmem_cache_high\" bytes=\"%ld\"/>\n",
+ g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
+ seq_printf( sfile,"\n" );
+
+ seq_printf( sfile,
+ "<watermark key=\"mr14\" description=\"system_ram_current\" bytes=\"%ld\"/>\n",
+ g_SysRAMWaterMark);
+ seq_printf( sfile,
+ "<watermark key=\"mr15\" description=\"system_ram_high\" bytes=\"%ld\"/>\n",
+ g_SysRAMHighWaterMark);
+ seq_printf( sfile,
+ "<watermark key=\"mr16\" description=\"system_io_current\" bytes=\"%ld\"/>\n",
+ g_IOMemWaterMark);
+ seq_printf( sfile,
+ "<watermark key=\"mr17\" description=\"system_io_high\" bytes=\"%ld\"/>\n",
+ g_IOMemHighWaterMark);
+
+ seq_printf( sfile, "</meminfo_header>\n");
+
+#endif
+ return;
+ }
+
+ if(psRecord->eAllocType != DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
+ {
+ seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
+#else
+ "<allocation>\n"
+ "\t<type>%s</type>\n"
+ "\t<cpu_virtual>%-8p</cpu_virtual>\n"
+ "\t<cpu_physical>%08lx</cpu_physical>\n"
+ "\t<bytes>%ld</bytes>\n"
+ "\t<pid>%d</pid>\n"
+ "\t<private>%s</private>\n"
+ "\t<filename>%s</filename>\n"
+ "\t<line>%ld</line>\n"
+ "</allocation>\n",
+#endif
+ DebugMemAllocRecordTypeToString(psRecord->eAllocType),
+ psRecord->pvCpuVAddr,
+ psRecord->ulCpuPAddr,
+ psRecord->ui32Bytes,
+ psRecord->pid,
+ "NULL",
+ psRecord->pszFileName,
+ psRecord->ui32Line);
+ }
+ else
+ {
+ seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
+#else
+ "<allocation>\n"
+ "\t<type>%s</type>\n"
+ "\t<cpu_virtual>%-8p</cpu_virtual>\n"
+ "\t<cpu_physical>%08lx</cpu_physical>\n"
+ "\t<bytes>%ld</bytes>\n"
+ "\t<pid>%d</pid>\n"
+ "\t<private>%s</private>\n"
+ "\t<filename>%s</filename>\n"
+ "\t<line>%ld</line>\n"
+ "</allocation>\n",
+#endif
+ DebugMemAllocRecordTypeToString(psRecord->eAllocType),
+ psRecord->pvCpuVAddr,
+ psRecord->ulCpuPAddr,
+ psRecord->ui32Bytes,
+ psRecord->pid,
+ KMemCacheNameWrapper(psRecord->pvPrivateData),
+ psRecord->pszFileName,
+ psRecord->ui32Line);
+ }
+}
+
+
+
+#else
+
static off_t
printMemoryRecords(IMG_CHAR * buffer, size_t count, off_t off)
{
goto unlock_and_return;
}
- for(psRecord=g_MemoryRecords; --off && psRecord; psRecord=psRecord->psNext)
- ;
+ psRecord = (DEBUG_MEM_ALLOC_REC*)
+ List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
+ DecOffMemAllocRec_AnyVaCb,
+ &off);
if(!psRecord)
{
#if defined(DEBUG_LINUX_XML_PROC_FILES)
return Ret;
}
#endif
+#endif
#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MMAP_AREAS)
}
#endif
-
const IMG_CHAR *LinuxMemAreaTypeToString(LINUX_MEM_AREA_TYPE eMemAreaType);
-#if defined(DEBUG) || defined(DEBUG_LINUX_MEM_AREAS)
+#if defined(DEBUG_PVR) || defined(DEBUG_LINUX_MEM_AREAS)
const IMG_CHAR *HAPFlagsToString(IMG_UINT32 ui32Flags);
#endif
#include <linux/sched.h>
#include <asm/current.h>
#endif
+#if defined(SUPPORT_DRI_DRM)
+#include <drm/drmP.h>
+#endif
#include "img_defs.h"
#include "services.h"
#include "perproc.h"
#include "env_perproc.h"
#include "bridged_support.h"
+#if defined(SUPPORT_DRI_DRM)
+#include "pvr_drm.h"
+#endif
#if !defined(PVR_SECURE_HANDLES)
#error "The mmap code requires PVR_SECURE_HANDLES"
static IMG_UINT32 g_ui32TotalByteSize = 0;
#endif
+
+#if defined(PVR_PROC_USE_SEQ_FILE) && defined(DEBUG_LINUX_MMAP_AREAS)
+static struct proc_dir_entry *g_ProcMMap;
+#endif
+
#define FIRST_PHYSICAL_PFN 0
-#define LAST_PHYSICAL_PFN 0x7ffffffful
+#define LAST_PHYSICAL_PFN 0x7fffffffUL
#define FIRST_SPECIAL_PFN (LAST_PHYSICAL_PFN + 1)
-#define LAST_SPECIAL_PFN 0xfffffffful
+#define LAST_SPECIAL_PFN 0xffffffffUL
-#define MAX_MMAP_HANDLE 0x7ffffffful
+#define MAX_MMAP_HANDLE 0x7fffffffUL
static inline IMG_BOOL
PFNIsPhysical(IMG_UINT32 pfn)
{
- return pfn >= FIRST_PHYSICAL_PFN && pfn <= LAST_PHYSICAL_PFN;
+
+ return ((pfn >= FIRST_PHYSICAL_PFN) && (pfn <= LAST_PHYSICAL_PFN)) ? IMG_TRUE : IMG_FALSE;
}
static inline IMG_BOOL
PFNIsSpecial(IMG_UINT32 pfn)
{
- return pfn >= FIRST_SPECIAL_PFN && pfn <= LAST_SPECIAL_PFN;
+
+ return ((pfn >= FIRST_SPECIAL_PFN) && (pfn <= LAST_SPECIAL_PFN)) ? IMG_TRUE : IMG_FALSE;
}
static inline IMG_HANDLE
const IMG_CHAR *pszName = LinuxMemAreaTypeToString(LinuxMemAreaRootType(psLinuxMemArea));
#endif
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
"%s(%s, psLinuxMemArea: 0x%p, ui32AllocFlags: 0x%8lx)",
__FUNCTION__, pszName, psLinuxMemArea, psLinuxMemArea->ui32AreaFlags));
+#endif
PVR_ASSERT(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC || LinuxMemAreaRoot(psLinuxMemArea)->eAreaType != LINUX_MEM_AREA_SUB_ALLOC);
LinuxMemArea *psLinuxMemArea;
PKV_OFFSET_STRUCT psOffsetStruct;
IMG_HANDLE hOSMemHandle;
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError;
LinuxLockMutex(&g_sMMapMutex);
if (psPerProc->ui32PID == psOffsetStruct->ui32PID)
{
- PVR_ASSERT(*pui32RealByteSize == psOffsetStruct->ui32RealByteSize);
+ PVR_ASSERT(*pui32RealByteSize == psOffsetStruct->ui32RealByteSize);
*pui32MMapOffset = psOffsetStruct->ui32MMapOffset;
*pui32UserVAddr = psOffsetStruct->ui32UserVAddr;
eError = PVRSRV_OK;
goto exit_unlock;
- }
+ }
}
LinuxMemArea *psLinuxMemArea;
PKV_OFFSET_STRUCT psOffsetStruct;
IMG_HANDLE hOSMemHandle;
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError;
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
LinuxLockMutex(&g_sMMapMutex);
psOffsetStruct->ui32RefCount--;
- *pbMUnmap = (psOffsetStruct->ui32RefCount == 0) && (psOffsetStruct->ui32UserVAddr != 0);
+ *pbMUnmap = (IMG_BOOL)((psOffsetStruct->ui32RefCount == 0) && (psOffsetStruct->ui32UserVAddr != 0));
*pui32UserVAddr = (*pbMUnmap) ? psOffsetStruct->ui32UserVAddr : 0;
*pui32RealByteSize = (*pbMUnmap) ? psOffsetStruct->ui32RealByteSize : 0;
list_for_each_entry(psOffsetStruct, &g_sMMapOffsetStructList, sMMapItem)
{
- if (ui32Offset == psOffsetStruct->ui32MMapOffset && ui32RealByteSize == psOffsetStruct->ui32RealByteSize && psOffsetStruct->ui32PID == ui32PID)
+ if (ui32Offset == psOffsetStruct->ui32MMapOffset && ui32RealByteSize == psOffsetStruct->ui32RealByteSize && psOffsetStruct->ui32PID == ui32PID)
{
if (!PFNIsPhysical(ui32Offset) || psOffsetStruct->ui32TID == ui32TID)
if (psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC)
{
- return DoMapToUser(LinuxMemAreaRoot(psLinuxMemArea),
+ return DoMapToUser(LinuxMemAreaRoot(psLinuxMemArea),
ps_vma,
psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset + ui32ByteOffset);
}
static struct vm_operations_struct MMapIOOps =
{
- open: MMapVOpen,
- close: MMapVClose
+ .open=MMapVOpen,
+ .close=MMapVClose
};
PVRMMap(struct file* pFile, struct vm_area_struct* ps_vma)
{
IMG_UINT32 ui32ByteSize;
- PKV_OFFSET_STRUCT psOffsetStruct = NULL;
+ PKV_OFFSET_STRUCT psOffsetStruct;
int iRetVal = 0;
PVR_UNREFERENCED_PARAMETER(pFile);
ps_vma->vm_pgoff,
ui32ByteSize, ui32ByteSize));
-
- if ((ps_vma->vm_flags & VM_WRITE) &&
- !(ps_vma->vm_flags & VM_SHARED))
- {
- PVR_DPF((PVR_DBG_ERROR, "%s: Cannot mmap non-shareable writable areas", __FUNCTION__));
- iRetVal = -EINVAL;
- goto unlock_and_return;
- }
-
psOffsetStruct = FindOffsetStructByOffset(ps_vma->vm_pgoff, ui32ByteSize);
if (psOffsetStruct == IMG_NULL)
{
+#if defined(SUPPORT_DRI_DRM)
+ LinuxUnLockMutex(&g_sMMapMutex);
+
+
+ return drm_mmap(pFile, ps_vma);
+#else
+ PVR_UNREFERENCED_PARAMETER(pFile);
+
PVR_DPF((PVR_DBG_ERROR,
"%s: Attempted to mmap unregistered area at vm_pgoff %ld",
__FUNCTION__, ps_vma->vm_pgoff));
iRetVal = -EINVAL;
+#endif
goto unlock_and_return;
}
list_del(&psOffsetStruct->sMMapItem);
psOffsetStruct->bOnMMapList = IMG_FALSE;
+
+ if (((ps_vma->vm_flags & VM_WRITE) != 0) &&
+ ((ps_vma->vm_flags & VM_SHARED) == 0))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: Cannot mmap non-shareable writable areas", __FUNCTION__));
+ iRetVal = -EINVAL;
+ goto unlock_and_return;
+ }
+
PVR_DPF((PVR_DBG_MESSAGE, "%s: Mapped psLinuxMemArea 0x%p\n",
__FUNCTION__, psOffsetStruct->psLinuxMemArea));
#if defined(DEBUG_LINUX_MMAP_AREAS)
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void ProcSeqStartstopMMapRegistations(struct seq_file *sfile,IMG_BOOL start)
+{
+ if(start)
+ {
+ LinuxLockMutex(&g_sMMapMutex);
+ }
+ else
+ {
+ LinuxUnLockMutex(&g_sMMapMutex);
+ }
+}
+
+
+static void* ProcSeqOff2ElementMMapRegistrations(struct seq_file *sfile, loff_t off)
+{
+ LinuxMemArea *psLinuxMemArea;
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+ list_for_each_entry(psLinuxMemArea, &g_sMMapAreaList, sMMapItem)
+ {
+ PKV_OFFSET_STRUCT psOffsetStruct;
+
+ list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+ {
+ off--;
+ if (off == 0)
+ {
+ PVR_ASSERT(psOffsetStruct->psLinuxMemArea == psLinuxMemArea);
+ return (void*)psOffsetStruct;
+ }
+ }
+ }
+ return (void*)0;
+}
+
+static void* ProcSeqNextMMapRegistrations(struct seq_file *sfile,void* el,loff_t off)
+{
+ return ProcSeqOff2ElementMMapRegistrations(sfile,off);
+}
+
+
+static void ProcSeqShowMMapRegistrations(struct seq_file *sfile,void* el)
+{
+ KV_OFFSET_STRUCT *psOffsetStruct = (KV_OFFSET_STRUCT*)el;
+ LinuxMemArea *psLinuxMemArea;
+ IMG_UINT32 ui32RealByteSize;
+ IMG_UINT32 ui32ByteOffset;
+
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+ seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ "Allocations registered for mmap: %lu\n"
+ "In total these areas correspond to %lu bytes\n"
+ "psLinuxMemArea "
+ "UserVAddr "
+ "KernelVAddr "
+ "CpuPAddr "
+ "MMapOffset "
+ "ByteLength "
+ "LinuxMemType "
+ "Pid Name Flags\n",
+#else
+ "<mmap_header>\n"
+ "\t<count>%lu</count>\n"
+ "\t<bytes>%lu</bytes>\n"
+ "</mmap_header>\n",
+#endif
+ g_ui32RegisteredAreas,
+ g_ui32TotalByteSize
+ );
+ return;
+ }
+
+ psLinuxMemArea = psOffsetStruct->psLinuxMemArea;
+
+ DetermineUsersSizeAndByteOffset(psLinuxMemArea,
+ &ui32RealByteSize,
+ &ui32ByteOffset);
+
+ seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+ "%-8p %08lx %-8p %08lx %08lx %-8ld %-24s %-5lu %-8s %08lx(%s)\n",
+#else
+ "<mmap_record>\n"
+ "\t<pointer>%-8p</pointer>\n"
+ "\t<user_virtual>%-8lx</user_virtual>\n"
+ "\t<kernel_virtual>%-8p</kernel_virtual>\n"
+ "\t<cpu_physical>%08lx</cpu_physical>\n"
+ "\t<mmap_offset>%08lx</mmap_offset>\n"
+ "\t<bytes>%-8ld</bytes>\n"
+ "\t<linux_mem_area_type>%-24s</linux_mem_area_type>\n"
+ "\t<pid>%-5lu</pid>\n"
+ "\t<name>%-8s</name>\n"
+ "\t<flags>%08lx</flags>\n"
+ "\t<flags_string>%s</flags_string>\n"
+ "</mmap_record>\n",
+#endif
+ psLinuxMemArea,
+ psOffsetStruct->ui32UserVAddr + ui32ByteOffset,
+ LinuxMemAreaToCpuVAddr(psLinuxMemArea),
+ LinuxMemAreaToCpuPAddr(psLinuxMemArea,0).uiAddr,
+ psOffsetStruct->ui32MMapOffset,
+ psLinuxMemArea->ui32ByteSize,
+ LinuxMemAreaTypeToString(psLinuxMemArea->eAreaType),
+ psOffsetStruct->ui32PID,
+ psOffsetStruct->pszName,
+ psLinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString(psLinuxMemArea->ui32AreaFlags));
+}
+
+#else
+
static off_t
PrintMMapRegistrations(IMG_CHAR *buffer, size_t size, off_t off)
{
{
PKV_OFFSET_STRUCT psOffsetStruct;
- list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+ list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
{
off--;
if (off == 0)
LinuxUnLockMutex(&g_sMMapMutex);
return Ret;
}
+#endif
#endif
PVRSRV_ERROR
PVRMMapRegisterArea(LinuxMemArea *psLinuxMemArea)
{
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError;
#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
const IMG_CHAR *pszName = LinuxMemAreaTypeToString(LinuxMemAreaRootType(psLinuxMemArea));
#endif
LinuxLockMutex(&g_sMMapMutex);
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
"%s(%s, psLinuxMemArea 0x%p, ui32AllocFlags 0x%8lx)",
__FUNCTION__, pszName, psLinuxMemArea, psLinuxMemArea->ui32AreaFlags));
+#endif
PVR_ASSERT(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC || LinuxMemAreaRoot(psLinuxMemArea)->eAreaType != LINUX_MEM_AREA_SUB_ALLOC);
PVRSRV_ERROR
PVRMMapRemoveRegisteredArea(LinuxMemArea *psLinuxMemArea)
{
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError;
PKV_OFFSET_STRUCT psOffsetStruct, psTmpOffsetStruct;
LinuxLockMutex(&g_sMMapMutex);
PVRSRV_ERROR LinuxMMapPerProcessHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ PVRSRV_ERROR eError;
eError = PVRSRVSetMaxHandle(psHandleBase, MAX_MMAP_HANDLE);
if (eError != PVRSRV_OK)
}
#if defined(DEBUG_LINUX_MMAP_AREAS)
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_ProcMMap = CreateProcReadEntrySeq("mmap", NULL,
+ ProcSeqNextMMapRegistrations,
+ ProcSeqShowMMapRegistrations,
+ ProcSeqOff2ElementMMapRegistrations,
+ ProcSeqStartstopMMapRegistations
+ );
+#else
CreateProcReadEntry("mmap", PrintMMapRegistrations);
-#endif
-
+#endif
+#endif
return;
error:
PVR_DPF((PVR_DBG_ERROR, "%s: Memory areas are still registered with MMap", __FUNCTION__));
PVR_TRACE(("%s: Unregistering memory areas", __FUNCTION__));
- list_for_each_entry_safe(psLinuxMemArea, psTmpMemArea, &g_sMMapAreaList, sMMapItem)
+ list_for_each_entry_safe(psLinuxMemArea, psTmpMemArea, &g_sMMapAreaList, sMMapItem)
{
eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
if (eError != PVRSRV_OK)
}
PVR_ASSERT(list_empty((&g_sMMapAreaList)));
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq(g_ProcMMap);
+#else
RemoveProcEntry("mmap");
+#endif
+#endif
if(g_psMemmapCache)
{
#include <linux/config.h>
#endif
+#if !defined(SUPPORT_DRI_DRM)
+
+ #if defined(LDM_PLATFORM)
+ #define PVR_LDM_PLATFORM_MODULE
+ #define PVR_LDM_MODULE
+ #else
+ #if defined(LDM_PCI)
+ #define PVR_LDM_PCI_MODULE
+ #define PVR_LDM_MODULE
+ #endif
+ #endif
+#endif
+
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
-#if defined(LDM_PLATFORM)
+#if defined(SUPPORT_DRI_DRM)
+#include <drm/drmP.h>
+#endif
+
+#if defined(PVR_LDM_PLATFORM_MODULE)
#include <linux/platform_device.h>
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
#include <linux/pci.h>
#endif
-#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
#include <asm/uaccess.h>
#endif
#define DRVNAME "pvrsrvkm"
#define DEVNAME "pvrsrvkm"
+#if defined(SUPPORT_DRI_DRM)
+#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
+#else
+#define PRIVATE_DATA(pFile) ((pFile)->private_data)
+#endif
MODULE_SUPPORTED_DEVICE(DEVNAME);
-#ifdef DEBUG
+#ifdef DEBUG_PVR
static IMG_INT debug = DBGPRIV_WARNING;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
#include <linux/moduleparam.h>
extern IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
extern IMG_BOOL PVRGetBufferClassJTable(PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable);
+
EXPORT_SYMBOL(PVRGetDisplayClassJTable);
EXPORT_SYMBOL(PVRGetBufferClassJTable);
-static IMG_INT AssignedMajorNumber;
-
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
static struct class *psPvrClass;
#endif
+#if !defined(SUPPORT_DRI_DRM)
+static IMG_INT AssignedMajorNumber;
+
static IMG_INT PVRSRVOpen(struct inode* pInode, struct file* pFile);
static IMG_INT PVRSRVRelease(struct inode* pInode, struct file* pFile);
-PVRSRV_LINUX_MUTEX gPVRSRVLock;
-
static struct file_operations pvrsrv_fops = {
- owner:THIS_MODULE,
- unlocked_ioctl:PVRSRV_BridgeDispatchKM,
- open:PVRSRVOpen,
- release:PVRSRVRelease,
- mmap:PVRMMap,
+ .owner=THIS_MODULE,
+ .unlocked_ioctl=PVRSRV_BridgeDispatchKM,
+ .open=PVRSRVOpen,
+ .release=PVRSRVRelease,
+ .mmap=PVRMMap,
};
+#endif
+PVRSRV_LINUX_MUTEX gPVRSRVLock;
+
+IMG_UINT32 gui32ReleasePID;
-#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
static IMG_UINT32 gPVRPowerLevel;
#endif
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
#define LDM_DEV struct platform_device
#define LDM_DRV struct platform_driver
-#if defined(LDM_PCI)
-#undef LDM_PCI
-#endif
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
#define LDM_DEV struct pci_dev
#define LDM_DRV struct pci_driver
#endif
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
static IMG_INT PVRSRVDriverRemove(LDM_DEV *device);
static IMG_INT PVRSRVDriverProbe(LDM_DEV *device);
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
static IMG_VOID PVRSRVDriverRemove(LDM_DEV *device);
static IMG_INT PVRSRVDriverProbe(LDM_DEV *device, const struct pci_device_id *id);
#endif
static IMG_VOID PVRSRVDriverShutdown(LDM_DEV *device);
static IMG_INT PVRSRVDriverResume(LDM_DEV *device);
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
struct pci_device_id powervr_id_table[] __devinitdata = {
{ PCI_DEVICE(SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV_DEVICE_ID) },
{ 0 }
#endif
static LDM_DRV powervr_driver = {
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
.driver = {
.name = DRVNAME,
},
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
.name = DRVNAME,
.id_table = powervr_id_table,
#endif
.probe = PVRSRVDriverProbe,
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
.remove = PVRSRVDriverRemove,
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
.remove = __devexit_p(PVRSRVDriverRemove),
#endif
.suspend = PVRSRVDriverSuspend,
LDM_DEV *gpsPVRLDMDev;
-#if defined(LDM_PLATFORM)
-static IMG_VOID PVRSRVDeviceRelease(struct device *device);
+#if defined(MODULE) && defined(PVR_LDM_PLATFORM_MODULE)
+
+static IMG_VOID PVRSRVDeviceRelease(struct device *pDevice)
+{
+ PVR_UNREFERENCED_PARAMETER(pDevice);
+}
static struct platform_device powervr_device = {
.name = DEVNAME,
.id = -1,
.dev = {
- .release = PVRSRVDeviceRelease
+ .release = PVRSRVDeviceRelease
}
};
+
#endif
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
static IMG_INT PVRSRVDriverProbe(LDM_DEV *pDevice)
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
static IMG_INT __devinit PVRSRVDriverProbe(LDM_DEV *pDevice, const struct pci_device_id *id)
#endif
{
}
-#if defined (LDM_PLATFORM)
+#if defined (PVR_LDM_PLATFORM_MODULE)
static IMG_INT PVRSRVDriverRemove(LDM_DEV *pDevice)
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
static IMG_VOID __devexit PVRSRVDriverRemove(LDM_DEV *pDevice)
#endif
{
if (SysAcquireData(&psSysData) == PVRSRV_OK)
{
-#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
if (gPVRPowerLevel != 0)
{
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D0) == PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
{
gPVRPowerLevel = 0;
}
}
#endif
-#if defined (LDM_PLATFORM)
+#if defined (PVR_LDM_PLATFORM_MODULE)
return 0;
#endif
-#if defined (LDM_PCI)
+#if defined (PVR_LDM_PCI_MODULE)
return;
#endif
}
{
PVR_TRACE(("PVRSRVDriverShutdown(pDevice=%p)", pDevice));
- (IMG_VOID) PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D3);
+ (IMG_VOID) PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3);
}
+#endif
+
+#if defined(PVR_LDM_MODULE) || defined(SUPPORT_DRI_DRM)
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVDriverSuspend(struct drm_device *pDevice, pm_message_t state)
+#else
static IMG_INT PVRSRVDriverSuspend(LDM_DEV *pDevice, pm_message_t state)
+#endif
{
-#if !(defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL))
+#if !(defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
PVR_TRACE(( "PVRSRVDriverSuspend(pDevice=%p)", pDevice));
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D3) != PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3) != PVRSRV_OK)
{
return -EINVAL;
}
}
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVDriverResume(struct drm_device *pDevice)
+#else
static IMG_INT PVRSRVDriverResume(LDM_DEV *pDevice)
+#endif
{
-#if !(defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL))
+#if !(defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
PVR_TRACE(("PVRSRVDriverResume(pDevice=%p)", pDevice));
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D0) != PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) != PVRSRV_OK)
{
return -EINVAL;
}
#endif
return 0;
}
-
-
-#if defined(LDM_PLATFORM)
-static IMG_VOID PVRSRVDeviceRelease(struct device *pDevice)
-{
- PVR_DPF((PVR_DBG_WARNING, "PVRSRVDeviceRelease(pDevice=%p)", pDevice));
-}
-#endif
#endif
-#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM)
IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data)
{
IMG_CHAR data_buffer[2];
{
if (PVRPowerLevel != 0)
{
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D3) != PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3) != PVRSRV_OK)
{
return -EINVAL;
}
}
else
{
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D0) != PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) != PVRSRV_OK)
{
return -EINVAL;
}
return (count);
}
+#ifdef PVR_PROC_USE_SEQ_FILE
+void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el)
+{
+ seq_printf(sfile, "%lu\n", gPVRPowerLevel);
+}
+
+#else
IMG_INT PVRProcGetPowerLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
{
if (off == 0) {
*eof = 1;
return 0;
}
+#endif
+
#endif
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVOpen(struct drm_device unref__ *dev, struct drm_file *pFile)
+#else
static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile)
+#endif
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
IMG_HANDLE hBlockAlloc;
PVRSRV_ERROR eError;
IMG_UINT32 ui32PID;
+#if defined(SUPPORT_DRI_DRM)
+ PVR_UNREFERENCED_PARAMETER(dev);
+#else
+ PVR_UNREFERENCED_PARAMETER(pInode);
+#endif
+
LinuxLockMutex(&gPVRSRVLock);
ui32PID = OSGetCurrentProcessIDKM();
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_FILE_PRIVATE_DATA),
(IMG_PVOID *)&psPrivateData,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "File Private Data");
if(eError != PVRSRV_OK)
goto err_unlock;
#endif
psPrivateData->ui32OpenPID = ui32PID;
psPrivateData->hBlockAlloc = hBlockAlloc;
- pFile->private_data = psPrivateData;
-
+ PRIVATE_DATA(pFile) = psPrivateData;
iRet = 0;
err_unlock:
LinuxUnLockMutex(&gPVRSRVLock);
}
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVRelease(struct drm_device unref__ *dev, struct drm_file *pFile)
+#else
static IMG_INT PVRSRVRelease(struct inode unref__ * pInode, struct file *pFile)
+#endif
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
+#if defined(SUPPORT_DRI_DRM)
+ PVR_UNREFERENCED_PARAMETER(dev);
+#else
+ PVR_UNREFERENCED_PARAMETER(pInode);
+#endif
+
LinuxLockMutex(&gPVRSRVLock);
- psPrivateData = pFile->private_data;
+ psPrivateData = PRIVATE_DATA(pFile);
+ gui32ReleasePID = psPrivateData->ui32OpenPID;
PVRSRVProcessDisconnect(psPrivateData->ui32OpenPID);
+ gui32ReleasePID = 0;
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_FILE_PRIVATE_DATA),
psPrivateData, psPrivateData->hBlockAlloc);
+ PRIVATE_DATA(pFile) = NULL;
LinuxUnLockMutex(&gPVRSRVLock);
return 0;
}
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRCore_Init(IMG_VOID)
+#else
static IMG_INT __init PVRCore_Init(IMG_VOID)
+#endif
{
IMG_INT error;
-#if !(defined(LDM_PLATFORM) || defined(LDM_PCI))
+#if !defined(PVR_LDM_MODULE)
PVRSRV_ERROR eError;
#else
struct device *psDev;
#endif
+#if !defined(SUPPORT_DRI_DRM)
PVRDPFInit();
-
+#endif
PVR_TRACE(("PVRCore_Init"));
LinuxInitMutex(&gPVRSRVLock);
-#ifdef DEBUG
+#ifdef DEBUG_PVR
PVRDebugSetLevel(debug);
#endif
PVRMMapInit();
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
-#if defined(LDM_PLATFORM)
+#if defined(PVR_LDM_PLATFORM_MODULE)
if ((error = platform_driver_register(&powervr_driver)) != 0)
{
PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to register platform driver (%d)", error));
goto init_failed;
}
+#if defined(MODULE)
if ((error = platform_device_register(&powervr_device)) != 0)
{
platform_driver_unregister(&powervr_driver);
goto init_failed;
}
+#endif
#endif
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
if ((error = pci_register_driver(&powervr_driver)) != 0)
{
PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to register PCI driver (%d)", error));
goto init_failed;
}
#endif
-#if defined(SUPPORT_DRI_DRM)
- if(PVRSRVDrmInit() != PVRSRV_OK)
- {
- error = -ENODEV;
- goto sys_deinit;
- }
-#endif
+#if !defined(SUPPORT_DRI_DRM)
AssignedMajorNumber = register_chrdev(0, DEVNAME, &pvrsrv_fops);
if (AssignedMajorNumber <= 0)
PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to get major number"));
error = -EBUSY;
- goto drm_deinit;
+ goto sys_deinit;
}
PVR_TRACE(("PVRCore_Init: major device %d", AssignedMajorNumber));
+#endif
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
psPvrClass = class_create(THIS_MODULE, "pvr");
return 0;
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
destroy_class:
class_destroy(psPvrClass);
unregister_device:
+ unregister_chrdev((IMG_UINT)AssignedMajorNumber, DRVNAME);
#endif
- unregister_chrdev(AssignedMajorNumber, DRVNAME);
-drm_deinit:
-#if defined(SUPPORT_DRI_DRM)
- PVRSRVDrmExit();
+#if !defined(SUPPORT_DRI_DRM)
sys_deinit:
#endif
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
+#if defined(PVR_LDM_PCI_MODULE)
pci_unregister_driver(&powervr_driver);
#endif
-#if defined (LDM_PLATFORM)
+#if defined (PVR_LDM_PLATFORM_MODULE)
+#if defined (MODULE)
platform_device_unregister(&powervr_device);
+#endif
platform_driver_unregister(&powervr_driver);
#endif
}
+#if defined(SUPPORT_DRI_DRM)
+IMG_VOID PVRCore_Cleanup(IMG_VOID)
+#else
static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID)
+#endif
{
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
device_destroy(psPvrClass, MKDEV(AssignedMajorNumber, 0));
class_destroy(psPvrClass);
#endif
+#if !defined(SUPPORT_DRI_DRM)
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22))
if (
#endif
- unregister_chrdev(AssignedMajorNumber, DRVNAME)
+ unregister_chrdev((IMG_UINT)AssignedMajorNumber, DRVNAME)
#if !(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22))
;
#else
PVR_DPF((PVR_DBG_ERROR," can't unregister device major %d", AssignedMajorNumber));
}
#endif
+#endif
-#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+#if defined(PVR_LDM_MODULE)
-#if defined(LDM_PCI)
+#if defined(PVR_LDM_PCI_MODULE)
pci_unregister_driver(&powervr_driver);
#endif
-#if defined (LDM_PLATFORM)
+#if defined (PVR_LDM_PLATFORM_MODULE)
+#if defined (MODULE)
platform_device_unregister(&powervr_device);
+#endif
platform_driver_unregister(&powervr_driver);
#endif
#else
-#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
if (gPVRPowerLevel != 0)
{
- if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D0) == PVRSRV_OK)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
{
gPVRPowerLevel = 0;
}
RemoveProcEntries();
PVR_TRACE(("PVRCore_Cleanup: unloading"));
-#if defined(SUPPORT_DRI_DRM)
- PVRSRVDrmExit();
-#endif
}
+#if !defined(SUPPORT_DRI_DRM)
module_init(PVRCore_Init);
module_exit(PVRCore_Cleanup);
-
+#endif
if(mutex_lock_interruptible(psPVRSRVMutex) == -EINTR)
{
return PVRSRV_ERROR_GENERIC;
- }else{
+ }
+ else
+ {
return PVRSRV_OK;
}
}
IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
{
- return mutex_is_locked(psPVRSRVMutex);
+ return (IMG_BOOL)mutex_is_locked(psPVRSRVMutex);
}
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#ifndef AUTOCONF_INCLUDED\r
-#include <linux/config.h>\r
-#endif\r
-#include <linux/version.h>\r
-\r
-#include <linux/spinlock.h>\r
-#include <asm/page.h>\r
-/* Compilation Error */\r
-/*#include <asm/pgtable.h> */\r
-\r
-#include "img_defs.h"\r
-#include "pvr_debug.h"\r
-#include "mutils.h"\r
-\r
-#if defined(SUPPORT_LINUX_X86_PAT)\r
-#define PAT_LINUX_X86_WC 1\r
-\r
-#define PAT_X86_ENTRY_BITS 8\r
-\r
-#define PAT_X86_BIT_PWT 1\r
-#define PAT_X86_BIT_PCD 2\r
-#define PAT_X86_BIT_PAT 4\r
-#define PAT_X86_BIT_MASK (PAT_X86_BIT_PAT | PAT_X86_BIT_PCD | PAT_X86_BIT_PWT)\r
-\r
-static IMG_BOOL g_write_combining_available = IMG_FALSE;\r
-\r
-#define PROT_TO_PAT_INDEX(v, B) ((v & _PAGE_ ## B) ? PAT_X86_BIT_ ## B : 0)\r
-\r
-static inline IMG_UINT\r
-pvr_pat_index(pgprotval_t prot_val)\r
-{\r
- IMG_UINT ret = 0;\r
- pgprotval_t val = prot_val & _PAGE_CACHE_MASK;\r
-\r
- ret |= PROT_TO_PAT_INDEX(val, PAT);\r
- ret |= PROT_TO_PAT_INDEX(val, PCD);\r
- ret |= PROT_TO_PAT_INDEX(val, PWT);\r
-\r
- return ret;\r
-}\r
-\r
-static inline IMG_UINT\r
-pvr_pat_entry(u64 pat, IMG_UINT index)\r
-{\r
- return (pat >> (index * PAT_X86_ENTRY_BITS)) & PAT_X86_BIT_MASK;\r
-}\r
-\r
-static IMG_VOID\r
-PVRLinuxX86PATProbe(IMG_VOID)\r
-{\r
- \r
- if (cpu_has_pat)\r
- {\r
- u64 pat;\r
- IMG_UINT pat_index;\r
- IMG_UINT pat_entry;\r
-\r
- PVR_TRACE(("%s: PAT available", __FUNCTION__));\r
- \r
- rdmsrl(MSR_IA32_CR_PAT, pat);\r
- PVR_TRACE(("%s: Top 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat >> 32)));\r
- PVR_TRACE(("%s: Bottom 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat)));\r
-\r
- pat_index = pvr_pat_index(_PAGE_CACHE_WC);\r
- PVR_TRACE(("%s: PAT index for write combining: %u", __FUNCTION__, pat_index));\r
-\r
- pat_entry = pvr_pat_entry(pat, pat_index);\r
- PVR_TRACE(("%s: PAT entry for write combining: 0x%.2x (should be 0x%.2x)", __FUNCTION__, pat_entry, PAT_LINUX_X86_WC));\r
-\r
-#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)\r
- g_write_combining_available = (IMG_BOOL)(pat_entry == PAT_LINUX_X86_WC);\r
-#endif\r
- }\r
-#if defined(DEBUG)\r
-#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)\r
- if (g_write_combining_available)\r
- {\r
- PVR_TRACE(("%s: Write combining available via PAT", __FUNCTION__));\r
- }\r
- else\r
- {\r
- PVR_TRACE(("%s: Write combining not available", __FUNCTION__));\r
- }\r
-#else \r
- PVR_TRACE(("%s: Write combining disabled in driver build", __FUNCTION__));\r
-#endif \r
-#endif \r
-}\r
-\r
-pgprot_t\r
-pvr_pgprot_writecombine(pgprot_t prot)\r
-{\r
- \r
- return (g_write_combining_available) ?\r
- __pgprot((pgprot_val(prot) & ~_PAGE_CACHE_MASK) | _PAGE_CACHE_WC) : pgprot_noncached(prot);\r
-}\r
-#endif \r
-\r
-IMG_VOID\r
-PVRLinuxMUtilsInit(IMG_VOID)\r
-{\r
-#if defined(SUPPORT_LINUX_X86_PAT)\r
- PVRLinuxX86PATProbe();\r
-#endif\r
-}\r
-\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 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
+ *
+ ******************************************************************************/
+
+#ifndef AUTOCONF_INCLUDED
+#include <linux/config.h>
+#endif
+#include <linux/version.h>
+
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+
+#include "img_defs.h"
+#include "pvr_debug.h"
+#include "mutils.h"
+
+#if defined(SUPPORT_LINUX_X86_PAT)
+#define PAT_LINUX_X86_WC 1
+
+#define PAT_X86_ENTRY_BITS 8
+
+#define PAT_X86_BIT_PWT 1U
+#define PAT_X86_BIT_PCD 2U
+#define PAT_X86_BIT_PAT 4U
+#define PAT_X86_BIT_MASK (PAT_X86_BIT_PAT | PAT_X86_BIT_PCD | PAT_X86_BIT_PWT)
+
+static IMG_BOOL g_write_combining_available = IMG_FALSE;
+
+#define PROT_TO_PAT_INDEX(v, B) ((v & _PAGE_ ## B) ? PAT_X86_BIT_ ## B : 0)
+
+static inline IMG_UINT
+pvr_pat_index(pgprotval_t prot_val)
+{
+ IMG_UINT ret = 0;
+ pgprotval_t val = prot_val & _PAGE_CACHE_MASK;
+
+ ret |= PROT_TO_PAT_INDEX(val, PAT);
+ ret |= PROT_TO_PAT_INDEX(val, PCD);
+ ret |= PROT_TO_PAT_INDEX(val, PWT);
+
+ return ret;
+}
+
+static inline IMG_UINT
+pvr_pat_entry(u64 pat, IMG_UINT index)
+{
+ return (IMG_UINT)(pat >> (index * PAT_X86_ENTRY_BITS)) & PAT_X86_BIT_MASK;
+}
+
+static IMG_VOID
+PVRLinuxX86PATProbe(IMG_VOID)
+{
+
+ if (cpu_has_pat)
+ {
+ u64 pat;
+ IMG_UINT pat_index;
+ IMG_UINT pat_entry;
+
+ PVR_TRACE(("%s: PAT available", __FUNCTION__));
+
+ rdmsrl(MSR_IA32_CR_PAT, pat);
+ PVR_TRACE(("%s: Top 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat >> 32)));
+ PVR_TRACE(("%s: Bottom 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat)));
+
+ pat_index = pvr_pat_index(_PAGE_CACHE_WC);
+ PVR_TRACE(("%s: PAT index for write combining: %u", __FUNCTION__, pat_index));
+
+ pat_entry = pvr_pat_entry(pat, pat_index);
+ PVR_TRACE(("%s: PAT entry for write combining: 0x%.2x (should be 0x%.2x)", __FUNCTION__, pat_entry, PAT_LINUX_X86_WC));
+
+#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)
+ g_write_combining_available = (IMG_BOOL)(pat_entry == PAT_LINUX_X86_WC);
+#endif
+ }
+#if defined(DEBUG)
+#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)
+ if (g_write_combining_available)
+ {
+ PVR_TRACE(("%s: Write combining available via PAT", __FUNCTION__));
+ }
+ else
+ {
+ PVR_TRACE(("%s: Write combining not available", __FUNCTION__));
+ }
+#else
+ PVR_TRACE(("%s: Write combining disabled in driver build", __FUNCTION__));
+#endif
+#endif
+}
+
+pgprot_t
+pvr_pgprot_writecombine(pgprot_t prot)
+{
+
+
+ return (g_write_combining_available) ?
+ __pgprot((pgprot_val(prot) & ~_PAGE_CACHE_MASK) | _PAGE_CACHE_WC) : pgprot_noncached(prot);
+}
+#endif
+
+IMG_VOID
+PVRLinuxMUtilsInit(IMG_VOID)
+{
+#if defined(SUPPORT_LINUX_X86_PAT)
+ PVRLinuxX86PATProbe();
+#endif
+}
+
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
#include <asm/system.h>
#endif
+#if defined(SUPPORT_CPU_CACHED_BUFFERS)
+#include <asm/cacheflush.h>
+#endif
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/hugetlb.h>
#include <linux/capability.h>
#include <asm/uaccess.h>
#include <linux/spinlock.h>
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+#include <linux/workqueue.h>
+#endif
#include "img_types.h"
#include "services_headers.h"
#define HOST_ALLOC_MEM_USING_VMALLOC ((IMG_HANDLE)1)
#if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-PVRSRV_ERROR OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc)
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc)
#else
-PVRSRV_ERROR _OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
#endif
{
PVR_UNREFERENCED_PARAMETER(ui32Flags);
#endif
if(*ppvCpuVAddr)
{
- if (phBlockAlloc)
- {
-
- *phBlockAlloc = HOST_ALLOC_MEM_USING_KMALLOC;
- }
+ if (phBlockAlloc)
+ {
+
+ *phBlockAlloc = HOST_ALLOC_MEM_USING_KMALLOC;
+ }
}
else
{
- if (!phBlockAlloc)
- {
- return PVRSRV_ERROR_OUT_OF_MEMORY;
- }
+ if (!phBlockAlloc)
+ {
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
-
+
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
- *ppvCpuVAddr = _VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED, pszFilename, ui32Line);
+ *ppvCpuVAddr = _VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED, pszFilename, ui32Line);
#else
- *ppvCpuVAddr = VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED);
+ *ppvCpuVAddr = VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED);
#endif
- if (!*ppvCpuVAddr)
- {
- return PVRSRV_ERROR_OUT_OF_MEMORY;
- }
+ if (!*ppvCpuVAddr)
+ {
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
-
- *phBlockAlloc = HOST_ALLOC_MEM_USING_VMALLOC;
+
+ *phBlockAlloc = HOST_ALLOC_MEM_USING_VMALLOC;
}
return PVRSRV_OK;
#if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-PVRSRV_ERROR OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc)
+PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc)
#else
-PVRSRV_ERROR _OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
#endif
{
PVR_UNREFERENCED_PARAMETER(ui32Flags);
if (hBlockAlloc == HOST_ALLOC_MEM_USING_VMALLOC)
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
- _VFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
+ _VFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
#else
- VFreeWrapper(pvCpuVAddr);
+ VFreeWrapper(pvCpuVAddr);
#endif
}
else
{
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
- _KFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
+ _KFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
#else
KFreeWrapper(pvCpuVAddr);
#endif
PVRSRV_ERROR
-OSAllocPages(IMG_UINT32 ui32AllocFlags,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PageSize,
- IMG_VOID **ppvCpuVAddr,
- IMG_HANDLE *phOSMemHandle)
+OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PageSize,
+ IMG_VOID **ppvCpuVAddr,
+ IMG_HANDLE *phOSMemHandle)
{
- LinuxMemArea *psLinuxMemArea;
+ LinuxMemArea *psLinuxMemArea;
PVR_UNREFERENCED_PARAMETER(ui32PageSize);
#endif
switch(ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK)
- {
+ {
case PVRSRV_HAP_KERNEL_ONLY:
{
psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags);
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
- PVRMMapRegisterArea(psLinuxMemArea);
+ PVRMMapRegisterArea(psLinuxMemArea);
break;
}
- case PVRSRV_HAP_MULTI_PROCESS:
- {
+ case PVRSRV_HAP_MULTI_PROCESS:
+ {
#if defined(VIVT_CACHE) || defined(__sh__)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
- PVRMMapRegisterArea(psLinuxMemArea);
+ PVRMMapRegisterArea(psLinuxMemArea);
break;
}
default:
- PVR_DPF((PVR_DBG_ERROR, "OSAllocPages: invalid flags 0x%x\n", ui32AllocFlags));
+ PVR_DPF((PVR_DBG_ERROR, "OSAllocPages: invalid flags 0x%x\n", ui32AllocFlags));
*ppvCpuVAddr = NULL;
*phOSMemHandle = (IMG_HANDLE)0;
- return PVRSRV_ERROR_INVALID_PARAMS;
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+#if defined(SUPPORT_CACHEFLUSH_ON_ALLOC)
+
+ if(ui32AllocFlags & (PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_UNCACHED))
+ {
+ OSFlushCPUCacheKM();
}
+#endif
*ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
*phOSMemHandle = psLinuxMemArea;
LinuxMemAreaRegister(psLinuxMemArea);
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
}
break;
default:
- PVR_DPF((PVR_DBG_ERROR,"%s: invalid flags 0x%x\n",
+ PVR_DPF((PVR_DBG_ERROR,"%s: invalid flags 0x%x\n",
__FUNCTION__, ui32AllocFlags));
return PVRSRV_ERROR_INVALID_PARAMS;
}
LinuxMemAreaDeepFree(psLinuxMemArea);
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
Dst[i]=Src[i];
}
#else
- memcpy(pvDst, pvSrc, ui32Size);
+ memcpy(pvDst, pvSrc, ui32Size);
#endif
}
Buff[i]=ui8Value;
}
#else
- memset(pvDest, (IMG_INT) ui8Value, (size_t) ui32Size);
+ memset(pvDest, (IMG_INT) ui8Value, (size_t) ui32Size);
#endif
}
IMG_CHAR *OSStringCopy(IMG_CHAR *pszDest, const IMG_CHAR *pszSrc)
{
- return (strcpy(pszDest, pszSrc));
+ return (strcpy(pszDest, pszSrc));
}
IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_UINT32 ui32Size, const IMG_CHAR *pszFormat, ...)
IMG_VOID OSBreakResourceLock (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
{
- volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+ volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
- if(*pui32Access)
- {
- if(psResource->ui32ID == ui32ID)
- {
- psResource->ui32ID = 0;
- *pui32Access = 0;
- }
- else
- {
- PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked for this process."));
- }
- }
- else
- {
- PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked"));
- }
+ if(*pui32Access)
+ {
+ if(psResource->ui32ID == ui32ID)
+ {
+ psResource->ui32ID = 0;
+ *pui32Access = 0;
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked for this process."));
+ }
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked"));
+ }
}
PVRSRV_ERROR OSCreateResource(PVRSRV_RESOURCE *psResource)
{
- psResource->ui32ID = 0;
- psResource->ui32Lock = 0;
+ psResource->ui32ID = 0;
+ psResource->ui32Lock = 0;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSDestroyResource (PVRSRV_RESOURCE *psResource)
{
- OSBreakResourceLock (psResource, psResource->ui32ID);
+ OSBreakResourceLock (psResource, psResource->ui32ID);
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSInitEnvData(IMG_PVOID *ppvEnvSpecificData)
{
- ENV_DATA *psEnvData;
-
-
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), (IMG_VOID *)&psEnvData, IMG_NULL) != PVRSRV_OK)
- {
- return PVRSRV_ERROR_GENERIC;
- }
+ ENV_DATA *psEnvData;
+
+
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), (IMG_VOID **)&psEnvData, IMG_NULL,
+ "Environment Data") != PVRSRV_OK)
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE,
- &psEnvData->pvBridgeData, IMG_NULL) != PVRSRV_OK)
- {
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), psEnvData, IMG_NULL);
- return PVRSRV_ERROR_GENERIC;
- }
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE,
+ &psEnvData->pvBridgeData, IMG_NULL,
+ "Bridge Data") != PVRSRV_OK)
+ {
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), psEnvData, IMG_NULL);
+
+ return PVRSRV_ERROR_GENERIC;
+ }
-
- psEnvData->bMISRInstalled = IMG_FALSE;
- psEnvData->bLISRInstalled = IMG_FALSE;
+
+ psEnvData->bMISRInstalled = IMG_FALSE;
+ psEnvData->bLISRInstalled = IMG_FALSE;
-
- *ppvEnvSpecificData = psEnvData;
+
+ *ppvEnvSpecificData = psEnvData;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSDeInitEnvData(IMG_PVOID pvEnvSpecificData)
{
- ENV_DATA *psEnvData = (ENV_DATA*)pvEnvSpecificData;
+ ENV_DATA *psEnvData = (ENV_DATA*)pvEnvSpecificData;
- PVR_ASSERT(!psEnvData->bMISRInstalled);
- PVR_ASSERT(!psEnvData->bLISRInstalled);
+ PVR_ASSERT(!psEnvData->bMISRInstalled);
+ PVR_ASSERT(!psEnvData->bLISRInstalled);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0x1000, psEnvData->pvBridgeData, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE, psEnvData->pvBridgeData, IMG_NULL);
+ psEnvData->pvBridgeData = IMG_NULL;
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), pvEnvSpecificData, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), pvEnvSpecificData, IMG_NULL);
+
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
IMG_VOID OSReleaseThreadQuanta(IMG_VOID)
{
- schedule();
+ schedule();
}
IMG_UINT32 OSClockus(IMG_VOID)
{
- IMG_UINT32 time, j = jiffies;
+ IMG_UINT32 time, j = jiffies;
- time = j * (1000000 / HZ);
+ time = j * (1000000 / HZ);
- return time;
+ return time;
}
IMG_VOID OSWaitus(IMG_UINT32 ui32Timeus)
{
- udelay(ui32Timeus);
+ udelay(ui32Timeus);
}
IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID)
{
- if (in_interrupt())
- {
- return KERNEL_ID;
- }
+ if (in_interrupt())
+ {
+ return KERNEL_ID;
+ }
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
- return (IMG_UINT32)current->pgrp;
+ return (IMG_UINT32)current->pgrp;
#else
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
- return (IMG_UINT32)task_tgid_nr(current);
+ return (IMG_UINT32)task_tgid_nr(current);
#else
- return (IMG_UINT32)current->tgid;
+ return (IMG_UINT32)current->tgid;
#endif
#endif
}
IMG_UINT32 OSGetPageSize(IMG_VOID)
{
#if defined(__sh__)
- IMG_UINT32 ui32ReturnValue = PAGE_SIZE;
+ IMG_UINT32 ui32ReturnValue = PAGE_SIZE;
- return (ui32ReturnValue);
+ return (ui32ReturnValue);
#else
- return PAGE_SIZE;
+ return PAGE_SIZE;
#endif
}
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
static irqreturn_t DeviceISRWrapper(int irq, void *dev_id
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
- , struct pt_regs *regs
+ , struct pt_regs *regs
#endif
- )
+ )
{
- PVRSRV_DEVICE_NODE *psDeviceNode;
- IMG_BOOL bStatus = IMG_FALSE;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_BOOL bStatus = IMG_FALSE;
- PVR_UNREFERENCED_PARAMETER(irq);
+ PVR_UNREFERENCED_PARAMETER(irq);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
- PVR_UNREFERENCED_PARAMETER(regs);
+ PVR_UNREFERENCED_PARAMETER(regs);
#endif
- psDeviceNode = (PVRSRV_DEVICE_NODE*)dev_id;
- if(!psDeviceNode)
- {
- PVR_DPF((PVR_DBG_ERROR, "DeviceISRWrapper: invalid params\n"));
- goto out;
- }
-
- bStatus = PVRSRVDeviceLISR(psDeviceNode);
+ psDeviceNode = (PVRSRV_DEVICE_NODE*)dev_id;
+ if(!psDeviceNode)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DeviceISRWrapper: invalid params\n"));
+ goto out;
+ }
- if (bStatus)
- {
- SYS_DATA *psSysData = psDeviceNode->psSysData;
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ bStatus = PVRSRVDeviceLISR(psDeviceNode);
- tasklet_schedule(&psEnvData->sMISRTasklet);
- }
+ if (bStatus)
+ {
+ OSScheduleMISR((IMG_VOID *)psDeviceNode->psSysData);
+ }
out:
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
- return bStatus ? IRQ_HANDLED : IRQ_NONE;
+ return bStatus ? IRQ_HANDLED : IRQ_NONE;
#endif
}
static irqreturn_t SystemISRWrapper(int irq, void *dev_id
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
- , struct pt_regs *regs
+ , struct pt_regs *regs
#endif
- )
+ )
{
- SYS_DATA *psSysData;
- IMG_BOOL bStatus = IMG_FALSE;
+ SYS_DATA *psSysData;
+ IMG_BOOL bStatus = IMG_FALSE;
- PVR_UNREFERENCED_PARAMETER(irq);
+ PVR_UNREFERENCED_PARAMETER(irq);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
- PVR_UNREFERENCED_PARAMETER(regs);
+ PVR_UNREFERENCED_PARAMETER(regs);
#endif
- psSysData = (SYS_DATA *)dev_id;
- if(!psSysData)
- {
- PVR_DPF((PVR_DBG_ERROR, "SystemISRWrapper: invalid params\n"));
- goto out;
- }
-
- bStatus = PVRSRVSystemLISR(psSysData);
+ psSysData = (SYS_DATA *)dev_id;
+ if(!psSysData)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SystemISRWrapper: invalid params\n"));
+ goto out;
+ }
- if (bStatus)
- {
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ bStatus = PVRSRVSystemLISR(psSysData);
- tasklet_schedule(&psEnvData->sMISRTasklet);
- }
+ if (bStatus)
+ {
+ OSScheduleMISR((IMG_VOID *)psSysData);
+ }
out:
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
- return bStatus ? IRQ_HANDLED : IRQ_NONE;
+ return bStatus ? IRQ_HANDLED : IRQ_NONE;
#endif
}
PVRSRV_ERROR OSInstallDeviceLISR(IMG_VOID *pvSysData,
- IMG_UINT32 ui32Irq,
- IMG_CHAR *pszISRName,
- IMG_VOID *pvDeviceNode)
+ IMG_UINT32 ui32Irq,
+ IMG_CHAR *pszISRName,
+ IMG_VOID *pvDeviceNode)
{
- SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- if (psEnvData->bLISRInstalled)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSInstallDeviceLISR: An ISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- return PVRSRV_ERROR_GENERIC;
- }
+ if (psEnvData->bLISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallDeviceLISR: An ISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ return PVRSRV_ERROR_GENERIC;
+ }
- PVR_TRACE(("Installing device LISR %s on IRQ %d with cookie %x", pszISRName, ui32Irq, pvDeviceNode));
+ PVR_TRACE(("Installing device LISR %s on IRQ %d with cookie %x", pszISRName, ui32Irq, pvDeviceNode));
- if(request_irq(ui32Irq, DeviceISRWrapper,
+ if(request_irq(ui32Irq, DeviceISRWrapper,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
- SA_SHIRQ
+ SA_SHIRQ
#else
- IRQF_SHARED
+ IRQF_SHARED
#endif
- , pszISRName, pvDeviceNode))
- {
- PVR_DPF((PVR_DBG_ERROR,"OSInstallDeviceLISR: Couldn't install device LISR on IRQ %d", ui32Irq));
+ , pszISRName, pvDeviceNode))
+ {
+ PVR_DPF((PVR_DBG_ERROR,"OSInstallDeviceLISR: Couldn't install device LISR on IRQ %d", ui32Irq));
- return PVRSRV_ERROR_GENERIC;
- }
+ return PVRSRV_ERROR_GENERIC;
+ }
- psEnvData->ui32IRQ = ui32Irq;
- psEnvData->pvISRCookie = pvDeviceNode;
- psEnvData->bLISRInstalled = IMG_TRUE;
+ psEnvData->ui32IRQ = ui32Irq;
+ psEnvData->pvISRCookie = pvDeviceNode;
+ psEnvData->bLISRInstalled = IMG_TRUE;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSUninstallDeviceLISR(IMG_VOID *pvSysData)
{
- SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- if (!psEnvData->bLISRInstalled)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSUninstallDeviceLISR: No LISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
- }
-
- PVR_TRACE(("Uninstalling device LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ if (!psEnvData->bLISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSUninstallDeviceLISR: No LISR has been installed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ PVR_TRACE(("Uninstalling device LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
+ free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
- psEnvData->bLISRInstalled = IMG_FALSE;
+ psEnvData->bLISRInstalled = IMG_FALSE;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSInstallSystemLISR(IMG_VOID *pvSysData, IMG_UINT32 ui32Irq)
{
- SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- if (psEnvData->bLISRInstalled)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSInstallSystemLISR: An LISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- return PVRSRV_ERROR_GENERIC;
- }
+ if (psEnvData->bLISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallSystemLISR: An LISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ return PVRSRV_ERROR_GENERIC;
+ }
- PVR_TRACE(("Installing system LISR on IRQ %d with cookie %x", ui32Irq, pvSysData));
+ PVR_TRACE(("Installing system LISR on IRQ %d with cookie %x", ui32Irq, pvSysData));
- if(request_irq(ui32Irq, SystemISRWrapper,
+ if(request_irq(ui32Irq, SystemISRWrapper,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
- SA_SHIRQ
+ SA_SHIRQ
#else
- IRQF_SHARED
+ IRQF_SHARED
#endif
- , "PowerVR", pvSysData))
- {
- PVR_DPF((PVR_DBG_ERROR,"OSInstallSystemLISR: Couldn't install system LISR on IRQ %d", ui32Irq));
+ , "PowerVR", pvSysData))
+ {
+ PVR_DPF((PVR_DBG_ERROR,"OSInstallSystemLISR: Couldn't install system LISR on IRQ %d", ui32Irq));
- return PVRSRV_ERROR_GENERIC;
- }
+ return PVRSRV_ERROR_GENERIC;
+ }
- psEnvData->ui32IRQ = ui32Irq;
- psEnvData->pvISRCookie = pvSysData;
- psEnvData->bLISRInstalled = IMG_TRUE;
+ psEnvData->ui32IRQ = ui32Irq;
+ psEnvData->pvISRCookie = pvSysData;
+ psEnvData->bLISRInstalled = IMG_TRUE;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSUninstallSystemLISR(IMG_VOID *pvSysData)
{
- SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
- ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- if (!psEnvData->bLISRInstalled)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSUninstallSystemLISR: No LISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
- }
+ if (!psEnvData->bLISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSUninstallSystemLISR: No LISR has been installed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
- PVR_TRACE(("Uninstalling system LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ PVR_TRACE(("Uninstalling system LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
+ free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
- psEnvData->bLISRInstalled = IMG_FALSE;
+ psEnvData->bLISRInstalled = IMG_FALSE;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
-
-static void MISRWrapper(unsigned long data)
+#if defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+static void MISRWrapper(
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+ void *data
+#else
+ struct work_struct *data
+#endif
+)
{
- SYS_DATA *psSysData;
+ ENV_DATA *psEnvData = container_of(data, ENV_DATA, sMISRWork);
+ SYS_DATA *psSysData = (SYS_DATA *)psEnvData->pvMISRData;
- psSysData = (SYS_DATA *)data;
-
PVRSRVMISR(psSysData);
}
PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
- tasklet_init(&psEnvData->sMISRTasklet, MISRWrapper, (unsigned long)pvSysData);
+ psEnvData->psWorkQueue = create_singlethread_workqueue("pvr_workqueue");
+
+ if (psEnvData->psWorkQueue == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: create_singlethreaded_workqueue failed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+ , (void *)&psEnvData->sMISRWork
+#endif
+ );
+ psEnvData->pvMISRData = pvSysData;
psEnvData->bMISRInstalled = IMG_TRUE;
return PVRSRV_OK;
PVR_TRACE(("Uninstalling MISR"));
- tasklet_kill(&psEnvData->sMISRTasklet);
+ flush_workqueue(psEnvData->psWorkQueue);
+
+ destroy_workqueue(psEnvData->psWorkQueue);
psEnvData->bMISRInstalled = IMG_FALSE;
return PVRSRV_OK;
}
+
PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
{
SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
if (psEnvData->bMISRInstalled)
{
- tasklet_schedule(&psEnvData->sMISRTasklet);
+ queue_work(psEnvData->psWorkQueue, &psEnvData->sMISRWork);
}
return PVRSRV_OK;
}
-
-
-#endif
-
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
-#define OS_TAS(p) xchg((p), 1)
+#else
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE)
+static void MISRWrapper(
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+ void *data
#else
-#define OS_TAS(p) tas(p)
+ struct work_struct *data
#endif
-PVRSRV_ERROR OSLockResource ( PVRSRV_RESOURCE *psResource,
- IMG_UINT32 ui32ID)
+)
+{
+ ENV_DATA *psEnvData = container_of(data, ENV_DATA, sMISRWork);
+ SYS_DATA *psSysData = (SYS_DATA *)psEnvData->pvMISRData;
+ PVRSRVMISR(psSysData);
+}
+
+
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+ if (psEnvData->bMISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
+
+ PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
+
+ INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+ , (void *)&psEnvData->sMISRWork
+#endif
+ );
- if(!OS_TAS(&psResource->ui32Lock))
- psResource->ui32ID = ui32ID;
- else
- eError = PVRSRV_ERROR_GENERIC;
+ psEnvData->pvMISRData = pvSysData;
+ psEnvData->bMISRInstalled = IMG_TRUE;
- return eError;
+ return PVRSRV_OK;
}
-PVRSRV_ERROR OSUnlockResource (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData)
{
- volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
- PVRSRV_ERROR eError = PVRSRV_OK;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- if(*pui32Access)
+ if (!psEnvData->bMISRInstalled)
{
- if(psResource->ui32ID == ui32ID)
- {
- psResource->ui32ID = 0;
- *pui32Access = 0;
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked with expected value.", psResource));
- PVR_DPF((PVR_DBG_MESSAGE,"Should be %x is actually %x", ui32ID, psResource->ui32ID));
- eError = PVRSRV_ERROR_GENERIC;
- }
+ PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
+ return PVRSRV_ERROR_GENERIC;
}
- else
+
+ PVR_TRACE(("Uninstalling MISR"));
+
+ flush_scheduled_work();
+
+ psEnvData->bMISRInstalled = IMG_FALSE;
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
+{
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA*)psSysData->pvEnvSpecificData;
+
+ if (psEnvData->bMISRInstalled)
{
- PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked", psResource));
- eError = PVRSRV_ERROR_GENERIC;
+ schedule_work(&psEnvData->sMISRWork);
}
-
- return eError;
+
+ return PVRSRV_OK;
}
+#else
-IMG_BOOL OSIsResourceLocked (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+
+static void MISRWrapper(unsigned long data)
{
- volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+ SYS_DATA *psSysData;
- return (*(volatile IMG_UINT32 *)pui32Access == 1) && (psResource->ui32ID == ui32ID)
- ? IMG_TRUE
- : IMG_FALSE;
+ psSysData = (SYS_DATA *)data;
+
+ PVRSRVMISR(psSysData);
}
-IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_VOID *pvLinAddr)
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData)
{
- IMG_CPU_PHYADDR CpuPAddr;
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
- CpuPAddr.uiAddr = (IMG_UINTPTR_T)VMallocToPhys(pvLinAddr);
+ if (psEnvData->bMISRInstalled)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
+ return PVRSRV_ERROR_GENERIC;
+ }
- return CpuPAddr;
+ PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
+
+ tasklet_init(&psEnvData->sMISRTasklet, MISRWrapper, (unsigned long)pvSysData);
+
+ psEnvData->bMISRInstalled = IMG_TRUE;
+
+ return PVRSRV_OK;
}
-IMG_VOID *
-OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
- IMG_UINT32 ui32Bytes,
- IMG_UINT32 ui32MappingFlags,
- IMG_HANDLE *phOSMemHandle)
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData)
{
- if(phOSMemHandle)
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+ if (!psEnvData->bMISRInstalled)
{
- *phOSMemHandle = (IMG_HANDLE)0;
+ PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
+ return PVRSRV_ERROR_GENERIC;
}
- if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
+ PVR_TRACE(("Uninstalling MISR"));
+
+ tasklet_kill(&psEnvData->sMISRTasklet);
+
+ psEnvData->bMISRInstalled = IMG_FALSE;
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
+{
+ SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+ ENV_DATA *psEnvData = (ENV_DATA*)psSysData->pvEnvSpecificData;
+
+ if (psEnvData->bMISRInstalled)
{
- IMG_VOID *pvIORemapCookie;
- pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags);
- if(pvIORemapCookie == IMG_NULL)
- {
- return NULL;
- }
- return pvIORemapCookie;
+ tasklet_schedule(&psEnvData->sMISRTasklet);
}
- else
- {
+
+ return PVRSRV_OK;
+}
+
+#endif
+#endif
+
+#endif
+
+IMG_VOID OSPanic(IMG_VOID)
+{
+ BUG();
+}
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#define OS_TAS(p) xchg((p), 1)
+#else
+#define OS_TAS(p) tas(p)
+#endif
+PVRSRV_ERROR OSLockResource ( PVRSRV_RESOURCE *psResource,
+ IMG_UINT32 ui32ID)
+
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if(!OS_TAS(&psResource->ui32Lock))
+ psResource->ui32ID = ui32ID;
+ else
+ eError = PVRSRV_ERROR_GENERIC;
+
+ return eError;
+}
+
+
+PVRSRV_ERROR OSUnlockResource (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+{
+ volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if(*pui32Access)
+ {
+ if(psResource->ui32ID == ui32ID)
+ {
+ psResource->ui32ID = 0;
+ *pui32Access = 0;
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked with expected value.", psResource));
+ PVR_DPF((PVR_DBG_MESSAGE,"Should be %x is actually %x", ui32ID, psResource->ui32ID));
+ eError = PVRSRV_ERROR_GENERIC;
+ }
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked", psResource));
+ eError = PVRSRV_ERROR_GENERIC;
+ }
+
+ return eError;
+}
+
+
+IMG_BOOL OSIsResourceLocked (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+{
+ volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+
+ return (*(volatile IMG_UINT32 *)pui32Access == 1) && (psResource->ui32ID == ui32ID)
+ ? IMG_TRUE
+ : IMG_FALSE;
+}
+
+
+IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_VOID *pvLinAddr)
+{
+ IMG_CPU_PHYADDR CpuPAddr;
+
+ CpuPAddr.uiAddr = (IMG_UINTPTR_T)VMallocToPhys(pvLinAddr);
+
+ return CpuPAddr;
+}
+
+
+IMG_VOID *
+OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32MappingFlags,
+ IMG_HANDLE *phOSMemHandle)
+{
+ if(phOSMemHandle)
+ {
+ *phOSMemHandle = (IMG_HANDLE)0;
+ }
+
+ if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
+ {
+ IMG_VOID *pvIORemapCookie;
+ pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags);
+ if(pvIORemapCookie == IMG_NULL)
+ {
+ return NULL;
+ }
+ return pvIORemapCookie;
+ }
+ else
+ {
PVR_DPF((PVR_DBG_ERROR,
"OSMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
" (Use OSReservePhys otherwise)"));
static PVRSRV_ERROR
RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr,
- IMG_VOID *pvCPUVAddr,
+ IMG_VOID *pvCPUVAddr,
IMG_UINT32 ui32Bytes,
- IMG_BOOL bPhysContig,
+ IMG_BOOL bPhysContig,
IMG_UINT32 ui32MappingFlags,
IMG_HANDLE *phOSMemHandle)
{
{
case PVRSRV_HAP_KERNEL_ONLY:
{
- psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
-
+ psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+
if(!psLinuxMemArea)
{
return PVRSRV_ERROR_GENERIC;
}
case PVRSRV_HAP_SINGLE_PROCESS:
{
- psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+ psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
if(!psLinuxMemArea)
{
ui32MappingFlags &= ~PVRSRV_HAP_CACHED;
#endif
- psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+ psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
if(!psLinuxMemArea)
{
PVRSRV_ERROR
OSRegisterMem(IMG_CPU_PHYADDR BasePAddr,
- IMG_VOID *pvCPUVAddr,
+ IMG_VOID *pvCPUVAddr,
IMG_UINT32 ui32Bytes,
IMG_UINT32 ui32MappingFlags,
IMG_HANDLE *phOSMemHandle)
{
- IMG_SYS_PHYADDR SysPAddr = SysCpuPAddrToSysPAddr(BasePAddr);
+ IMG_SYS_PHYADDR SysPAddr = SysCpuPAddrToSysPAddr(BasePAddr);
- return RegisterExternalMem(&SysPAddr, pvCPUVAddr, ui32Bytes, IMG_TRUE, ui32MappingFlags, phOSMemHandle);
+ return RegisterExternalMem(&SysPAddr, pvCPUVAddr, ui32Bytes, IMG_TRUE, ui32MappingFlags, phOSMemHandle);
}
PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE *phOSMemHandle)
{
- return RegisterExternalMem(pBasePAddr, pvCPUVAddr, ui32Bytes, IMG_FALSE, ui32MappingFlags, phOSMemHandle);
+ return RegisterExternalMem(pBasePAddr, pvCPUVAddr, ui32Bytes, IMG_FALSE, ui32MappingFlags, phOSMemHandle);
}
PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
{
- return OSUnRegisterMem(pvCpuVAddr, ui32Bytes, ui32Flags, hOSMemHandle);
+ return OSUnRegisterMem(pvCpuVAddr, ui32Bytes, ui32Flags, hOSMemHandle);
}
PVRSRV_ERROR
if(!psLinuxMemArea)
{
return PVRSRV_ERROR_GENERIC;
- }
+ }
break;
}
case PVRSRV_HAP_SINGLE_PROCESS:
- {
+ {
psLinuxMemArea = NewIOLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
if(!psLinuxMemArea)
{
return PVRSRV_ERROR_GENERIC;
- }
+ }
PVRMMapRegisterArea(psLinuxMemArea);
break;
}
*ppvCpuVAddr = NULL;
*phOSMemHandle = (IMG_HANDLE)0;
return PVRSRV_ERROR_GENERIC;
- }
+ }
*phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
*ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
#endif
if (!pvKernLinAddr)
{
- return PVRSRV_ERROR_OUT_OF_MEMORY;
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
}
*pvLinAddr = pvKernLinAddr;
IMG_UINT32 OSReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset)
{
#if !defined(NO_HARDWARE)
- return (IMG_UINT32) readl((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+ return (IMG_UINT32) readl((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
#else
- return *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+ return *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
#endif
}
IMG_VOID OSWriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value)
{
#if !defined(NO_HARDWARE)
- writel(ui32Value, (IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+ writel(ui32Value, (IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
#else
- *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset) = ui32Value;
+ *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset) = ui32Value;
#endif
}
PVRSRV_PCI_DEV_HANDLE OSPCISetDev(IMG_VOID *pvPCICookie, HOST_PCI_INIT_FLAGS eFlags)
{
- int err;
- IMG_UINT32 i;
- PVR_PCI_DEV *psPVRPCI;
+ int err;
+ IMG_UINT32 i;
+ PVR_PCI_DEV *psPVRPCI;
- PVR_TRACE(("OSPCISetDev"));
+ PVR_TRACE(("OSPCISetDev"));
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID *)&psPVRPCI, IMG_NULL) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't allocate PVR PCI structure"));
- return IMG_NULL;
- }
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID **)&psPVRPCI, IMG_NULL,
+ "PCI Device") != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't allocate PVR PCI structure"));
+ return IMG_NULL;
+ }
- psPVRPCI->psPCIDev = (struct pci_dev *)pvPCICookie;
- psPVRPCI->ePCIFlags = eFlags;
+ psPVRPCI->psPCIDev = (struct pci_dev *)pvPCICookie;
+ psPVRPCI->ePCIFlags = eFlags;
- err = pci_enable_device(psPVRPCI->psPCIDev);
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't enable device (%d)", err));
- return IMG_NULL;
- }
+ err = pci_enable_device(psPVRPCI->psPCIDev);
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't enable device (%d)", err));
+ return IMG_NULL;
+ }
- if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
- {
- pci_set_master(psPVRPCI->psPCIDev);
- }
+ if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
+ {
+ pci_set_master(psPVRPCI->psPCIDev);
+ }
- if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)
- {
+ if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)
+ {
#if defined(CONFIG_PCI_MSI)
- err = pci_enable_msi(psPVRPCI->psPCIDev);
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: Couldn't enable MSI (%d)", err));
- psPVRPCI->ePCIFlags &= ~HOST_PCI_INIT_FLAG_MSI;
- }
+ err = pci_enable_msi(psPVRPCI->psPCIDev);
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: Couldn't enable MSI (%d)", err));
+ psPVRPCI->ePCIFlags &= ~HOST_PCI_INIT_FLAG_MSI;
+ }
#else
- PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: MSI support not enabled in the kernel"));
+ PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: MSI support not enabled in the kernel"));
#endif
- }
+ }
-
- for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
- {
- psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
- }
+
+ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+ {
+ psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
+ }
- return (PVRSRV_PCI_DEV_HANDLE)psPVRPCI;
+ return (PVRSRV_PCI_DEV_HANDLE)psPVRPCI;
}
PVRSRV_PCI_DEV_HANDLE OSPCIAcquireDev(IMG_UINT16 ui16VendorID, IMG_UINT16 ui16DeviceID, HOST_PCI_INIT_FLAGS eFlags)
{
- struct pci_dev *psPCIDev;
+ struct pci_dev *psPCIDev;
- psPCIDev = pci_get_device(ui16VendorID, ui16DeviceID, NULL);
- if (psPCIDev == NULL)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIAcquireDev: Couldn't acquire device"));
- return IMG_NULL;
- }
+ psPCIDev = pci_get_device(ui16VendorID, ui16DeviceID, NULL);
+ if (psPCIDev == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIAcquireDev: Couldn't acquire device"));
+ return IMG_NULL;
+ }
- return OSPCISetDev((IMG_VOID *)psPCIDev, eFlags);
+ return OSPCISetDev((IMG_VOID *)psPCIDev, eFlags);
}
PVRSRV_ERROR OSPCIIRQ(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 *pui32IRQ)
{
- PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+ PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
- *pui32IRQ = psPVRPCI->psPCIDev->irq;
+ *pui32IRQ = psPVRPCI->psPCIDev->irq;
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
enum HOST_PCI_ADDR_RANGE_FUNC
{
- HOST_PCI_ADDR_RANGE_FUNC_LEN,
- HOST_PCI_ADDR_RANGE_FUNC_START,
- HOST_PCI_ADDR_RANGE_FUNC_END,
- HOST_PCI_ADDR_RANGE_FUNC_REQUEST,
- HOST_PCI_ADDR_RANGE_FUNC_RELEASE
+ HOST_PCI_ADDR_RANGE_FUNC_LEN,
+ HOST_PCI_ADDR_RANGE_FUNC_START,
+ HOST_PCI_ADDR_RANGE_FUNC_END,
+ HOST_PCI_ADDR_RANGE_FUNC_REQUEST,
+ HOST_PCI_ADDR_RANGE_FUNC_RELEASE
};
static IMG_UINT32 OSPCIAddrRangeFunc(enum HOST_PCI_ADDR_RANGE_FUNC eFunc,
- PVRSRV_PCI_DEV_HANDLE hPVRPCI,
- IMG_UINT32 ui32Index)
+ PVRSRV_PCI_DEV_HANDLE hPVRPCI,
+ IMG_UINT32 ui32Index)
{
- PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+ PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
- if (ui32Index >= DEVICE_COUNT_RESOURCE)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Index out of range"));
- return 0;
+ if (ui32Index >= DEVICE_COUNT_RESOURCE)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Index out of range"));
+ return 0;
- }
+ }
- switch (eFunc)
- {
- case HOST_PCI_ADDR_RANGE_FUNC_LEN:
- return pci_resource_len(psPVRPCI->psPCIDev, ui32Index);
- case HOST_PCI_ADDR_RANGE_FUNC_START:
- return pci_resource_start(psPVRPCI->psPCIDev, ui32Index);
- case HOST_PCI_ADDR_RANGE_FUNC_END:
- return pci_resource_end(psPVRPCI->psPCIDev, ui32Index);
- case HOST_PCI_ADDR_RANGE_FUNC_REQUEST:
- {
- int err;
-
- err = pci_request_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index, "PowerVR");
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: pci_request_region_failed (%d)", err));
- return 0;
- }
- psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_TRUE;
- return 1;
- }
- case HOST_PCI_ADDR_RANGE_FUNC_RELEASE:
- if (psPVRPCI->abPCIResourceInUse[ui32Index])
- {
- pci_release_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index);
- psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_FALSE;
- }
- return 1;
- default:
- PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Unknown function"));
- break;
- }
+ switch (eFunc)
+ {
+ case HOST_PCI_ADDR_RANGE_FUNC_LEN:
+ return pci_resource_len(psPVRPCI->psPCIDev, ui32Index);
+ case HOST_PCI_ADDR_RANGE_FUNC_START:
+ return pci_resource_start(psPVRPCI->psPCIDev, ui32Index);
+ case HOST_PCI_ADDR_RANGE_FUNC_END:
+ return pci_resource_end(psPVRPCI->psPCIDev, ui32Index);
+ case HOST_PCI_ADDR_RANGE_FUNC_REQUEST:
+ {
+ int err;
+
+ err = pci_request_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index, "PowerVR");
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: pci_request_region_failed (%d)", err));
+ return 0;
+ }
+ psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_TRUE;
+ return 1;
+ }
+ case HOST_PCI_ADDR_RANGE_FUNC_RELEASE:
+ if (psPVRPCI->abPCIResourceInUse[ui32Index])
+ {
+ pci_release_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index);
+ psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_FALSE;
+ }
+ return 1;
+ default:
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Unknown function"));
+ break;
+ }
- return 0;
+ return 0;
}
IMG_UINT32 OSPCIAddrRangeLen(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_LEN, hPVRPCI, ui32Index);
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_LEN, hPVRPCI, ui32Index);
}
IMG_UINT32 OSPCIAddrRangeStart(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_START, hPVRPCI, ui32Index);
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_START, hPVRPCI, ui32Index);
}
IMG_UINT32 OSPCIAddrRangeEnd(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_END, hPVRPCI, ui32Index);
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_END, hPVRPCI, ui32Index);
}
PVRSRV_ERROR OSPCIRequestAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI,
- IMG_UINT32 ui32Index)
+ IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_REQUEST, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_REQUEST, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
}
PVRSRV_ERROR OSPCIReleaseAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_RELEASE, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_RELEASE, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
}
PVRSRV_ERROR OSPCIReleaseDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
{
- PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
- int i;
+ PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+ int i;
- PVR_TRACE(("OSPCIReleaseDev"));
+ PVR_TRACE(("OSPCIReleaseDev"));
-
- for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
- {
- if (psPVRPCI->abPCIResourceInUse[i])
- {
- PVR_TRACE(("OSPCIReleaseDev: Releasing Address range %d", i));
- pci_release_region(psPVRPCI->psPCIDev, i);
- psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
- }
- }
+
+ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+ {
+ if (psPVRPCI->abPCIResourceInUse[i])
+ {
+ PVR_TRACE(("OSPCIReleaseDev: Releasing Address range %d", i));
+ pci_release_region(psPVRPCI->psPCIDev, i);
+ psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
+ }
+ }
#if defined(CONFIG_PCI_MSI)
- if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)
- {
- pci_disable_msi(psPVRPCI->psPCIDev);
- }
+ if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)
+ {
+ pci_disable_msi(psPVRPCI->psPCIDev);
+ }
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
- if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
- {
- pci_clear_master(psPVRPCI->psPCIDev);
- }
+ if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
+ {
+ pci_clear_master(psPVRPCI->psPCIDev);
+ }
#endif
- pci_disable_device(psPVRPCI->psPCIDev);
+ pci_disable_device(psPVRPCI->psPCIDev);
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID *)psPVRPCI, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID *)psPVRPCI, IMG_NULL);
+
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSPCISuspendDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
{
- PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
- int i;
- int err;
+ PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+ int i;
+ int err;
- PVR_TRACE(("OSPCISuspendDev"));
+ PVR_TRACE(("OSPCISuspendDev"));
-
- for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
- {
- if (psPVRPCI->abPCIResourceInUse[i])
- {
- pci_release_region(psPVRPCI->psPCIDev, i);
- }
- }
+
+ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+ {
+ if (psPVRPCI->abPCIResourceInUse[i])
+ {
+ pci_release_region(psPVRPCI->psPCIDev, i);
+ }
+ }
- err = pci_save_state(psPVRPCI->psPCIDev);
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_save_state_failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
- }
+ err = pci_save_state(psPVRPCI->psPCIDev);
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_save_state_failed (%d)", err));
+ return PVRSRV_ERROR_GENERIC;
+ }
- pci_disable_device(psPVRPCI->psPCIDev);
+ pci_disable_device(psPVRPCI->psPCIDev);
- err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_SUSPEND));
- switch(err)
- {
- case 0:
- break;
- case -EIO:
- PVR_DPF((PVR_DBG_WARNING, "OSPCISuspendDev: device doesn't support PCI PM"));
- break;
- case -EINVAL:
- PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: can't enter requested power state"));
- break;
- default:
- PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_set_power_state failed (%d)", err));
- break;
- }
+ err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_SUSPEND));
+ switch(err)
+ {
+ case 0:
+ break;
+ case -EIO:
+ PVR_DPF((PVR_DBG_WARNING, "OSPCISuspendDev: device doesn't support PCI PM"));
+ break;
+ case -EINVAL:
+ PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: can't enter requested power state"));
+ break;
+ default:
+ PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_set_power_state failed (%d)", err));
+ break;
+ }
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSPCIResumeDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
{
- PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
- int err;
- int i;
+ PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+ int err;
+ int i;
- PVR_TRACE(("OSPCIResumeDev"));
+ PVR_TRACE(("OSPCIResumeDev"));
- err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_ON));
- switch(err)
- {
- case 0:
- break;
- case -EIO:
- PVR_DPF((PVR_DBG_WARNING, "OSPCIResumeDev: device doesn't support PCI PM"));
- break;
- case -EINVAL:
- PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: can't enter requested power state"));
- return PVRSRV_ERROR_GENERIC;
- default:
- PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_set_power_state failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
- }
+ err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_ON));
+ switch(err)
+ {
+ case 0:
+ break;
+ case -EIO:
+ PVR_DPF((PVR_DBG_WARNING, "OSPCIResumeDev: device doesn't support PCI PM"));
+ break;
+ case -EINVAL:
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: can't enter requested power state"));
+ return PVRSRV_ERROR_GENERIC;
+ default:
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_set_power_state failed (%d)", err));
+ return PVRSRV_ERROR_GENERIC;
+ }
- err = pci_restore_state(psPVRPCI->psPCIDev);
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_restore_state failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
- }
+ err = pci_restore_state(psPVRPCI->psPCIDev);
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_restore_state failed (%d)", err));
+ return PVRSRV_ERROR_GENERIC;
+ }
- err = pci_enable_device(psPVRPCI->psPCIDev);
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: Couldn't enable device (%d)", err));
- return PVRSRV_ERROR_GENERIC;
- }
+ err = pci_enable_device(psPVRPCI->psPCIDev);
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: Couldn't enable device (%d)", err));
+ return PVRSRV_ERROR_GENERIC;
+ }
- if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
- pci_set_master(psPVRPCI->psPCIDev);
+ if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
+ pci_set_master(psPVRPCI->psPCIDev);
-
- for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
- {
- if (psPVRPCI->abPCIResourceInUse[i])
- {
- err = pci_request_region(psPVRPCI->psPCIDev, i, "PowerVR");
- if (err != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_request_region_failed (region %d, error %d)", i, err));
- }
- }
+
+ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+ {
+ if (psPVRPCI->abPCIResourceInUse[i])
+ {
+ err = pci_request_region(psPVRPCI->psPCIDev, i, "PowerVR");
+ if (err != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_request_region_failed (region %d, error %d)", i, err));
+ }
+ }
- }
+ }
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
#endif
typedef struct TIMER_CALLBACK_DATA_TAG
{
- IMG_BOOL bInUse;
- PFN_TIMER_FUNC pfnTimerFunc;
- IMG_VOID *pvData;
- struct timer_list sTimer;
- IMG_UINT32 ui32Delay;
- IMG_BOOL bActive;
+ IMG_BOOL bInUse;
+ PFN_TIMER_FUNC pfnTimerFunc;
+ IMG_VOID *pvData;
+ struct timer_list sTimer;
+ IMG_UINT32 ui32Delay;
+ IMG_BOOL bActive;
+ struct work_struct work;
}TIMER_CALLBACK_DATA;
static TIMER_CALLBACK_DATA sTimers[OS_MAX_TIMERS];
-//static spinlock_t sTimerStructLock = SPIN_LOCK_UNLOCKED;
static DEFINE_SPINLOCK(sTimerStructLock);
+static void timer_worker(struct work_struct *work)
+{
+ TIMER_CALLBACK_DATA *psTimerCBData =
+ container_of(work, TIMER_CALLBACK_DATA, work);
+
+ if (psTimerCBData->bActive)
+ {
+ /* call timer callback */
+ psTimerCBData->pfnTimerFunc(psTimerCBData->pvData);
+
+ /* reset timer */
+ mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
+ }
+}
+
static IMG_VOID OSTimerCallbackWrapper(IMG_UINT32 ui32Data)
{
- TIMER_CALLBACK_DATA *psTimerCBData = (TIMER_CALLBACK_DATA*)ui32Data;
-
- if (!psTimerCBData->bActive)
- return;
+ TIMER_CALLBACK_DATA *psTimerCBData = (TIMER_CALLBACK_DATA*)ui32Data;
-
- psTimerCBData->pfnTimerFunc(psTimerCBData->pvData);
-
-
- mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
+ schedule_work(&psTimerCBData->work);
}
IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32 ui32MsTimeout)
{
- TIMER_CALLBACK_DATA *psTimerCBData;
- IMG_UINT32 ui32i;
- unsigned long ulLockFlags;
-
-
- if(!pfnTimerFunc)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: passed invalid callback"));
- return IMG_NULL;
- }
-
-
- spin_lock_irqsave(&sTimerStructLock, ulLockFlags);
- for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
- {
- psTimerCBData = &sTimers[ui32i];
- if (!psTimerCBData->bInUse)
- {
- psTimerCBData->bInUse = IMG_TRUE;
- break;
- }
- }
- spin_unlock_irqrestore(&sTimerStructLock, ulLockFlags);
+ TIMER_CALLBACK_DATA *psTimerCBData;
+ IMG_UINT32 ui32i;
+ unsigned long ulLockFlags;
- if (ui32i >= OS_MAX_TIMERS)
- {
- PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: all timers are in use"));
- return IMG_NULL;
- }
+
+ if(!pfnTimerFunc)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: passed invalid callback"));
+ return IMG_NULL;
+ }
+
+
+ spin_lock_irqsave(&sTimerStructLock, ulLockFlags);
+ for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
+ {
+ psTimerCBData = &sTimers[ui32i];
+ if (!psTimerCBData->bInUse)
+ {
+ psTimerCBData->bInUse = IMG_TRUE;
+ break;
+ }
+ }
+ spin_unlock_irqrestore(&sTimerStructLock, ulLockFlags);
- psTimerCBData->pfnTimerFunc = pfnTimerFunc;
- psTimerCBData->pvData = pvData;
- psTimerCBData->bActive = IMG_FALSE;
-
-
+ if (ui32i >= OS_MAX_TIMERS)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: all timers are in use"));
+ return IMG_NULL;
+ }
+ psTimerCBData->pfnTimerFunc = pfnTimerFunc;
+ psTimerCBData->pvData = pvData;
+ psTimerCBData->bActive = IMG_FALSE;
+
+
+ INIT_WORK(&psTimerCBData->work, timer_worker);
- psTimerCBData->ui32Delay = ((HZ * ui32MsTimeout) < 1000)
- ? 1
- : ((HZ * ui32MsTimeout) / 1000);
-
- init_timer(&psTimerCBData->sTimer);
-
-
- psTimerCBData->sTimer.function = OSTimerCallbackWrapper;
- psTimerCBData->sTimer.data = (IMG_UINT32)psTimerCBData;
- psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
-
- return (IMG_HANDLE)(ui32i + 1);
+ psTimerCBData->ui32Delay = ((HZ * ui32MsTimeout) < 1000)
+ ? 1
+ : ((HZ * ui32MsTimeout) / 1000);
+
+ init_timer(&psTimerCBData->sTimer);
+
+
+ psTimerCBData->sTimer.function = OSTimerCallbackWrapper;
+ psTimerCBData->sTimer.data = (IMG_UINT32)psTimerCBData;
+ psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
+
+ return (IMG_HANDLE)(ui32i + 1);
}
static inline TIMER_CALLBACK_DATA *GetTimerStructure(IMG_HANDLE hTimer)
{
- IMG_UINT32 ui32i = ((IMG_UINT32)hTimer) - 1;
+ IMG_UINT32 ui32i = ((IMG_UINT32)hTimer) - 1;
- PVR_ASSERT(ui32i < OS_MAX_TIMERS);
+ PVR_ASSERT(ui32i < OS_MAX_TIMERS);
- return &sTimers[ui32i];
+ return &sTimers[ui32i];
}
PVRSRV_ERROR OSRemoveTimer (IMG_HANDLE hTimer)
{
- TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+ TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
- PVR_ASSERT(psTimerCBData->bInUse);
- PVR_ASSERT(!psTimerCBData->bActive);
+ PVR_ASSERT(psTimerCBData->bInUse);
+ PVR_ASSERT(!psTimerCBData->bActive);
-
- psTimerCBData->bInUse = IMG_FALSE;
-
- return PVRSRV_OK;
+
+ psTimerCBData->bInUse = IMG_FALSE;
+
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSEnableTimer (IMG_HANDLE hTimer)
{
- TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+ TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+ int ret;
- PVR_ASSERT(psTimerCBData->bInUse);
- PVR_ASSERT(!psTimerCBData->bActive);
+ PVR_ASSERT(psTimerCBData->bInUse);
+ PVR_ASSERT(!psTimerCBData->bActive);
-
- psTimerCBData->bActive = IMG_TRUE;
+
+ psTimerCBData->bActive = IMG_TRUE;
-
- add_timer(&psTimerCBData->sTimer);
-
- return PVRSRV_OK;
+
+ psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
+
+ ret = mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
+
+ if(ret == 1)
+ PVR_DPF((PVR_DBG_WARNING, "OSEnableTimer: enabling active timer"));
+
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSDisableTimer (IMG_HANDLE hTimer)
{
- TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+ TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
- PVR_ASSERT(psTimerCBData->bInUse);
- PVR_ASSERT(psTimerCBData->bActive);
+ PVR_ASSERT(psTimerCBData->bInUse);
+ PVR_ASSERT(psTimerCBData->bActive);
-
- psTimerCBData->bActive = IMG_FALSE;
+
+ psTimerCBData->bActive = IMG_FALSE;
-
- del_timer_sync(&psTimerCBData->sTimer);
-
- return PVRSRV_OK;
+ cancel_work_sync(&psTimerCBData->work);
+
+ del_timer_sync(&psTimerCBData->sTimer);
+
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSEventObjectCreate(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT *psEventObject)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
-
- if(psEventObject)
- {
- if(pszName)
- {
-
- strncpy(psEventObject->szName, pszName, EVENTOBJNAME_MAXLENGTH);
- }
- else
- {
-
- static IMG_UINT16 ui16NameIndex = 0;
- snprintf(psEventObject->szName, EVENTOBJNAME_MAXLENGTH, "PVRSRV_EVENTOBJECT_%d", ui16NameIndex++);
- }
-
- if(LinuxEventObjectListCreate(&psEventObject->hOSEventKM) != PVRSRV_OK)
- {
- eError = PVRSRV_ERROR_OUT_OF_MEMORY;
- }
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if(psEventObject)
+ {
+ if(pszName)
+ {
+
+ strncpy(psEventObject->szName, pszName, EVENTOBJNAME_MAXLENGTH);
+ }
+ else
+ {
+
+ static IMG_UINT16 ui16NameIndex = 0;
+ snprintf(psEventObject->szName, EVENTOBJNAME_MAXLENGTH, "PVRSRV_EVENTOBJECT_%d", ui16NameIndex++);
+ }
+
+ if(LinuxEventObjectListCreate(&psEventObject->hOSEventKM) != PVRSRV_OK)
+ {
+ eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
- }
- else
- {
+ }
+ else
+ {
PVR_DPF((PVR_DBG_ERROR, "OSEventObjectCreate: psEventObject is not a valid pointer"));
- eError = PVRSRV_ERROR_GENERIC;
- }
-
- return eError;
+ eError = PVRSRV_ERROR_GENERIC;
+ }
+
+ return eError;
}
PVRSRV_ERROR OSEventObjectDestroy(PVRSRV_EVENTOBJECT *psEventObject)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ PVRSRV_ERROR eError = PVRSRV_OK;
- if(psEventObject)
- {
- if(psEventObject->hOSEventKM)
- {
- LinuxEventObjectListDestroy(psEventObject->hOSEventKM);
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: hOSEventKM is not a valid pointer"));
- eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
- }
- else
- {
+ if(psEventObject)
+ {
+ if(psEventObject->hOSEventKM)
+ {
+ LinuxEventObjectListDestroy(psEventObject->hOSEventKM);
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: hOSEventKM is not a valid pointer"));
+ eError = PVRSRV_ERROR_INVALID_PARAMS;
+ }
+ }
+ else
+ {
PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: psEventObject is not a valid pointer"));
eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
-
- return eError;
+ }
+
+ return eError;
}
PVRSRV_ERROR OSEventObjectWait(IMG_HANDLE hOSEventKM)
{
- PVRSRV_ERROR eError;
-
- if(hOSEventKM)
- {
- eError = LinuxEventObjectWait(hOSEventKM, EVENT_OBJECT_TIMEOUT_MS);
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR, "OSEventObjectWait: hOSEventKM is not a valid handle"));
- eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
-
- return eError;
+ PVRSRV_ERROR eError;
+
+ if(hOSEventKM)
+ {
+ eError = LinuxEventObjectWait(hOSEventKM, EVENT_OBJECT_TIMEOUT_MS);
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSEventObjectWait: hOSEventKM is not a valid handle"));
+ eError = PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ return eError;
}
PVRSRV_ERROR OSEventObjectOpen(PVRSRV_EVENTOBJECT *psEventObject,
- IMG_HANDLE *phOSEvent)
+ IMG_HANDLE *phOSEvent)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
-
- if(psEventObject)
- {
- if(LinuxEventObjectAdd(psEventObject->hOSEventKM, phOSEvent) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: failed"));
- eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if(psEventObject)
+ {
+ if(LinuxEventObjectAdd(psEventObject->hOSEventKM, phOSEvent) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: failed"));
+ eError = PVRSRV_ERROR_INVALID_PARAMS;
+ }
- }
- else
- {
+ }
+ else
+ {
PVR_DPF((PVR_DBG_ERROR, "OSEventObjectCreate: psEventObject is not a valid pointer"));
eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
-
- return eError;
+ }
+
+ return eError;
}
PVRSRV_ERROR OSEventObjectClose(PVRSRV_EVENTOBJECT *psEventObject,
- IMG_HANDLE hOSEventKM)
+ IMG_HANDLE hOSEventKM)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ PVRSRV_ERROR eError = PVRSRV_OK;
- if(psEventObject)
- {
- if(LinuxEventObjectDelete(psEventObject->hOSEventKM, hOSEventKM) != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectDelete: failed"));
- eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
+ if(psEventObject)
+ {
+ if(LinuxEventObjectDelete(psEventObject->hOSEventKM, hOSEventKM) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectDelete: failed"));
+ eError = PVRSRV_ERROR_INVALID_PARAMS;
+ }
- }
- else
- {
+ }
+ else
+ {
PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: psEventObject is not a valid pointer"));
eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
-
- return eError;
-
+ }
+
+ return eError;
+
}
PVRSRV_ERROR OSEventObjectSignal(IMG_HANDLE hOSEventKM)
{
- PVRSRV_ERROR eError;
-
- if(hOSEventKM)
- {
- eError = LinuxEventObjectSignal(hOSEventKM);
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR, "OSEventObjectSignal: hOSEventKM is not a valid handle"));
- eError = PVRSRV_ERROR_INVALID_PARAMS;
- }
-
- return eError;
+ PVRSRV_ERROR eError;
+
+ if(hOSEventKM)
+ {
+ eError = LinuxEventObjectSignal(hOSEventKM);
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "OSEventObjectSignal: hOSEventKM is not a valid handle"));
+ eError = PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ return eError;
}
IMG_BOOL OSProcHasPrivSrvInit(IMG_VOID)
{
- return (capable(CAP_SYS_MODULE) != 0) ? IMG_TRUE : IMG_FALSE;
+ return (capable(CAP_SYS_MODULE) != 0) ? IMG_TRUE : IMG_FALSE;
}
PVRSRV_ERROR OSCopyToUser(IMG_PVOID pvProcess,
IMG_VOID *pvSrc,
IMG_UINT32 ui32Bytes)
{
- PVR_UNREFERENCED_PARAMETER(pvProcess);
+ PVR_UNREFERENCED_PARAMETER(pvProcess);
- if(copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
- return PVRSRV_OK;
- else
- return PVRSRV_ERROR_GENERIC;
+ if(copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
+ return PVRSRV_OK;
+ else
+ return PVRSRV_ERROR_GENERIC;
}
PVRSRV_ERROR OSCopyFromUser( IMG_PVOID pvProcess,
IMG_VOID *pvSrc,
IMG_UINT32 ui32Bytes)
{
- PVR_UNREFERENCED_PARAMETER(pvProcess);
+ PVR_UNREFERENCED_PARAMETER(pvProcess);
- if(copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
- return PVRSRV_OK;
- else
- return PVRSRV_ERROR_GENERIC;
+ if(copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
+ return PVRSRV_OK;
+ else
+ return PVRSRV_ERROR_GENERIC;
}
IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_UINT32 ui32Bytes)
{
- IMG_INT linuxType;
+ IMG_INT linuxType;
- if (eVerification == PVR_VERIFY_READ)
- {
- linuxType = VERIFY_READ;
- }
- else
- {
- PVR_ASSERT(eVerification == PVR_VERIFY_WRITE);
- linuxType = VERIFY_WRITE;
- }
+ if (eVerification == PVR_VERIFY_READ)
+ {
+ linuxType = VERIFY_READ;
+ }
+ else
+ {
+ PVR_ASSERT(eVerification == PVR_VERIFY_WRITE);
+ linuxType = VERIFY_WRITE;
+ }
- return access_ok(linuxType, pvUserPtr, ui32Bytes);
+ return access_ok(linuxType, pvUserPtr, ui32Bytes);
}
typedef enum _eWrapMemType_
{
- WRAP_TYPE_CLEANUP,
- WRAP_TYPE_GET_USER_PAGES,
- WRAP_TYPE_FIND_VMA_PAGES,
- WRAP_TYPE_FIND_VMA_PFN
+ WRAP_TYPE_CLEANUP,
+ WRAP_TYPE_GET_USER_PAGES,
+ WRAP_TYPE_FIND_VMA_PAGES,
+ WRAP_TYPE_FIND_VMA_PFN
} eWrapMemType;
typedef struct _sWrapMemInfo_
{
- eWrapMemType eType;
- IMG_INT iNumPages;
- struct page **ppsPages;
- IMG_SYS_PHYADDR *psPhysAddr;
- IMG_INT iPageOffset;
- IMG_INT iContiguous;
-#if defined(DEBUG)
- IMG_UINT32 ulStartAddr;
- IMG_UINT32 ulBeyondEndAddr;
- struct vm_area_struct *psVMArea;
+ eWrapMemType eType;
+ IMG_INT iNumPages;
+ struct page **ppsPages;
+ IMG_SYS_PHYADDR *psPhysAddr;
+ IMG_INT iPageOffset;
+ IMG_INT iContiguous;
+#if defined(DEBUG_PVR)
+ IMG_UINT32 ulStartAddr;
+ IMG_UINT32 ulBeyondEndAddr;
+ struct vm_area_struct *psVMArea;
#endif
} sWrapMemInfo;
static IMG_VOID CheckPagesContiguous(sWrapMemInfo *psInfo)
{
- IMG_INT i;
- IMG_UINT32 ui32AddrChk;
+ IMG_INT i;
+ IMG_UINT32 ui32AddrChk;
- BUG_ON(psInfo == IMG_NULL);
+ BUG_ON(psInfo == IMG_NULL);
- psInfo->iContiguous = 1;
+ psInfo->iContiguous = 1;
- for (i = 0, ui32AddrChk = psInfo->psPhysAddr[0].uiAddr;
- i < psInfo->iNumPages;
- i++, ui32AddrChk += PAGE_SIZE)
- {
- if (psInfo->psPhysAddr[i].uiAddr != ui32AddrChk)
- {
- psInfo->iContiguous = 0;
- break;
- }
- }
+ for (i = 0, ui32AddrChk = psInfo->psPhysAddr[0].uiAddr;
+ i < psInfo->iNumPages;
+ i++, ui32AddrChk += PAGE_SIZE)
+ {
+ if (psInfo->psPhysAddr[i].uiAddr != ui32AddrChk)
+ {
+ psInfo->iContiguous = 0;
+ break;
+ }
+ }
}
static struct page *CPUVAddrToPage(struct vm_area_struct *psVMArea, IMG_UINT32 ulCPUVAddr)
{
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10))
- pgd_t *psPGD;
- pud_t *psPUD;
- pmd_t *psPMD;
- pte_t *psPTE;
- struct mm_struct *psMM = psVMArea->vm_mm;
- IMG_UINT32 ulPFN;
- spinlock_t *psPTLock;
- struct page *psPage;
-
- psPGD = pgd_offset(psMM, ulCPUVAddr);
- if (pgd_none(*psPGD) || pgd_bad(*psPGD))
- return NULL;
+ pgd_t *psPGD;
+ pud_t *psPUD;
+ pmd_t *psPMD;
+ pte_t *psPTE;
+ struct mm_struct *psMM = psVMArea->vm_mm;
+ IMG_UINT32 ulPFN;
+ spinlock_t *psPTLock;
+ struct page *psPage;
+
+ psPGD = pgd_offset(psMM, ulCPUVAddr);
+ if (pgd_none(*psPGD) || pgd_bad(*psPGD))
+ return NULL;
- psPUD = pud_offset(psPGD, ulCPUVAddr);
- if (pud_none(*psPUD) || pud_bad(*psPUD))
- return NULL;
+ psPUD = pud_offset(psPGD, ulCPUVAddr);
+ if (pud_none(*psPUD) || pud_bad(*psPUD))
+ return NULL;
- psPMD = pmd_offset(psPUD, ulCPUVAddr);
- if (pmd_none(*psPMD) || pmd_bad(*psPMD))
- return NULL;
+ psPMD = pmd_offset(psPUD, ulCPUVAddr);
+ if (pmd_none(*psPMD) || pmd_bad(*psPMD))
+ return NULL;
- psPage = NULL;
+ psPage = NULL;
- psPTE = (pte_t *)pte_offset_map_lock(psMM, psPMD, ulCPUVAddr, &psPTLock);
- if ((pte_none(*psPTE) != 0) || (pte_present(*psPTE) == 0) || (pte_write(*psPTE) == 0))
- goto exit_unlock;
+ psPTE = (pte_t *)pte_offset_map_lock(psMM, psPMD, ulCPUVAddr, &psPTLock);
+ if ((pte_none(*psPTE) != 0) || (pte_present(*psPTE) == 0) || (pte_write(*psPTE) == 0))
+ goto exit_unlock;
- ulPFN = pte_pfn(*psPTE);
- if (!pfn_valid(ulPFN))
- goto exit_unlock;
+ ulPFN = pte_pfn(*psPTE);
+ if (!pfn_valid(ulPFN))
+ goto exit_unlock;
- psPage = pfn_to_page(ulPFN);
+ psPage = pfn_to_page(ulPFN);
- get_page(psPage);
+ get_page(psPage);
exit_unlock:
- pte_unmap_unlock(psPTE, psPTLock);
+ pte_unmap_unlock(psPTE, psPTLock);
- return psPage;
+ return psPage;
#else
- return NULL;
+ return NULL;
#endif
}
PVRSRV_ERROR OSReleasePhysPageAddr(IMG_HANDLE hOSWrapMem)
{
- sWrapMemInfo *psInfo = (sWrapMemInfo *)hOSWrapMem;
- IMG_INT i;
+ sWrapMemInfo *psInfo = (sWrapMemInfo *)hOSWrapMem;
+ IMG_INT i;
- BUG_ON(psInfo == IMG_NULL);
+ BUG_ON(psInfo == IMG_NULL);
- switch (psInfo->eType)
- {
- case WRAP_TYPE_CLEANUP:
- break;
- case WRAP_TYPE_FIND_VMA_PFN:
- break;
- case WRAP_TYPE_GET_USER_PAGES:
- {
- for (i = 0; i < psInfo->iNumPages; i++)
- {
- struct page *psPage = psInfo->ppsPages[i];
-
-
- if (!PageReserved(psPage));
- {
- SetPageDirty(psPage);
- }
- page_cache_release(psPage);
- }
- break;
- }
- case WRAP_TYPE_FIND_VMA_PAGES:
- {
- for (i = 0; i < psInfo->iNumPages; i++)
- {
- put_page_testzero(psInfo->ppsPages[i]);
- }
- break;
- }
- default:
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSReleasePhysPageAddr: Unknown wrap type (%d)", psInfo->eType));
- return PVRSRV_ERROR_GENERIC;
- }
- }
+ switch (psInfo->eType)
+ {
+ case WRAP_TYPE_CLEANUP:
+ break;
+ case WRAP_TYPE_FIND_VMA_PFN:
+ break;
+ case WRAP_TYPE_GET_USER_PAGES:
+ {
+ for (i = 0; i < psInfo->iNumPages; i++)
+ {
+ struct page *psPage = psInfo->ppsPages[i];
+
+
+ if (!PageReserved(psPage));
+ {
+ SetPageDirty(psPage);
+ }
+ page_cache_release(psPage);
+ }
+ break;
+ }
+ case WRAP_TYPE_FIND_VMA_PAGES:
+ {
+ for (i = 0; i < psInfo->iNumPages; i++)
+ {
+ put_page_testzero(psInfo->ppsPages[i]);
+ }
+ break;
+ }
+ default:
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSReleasePhysPageAddr: Unknown wrap type (%d)", psInfo->eType));
+ return PVRSRV_ERROR_GENERIC;
+ }
+ }
- if (psInfo->ppsPages != IMG_NULL)
- {
- kfree(psInfo->ppsPages);
- }
+ if (psInfo->ppsPages != IMG_NULL)
+ {
+ kfree(psInfo->ppsPages);
+ }
- if (psInfo->psPhysAddr != IMG_NULL)
- {
- kfree(psInfo->psPhysAddr);
- }
+ if (psInfo->psPhysAddr != IMG_NULL)
+ {
+ kfree(psInfo->psPhysAddr);
+ }
- kfree(psInfo);
+ kfree(psInfo);
- return PVRSRV_OK;
+ return PVRSRV_OK;
}
PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID* pvCPUVAddr,
- IMG_UINT32 ui32Bytes,
- IMG_SYS_PHYADDR *psSysPAddr,
- IMG_HANDLE *phOSWrapMem)
-{
- IMG_UINT32 ulStartAddrOrig = (IMG_UINT32) pvCPUVAddr;
- IMG_UINT32 ulAddrRangeOrig = (IMG_UINT32) ui32Bytes;
- IMG_UINT32 ulBeyondEndAddrOrig = ulStartAddrOrig + ulAddrRangeOrig;
- IMG_UINT32 ulStartAddr;
- IMG_UINT32 ulAddrRange;
- IMG_UINT32 ulBeyondEndAddr;
- IMG_UINT32 ulAddr;
- IMG_INT iNumPagesMapped;
- IMG_INT i;
- struct vm_area_struct *psVMArea;
- sWrapMemInfo *psInfo;
+ IMG_UINT32 ui32Bytes,
+ IMG_SYS_PHYADDR *psSysPAddr,
+ IMG_HANDLE *phOSWrapMem)
+{
+ IMG_UINT32 ulStartAddrOrig = (IMG_UINT32) pvCPUVAddr;
+ IMG_UINT32 ulAddrRangeOrig = (IMG_UINT32) ui32Bytes;
+ IMG_UINT32 ulBeyondEndAddrOrig = ulStartAddrOrig + ulAddrRangeOrig;
+ IMG_UINT32 ulStartAddr;
+ IMG_UINT32 ulAddrRange;
+ IMG_UINT32 ulBeyondEndAddr;
+ IMG_UINT32 ulAddr;
+ IMG_INT iNumPagesMapped;
+ IMG_INT i;
+ struct vm_area_struct *psVMArea;
+ sWrapMemInfo *psInfo;
-
- ulStartAddr = ulStartAddrOrig & PAGE_MASK;
- ulBeyondEndAddr = PAGE_ALIGN(ulBeyondEndAddrOrig);
- ulAddrRange = ulBeyondEndAddr - ulStartAddr;
+
+ ulStartAddr = ulStartAddrOrig & PAGE_MASK;
+ ulBeyondEndAddr = PAGE_ALIGN(ulBeyondEndAddrOrig);
+ ulAddrRange = ulBeyondEndAddr - ulStartAddr;
-
- psInfo = kmalloc(sizeof(*psInfo), GFP_KERNEL);
- if (psInfo == NULL)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Couldn't allocate information structure"));
- return PVRSRV_ERROR_OUT_OF_MEMORY;
- }
- memset(psInfo, 0, sizeof(*psInfo));
+
+ psInfo = kmalloc(sizeof(*psInfo), GFP_KERNEL);
+ if (psInfo == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Couldn't allocate information structure"));
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
+ memset(psInfo, 0, sizeof(*psInfo));
-#if defined(DEBUG)
- psInfo->ulStartAddr = ulStartAddrOrig;
- psInfo->ulBeyondEndAddr = ulBeyondEndAddrOrig;
+#if defined(DEBUG_PVR)
+ psInfo->ulStartAddr = ulStartAddrOrig;
+ psInfo->ulBeyondEndAddr = ulBeyondEndAddrOrig;
#endif
- psInfo->iNumPages = (IMG_INT)(ulAddrRange >> PAGE_SHIFT);
- psInfo->iPageOffset = (IMG_INT)(ulStartAddrOrig & ~PAGE_MASK);
+ psInfo->iNumPages = (IMG_INT)(ulAddrRange >> PAGE_SHIFT);
+ psInfo->iPageOffset = (IMG_INT)(ulStartAddrOrig & ~PAGE_MASK);
-
- psInfo->psPhysAddr = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->psPhysAddr), GFP_KERNEL);
- if (psInfo->psPhysAddr == NULL)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Couldn't allocate page array"));
- goto error_free;
- }
+
+ psInfo->psPhysAddr = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->psPhysAddr), GFP_KERNEL);
+ if (psInfo->psPhysAddr == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Couldn't allocate page array"));
+ goto error_free;
+ }
-
- psInfo->ppsPages = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->ppsPages), GFP_KERNEL);
- if (psInfo->ppsPages == NULL)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Couldn't allocate page array"));
- goto error_free;
- }
+
+ psInfo->ppsPages = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->ppsPages), GFP_KERNEL);
+ if (psInfo->ppsPages == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Couldn't allocate page array"));
+ goto error_free;
+ }
-
- down_read(¤t->mm->mmap_sem);
- iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
- up_read(¤t->mm->mmap_sem);
+
+ down_read(¤t->mm->mmap_sem);
+ iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
+ up_read(¤t->mm->mmap_sem);
- if (iNumPagesMapped >= 0)
- {
-
- if (iNumPagesMapped != psInfo->iNumPages)
- {
- PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't map all the pages needed (wanted: %d, got %d)", psInfo->iNumPages, iNumPagesMapped));
-
-
- for (i = 0; i < iNumPagesMapped; i++)
- {
- page_cache_release(psInfo->ppsPages[i]);
-
- }
- goto error_free;
- }
+ if (iNumPagesMapped >= 0)
+ {
+
+ if (iNumPagesMapped != psInfo->iNumPages)
+ {
+ PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't map all the pages needed (wanted: %d, got %d)", psInfo->iNumPages, iNumPagesMapped));
-
- for (i = 0; i < psInfo->iNumPages; i++)
- {
- IMG_CPU_PHYADDR CPUPhysAddr;
+
+ for (i = 0; i < iNumPagesMapped; i++)
+ {
+ page_cache_release(psInfo->ppsPages[i]);
+
+ }
+ goto error_free;
+ }
- CPUPhysAddr.uiAddr = page_to_pfn(psInfo->ppsPages[i]) << PAGE_SHIFT;
- psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
- psSysPAddr[i] = psInfo->psPhysAddr[i];
-
- }
+
+ for (i = 0; i < psInfo->iNumPages; i++)
+ {
+ IMG_CPU_PHYADDR CPUPhysAddr;
- psInfo->eType = WRAP_TYPE_GET_USER_PAGES;
+ CPUPhysAddr.uiAddr = page_to_pfn(psInfo->ppsPages[i]) << PAGE_SHIFT;
+ psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+ psSysPAddr[i] = psInfo->psPhysAddr[i];
+
+ }
- goto exit_check;
- }
+ psInfo->eType = WRAP_TYPE_GET_USER_PAGES;
- PVR_TRACE(("OSAcquirePhysPageAddr: get_user_pages failed (%d), trying something else", iNumPagesMapped));
-
-
- down_read(¤t->mm->mmap_sem);
+ goto exit_check;
+ }
- psVMArea = find_vma(current->mm, ulStartAddrOrig);
- if (psVMArea == NULL)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Couldn't find memory region containing start address %lx", ulStartAddrOrig));
-
- goto error_release_mmap_sem;
- }
-#if defined(DEBUG)
- psInfo->psVMArea = psVMArea;
+ PVR_TRACE(("OSAcquirePhysPageAddr: get_user_pages failed (%d), trying something else", iNumPagesMapped));
+
+
+ down_read(¤t->mm->mmap_sem);
+
+ psVMArea = find_vma(current->mm, ulStartAddrOrig);
+ if (psVMArea == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Couldn't find memory region containing start address %lx", ulStartAddrOrig));
+
+ goto error_release_mmap_sem;
+ }
+#if defined(DEBUG_PVR)
+ psInfo->psVMArea = psVMArea;
#endif
-
- if (ulStartAddrOrig < psVMArea->vm_start)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Start address %lx is outside of the region returned by find_vma", ulStartAddrOrig));
- goto error_release_mmap_sem;
- }
+
+ if (ulStartAddrOrig < psVMArea->vm_start)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Start address %lx is outside of the region returned by find_vma", ulStartAddrOrig));
+ goto error_release_mmap_sem;
+ }
-
- if (ulBeyondEndAddrOrig > psVMArea->vm_end)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: End address %lx is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
- goto error_release_mmap_sem;
- }
+
+ if (ulBeyondEndAddrOrig > psVMArea->vm_end)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: End address %lx is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
+ goto error_release_mmap_sem;
+ }
-
- if ((psVMArea->vm_flags & (VM_IO | VM_RESERVED)) != (VM_IO | VM_RESERVED))
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Memory region does not represent memory mapped I/O (VMA flags: 0x%lx)", psVMArea->vm_flags));
- goto error_release_mmap_sem;
- }
+
+ if ((psVMArea->vm_flags & (VM_IO | VM_RESERVED)) != (VM_IO | VM_RESERVED))
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Memory region does not represent memory mapped I/O (VMA flags: 0x%lx)", psVMArea->vm_flags));
+ goto error_release_mmap_sem;
+ }
-
- if ((psVMArea->vm_flags & (VM_READ | VM_WRITE)) != (VM_READ | VM_WRITE))
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: No read/write access to memory region (VMA flags: 0x%lx)", psVMArea->vm_flags));
- goto error_release_mmap_sem;
- }
+
+ if ((psVMArea->vm_flags & (VM_READ | VM_WRITE)) != (VM_READ | VM_WRITE))
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: No read/write access to memory region (VMA flags: 0x%lx)", psVMArea->vm_flags));
+ goto error_release_mmap_sem;
+ }
-
- for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
- {
- struct page *psPage;
+
+ for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
+ {
+ struct page *psPage;
- BUG_ON(i >= psInfo->iNumPages);
+ BUG_ON(i >= psInfo->iNumPages);
- psPage = CPUVAddrToPage(psVMArea, ulAddr);
- if (psPage == NULL)
- {
- IMG_INT j;
+ psPage = CPUVAddrToPage(psVMArea, ulAddr);
+ if (psPage == NULL)
+ {
+ IMG_INT j;
- PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't lookup page structure for address 0x%lx, trying something else", ulAddr));
+ PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't lookup page structure for address 0x%lx, trying something else", ulAddr));
-
- for (j = 0; j < i; j++)
- {
- put_page_testzero(psInfo->ppsPages[j]);
- }
- break;
- }
+
+ for (j = 0; j < i; j++)
+ {
+ put_page_testzero(psInfo->ppsPages[j]);
+ }
+ break;
+ }
- psInfo->ppsPages[i] = psPage;
- }
+ psInfo->ppsPages[i] = psPage;
+ }
- BUG_ON(i > psInfo->iNumPages);
- if (i == psInfo->iNumPages)
- {
-
- for (i = 0; i < psInfo->iNumPages; i++)
- {
- struct page *psPage = psInfo->ppsPages[i];
- IMG_CPU_PHYADDR CPUPhysAddr;
+ BUG_ON(i > psInfo->iNumPages);
+ if (i == psInfo->iNumPages)
+ {
+
+ for (i = 0; i < psInfo->iNumPages; i++)
+ {
+ struct page *psPage = psInfo->ppsPages[i];
+ IMG_CPU_PHYADDR CPUPhysAddr;
-
- CPUPhysAddr.uiAddr = page_to_pfn(psPage) << PAGE_SHIFT;
+
+ CPUPhysAddr.uiAddr = page_to_pfn(psPage) << PAGE_SHIFT;
- psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
- psSysPAddr[i] = psInfo->psPhysAddr[i];
- }
+ psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+ psSysPAddr[i] = psInfo->psPhysAddr[i];
+ }
- psInfo->eType = WRAP_TYPE_FIND_VMA_PAGES;
- }
- else
- {
+ psInfo->eType = WRAP_TYPE_FIND_VMA_PAGES;
+ }
+ else
+ {
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10)) && defined(PVR_SECURE_HANDLES)
-
+
-
- if ((psVMArea->vm_flags & VM_PFNMAP) == 0)
- {
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Region isn't a raw PFN mapping. Giving up."));
- goto error_release_mmap_sem;
- }
-
- for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
- {
- IMG_CPU_PHYADDR CPUPhysAddr;
+
+ if ((psVMArea->vm_flags & VM_PFNMAP) == 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSAcquirePhysPageAddr: Region isn't a raw PFN mapping. Giving up."));
+ goto error_release_mmap_sem;
+ }
+
+ for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
+ {
+ IMG_CPU_PHYADDR CPUPhysAddr;
- CPUPhysAddr.uiAddr = ((ulAddr - psVMArea->vm_start) + (psVMArea->vm_pgoff << PAGE_SHIFT)) & PAGE_MASK;
+ CPUPhysAddr.uiAddr = ((ulAddr - psVMArea->vm_start) + (psVMArea->vm_pgoff << PAGE_SHIFT)) & PAGE_MASK;
- psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
- psSysPAddr[i] = psInfo->psPhysAddr[i];
- }
- BUG_ON(i != psInfo->iNumPages);
+ psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+ psSysPAddr[i] = psInfo->psPhysAddr[i];
+ }
+ BUG_ON(i != psInfo->iNumPages);
- psInfo->eType = WRAP_TYPE_FIND_VMA_PFN;
+ psInfo->eType = WRAP_TYPE_FIND_VMA_PFN;
-
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Region can't be locked down"));
+
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSAcquirePhysPageAddr: Region can't be locked down"));
#else
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Raw PFN mappings not supported. Giving up."));
- goto error_release_mmap_sem;
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSAcquirePhysPageAddr: Raw PFN mappings not supported. Giving up."));
+ goto error_release_mmap_sem;
#endif
- }
+ }
- up_read(¤t->mm->mmap_sem);
+ up_read(¤t->mm->mmap_sem);
exit_check:
- CheckPagesContiguous(psInfo);
+ CheckPagesContiguous(psInfo);
-
- *phOSWrapMem = (IMG_HANDLE)psInfo;
+
+ *phOSWrapMem = (IMG_HANDLE)psInfo;
- return PVRSRV_OK;
+ return PVRSRV_OK;
error_release_mmap_sem:
- up_read(¤t->mm->mmap_sem);
+ up_read(¤t->mm->mmap_sem);
error_free:
- psInfo->eType = WRAP_TYPE_CLEANUP;
- OSReleasePhysPageAddr((IMG_HANDLE)psInfo);
- return PVRSRV_ERROR_GENERIC;
+ psInfo->eType = WRAP_TYPE_CLEANUP;
+ OSReleasePhysPageAddr((IMG_HANDLE)psInfo);
+ return PVRSRV_ERROR_GENERIC;
+}
+
+
+
+#if defined(SUPPORT_CPU_CACHED_BUFFERS)
+
+#if defined(__i386__)
+static void per_cpu_cache_flush(void *arg)
+{
+ PVR_UNREFERENCED_PARAMETER(arg);
+ wbinvd();
+}
+#endif
+
+
+IMG_VOID OSFlushCPUCacheKM()
+{
+#if defined(__arm__)
+ flush_cache_all();
+#elif defined(__i386__)
+
+ on_each_cpu(per_cpu_cache_flush, NULL, 1);
+#else
+#error "Implement full CPU cache flush for this CPU!"
+#endif
+}
+
+
+IMG_VOID OSFlushCPUCacheRangeKM(IMG_VOID *pvRangeAddrStart,
+ IMG_VOID *pvRangeAddrEnd)
+{
+ PVR_UNREFERENCED_PARAMETER(pvRangeAddrStart);
+ PVR_UNREFERENCED_PARAMETER(pvRangeAddrEnd);
+
+
+
+#if defined(__arm__)
+ flush_cache_all();
+#elif defined(__i386__)
+
+ on_each_cpu(per_cpu_cache_flush, NULL, 1);
+#else
+#error "Implement full CPU cache flush for this CPU!"
+#endif
}
+
+#endif
+
#include "env_perproc.h"
#include "proc.h"
+extern IMG_UINT32 gui32ReleasePID;
+
PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData)
{
PVRSRV_ERROR eError;
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
phOsPrivateData,
- &hBlockAlloc);
+ &hBlockAlloc,
+ "Environment per Process Data");
if (eError != PVRSRV_OK)
{
sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
hOsPrivateData,
psEnvPerProc->hBlockAlloc);
+
+
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "%s: OSFreeMem failed (%d)", __FUNCTION__, eError));
return LinuxMMapPerProcessHandleOptions(psHandleBase);
}
+IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID)
+{
+ if(!gui32ReleasePID)
+ return NULL;
+ return PVRSRVPerProcessPrivateData(gui32ReleasePID);
+}
#if defined (SUPPORT_SGX)
#if defined (PDUMP)
+
#include <asm/atomic.h>
#include <stdarg.h>
#include "sgxdefs.h"
static IMG_UINT32 DbgWrite (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags);
#define PDUMP_DATAMASTER_PIXEL (1)
+#define PDUMP_DATAMASTER_EDM (3)
#define MIN(a,b) (a > b ? b : a)
static PDBGKM_SERVICE_TABLE gpfnDbgDrv = IMG_NULL;
-#define PDUMP_STREAM_PARAM2 0
-#define PDUMP_STREAM_SCRIPT2 1
-#define PDUMP_STREAM_DRIVERINFO 2
-#define PDUMP_NUM_STREAMS 3
-
IMG_CHAR *pszStreamName[PDUMP_NUM_STREAMS] = { "ParamStream2",
"ScriptStream2",
"DriverInfoStream"};
-
-#define __PDBG_PDUMP_STATE_GET_MSG_STRING(ERROR) \
- IMG_CHAR *pszMsg = gsDBGPdumpState.pszMsg; \
- if ((!pszMsg) || PDumpSuspended()) return ERROR
-
-#define __PDBG_PDUMP_STATE_GET_SCRIPT_STRING(ERROR) \
- IMG_CHAR *pszScript = gsDBGPdumpState.pszScript; \
- if ((!pszScript) || PDumpSuspended()) return ERROR
-
-#define __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(ERROR) \
- IMG_CHAR *pszScript = gsDBGPdumpState.pszScript; \
- IMG_CHAR *pszFile = gsDBGPdumpState.pszFile; \
- if ((!pszScript) || (!pszFile) || PDumpSuspended()) return ERROR
-
-typedef struct PDBG_PDUMP_STATE_TAG
+typedef struct PDBG_PDUMP_STATE_TAG
{
PDBG_STREAM psStream[PDUMP_NUM_STREAMS];
IMG_UINT32 ui32ParamFileNum;
return atomic_read(&gsPDumpSuspended) != 0;
}
+PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
+ IMG_UINT32 *pui32MaxLen)
+{
+ *phScript = (IMG_HANDLE)gsDBGPdumpState.pszScript;
+ *pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
+ if ((!*phScript) || PDumpSuspended())
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpOSGetMessageString(IMG_HANDLE *phMsg,
+ IMG_UINT32 *pui32MaxLen)
+{
+ *phMsg = (IMG_HANDLE)gsDBGPdumpState.pszMsg;
+ *pui32MaxLen = SZ_MSG_SIZE_MAX;
+ if ((!*phMsg) || PDumpSuspended())
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile,
+ IMG_UINT32 *pui32MaxLen)
+{
+ *ppszFile = gsDBGPdumpState.pszFile;
+ *pui32MaxLen = SZ_FILENAME_SIZE_MAX;
+ if ((!*ppszFile) || PDumpSuspended())
+ {
+ return PVRSRV_ERROR_GENERIC;
+ }
+ return PVRSRV_OK;
+}
+
+IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags)
+{
+ return PDumpWriteString2(hScript, ui32Flags);
+}
+
+PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
+{
+ IMG_CHAR* pszBuf = hBuf;
+ IMG_UINT32 n;
+ va_list vaArgs;
+
+ va_start(vaArgs, pszFormat);
+
+ n = vsnprintf(pszBuf, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+ va_end(vaArgs);
+
+ if (n>=ui32ScriptSizeMax || n==-1)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
+
+ return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
+ }
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs)
+{
+ IMG_UINT32 n;
+
+ n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+ if (n>=ui32ScriptSizeMax || n==-1)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
+
+ return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
+ }
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
+{
+
+}
+
+PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
+{
+ IMG_UINT32 n;
+ va_list vaArgs;
+
+ va_start(vaArgs, pszFormat);
+
+ n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+ va_end(vaArgs);
+
+ if (n>=ui32ScriptSizeMax || n==-1)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
+
+ return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
+ }
+
+ return PVRSRV_OK;
+}
+
+IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
+{
+ IMG_CHAR* pszBuf = hBuffer;
+ IMG_UINT32 ui32Count = 0;
+
+ while ((pszBuf[ui32Count]!=0) && (ui32Count<ui32BufferSizeMax) )
+ {
+ ui32Count++;
+ }
+ return(ui32Count);
+}
+
+IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
+{
+ IMG_UINT32 ui32Count = 0;
+ IMG_CHAR* pszBuf = hBuffer;
+
+
+ ui32Count = PDumpOSBuflen(hBuffer, ui32BufferSizeMax);
+
+
+ if ((ui32Count >= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count<ui32BufferSizeMax))
+ {
+ pszBuf[ui32Count] = '\n';
+ ui32Count++;
+ pszBuf[ui32Count] = '\0';
+ }
+ if ((ui32Count >= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32Count<ui32BufferSizeMax))
+ {
+ pszBuf[ui32Count-1] = '\r';
+ pszBuf[ui32Count] = '\n';
+ ui32Count++;
+ pszBuf[ui32Count] = '\0';
+ }
+}
+
+IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream)
+{
+ return (IMG_HANDLE)gsDBGPdumpState.psStream[ePDumpStream];
+}
+
+IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream)
+{
+ PDBG_STREAM psStream = gsDBGPdumpState.psStream[ePDumpStream];
+ return gpfnDbgDrv->pfnGetStreamOffset(psStream);
+}
+
+IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID)
+{
+ return gsDBGPdumpState.ui32ParamFileNum;
+}
+
+IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
+ IMG_UINT8 *psui8Data,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32Flags)
+{
+ PDBG_STREAM psStream = (PDBG_STREAM)hStream;
+ return PDumpWriteILock(psStream,
+ psui8Data,
+ ui32Size,
+ ui32Flags);
+}
+
+IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags)
+{
+
+ PVR_UNREFERENCED_PARAMETER(hStream);
+ PVR_UNREFERENCED_PARAMETER(ui32Size);
+ PVR_UNREFERENCED_PARAMETER(ui32Size);
+}
+
+IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
+{
+ if(gpfnDbgDrv)
+ {
+ return IMG_TRUE;
+ }
+ return IMG_FALSE;
+}
+
+inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
+{
+ return atomic_read(&gsPDumpSuspended) != 0;
+}
+
+IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_UINT8 *pui8LinAddr,
+ IMG_UINT32 ui32PageSize,
+ IMG_DEV_PHYADDR *psDevPAddr)
+{
+ if(hOSMemHandle)
+ {
+
+ IMG_CPU_PHYADDR sCpuPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+
+ sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
+ PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
+
+
+ *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
+ }
+ else
+ {
+ IMG_CPU_PHYADDR sCpuPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(ui32Offset);
+
+ sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
+ *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
+ }
+}
+
+IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_PUINT8 pui8LinAddr,
+ IMG_UINT32 *pui32PageOffset)
+{
+ if(hOSMemHandle)
+ {
+
+ IMG_CPU_PHYADDR sCpuPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+
+ sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
+ *pui32PageOffset = sCpuPAddr.uiAddr & (HOST_PAGESIZE() -1);
+ }
+ else
+ {
+ PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+ PVR_UNREFERENCED_PARAMETER(ui32Offset);
+
+ *pui32PageOffset = (IMG_UINT32)pui8LinAddr & (HOST_PAGESIZE() - 1);
+ }
+}
+
+
+
IMG_VOID PDumpInit(IMG_VOID)
-{
- IMG_UINT32 i=0;
+{
+ IMG_UINT32 i;
if (!gpfnDbgDrv)
{
DBGDrvGetServiceTable((IMG_VOID **)&gpfnDbgDrv);
-
+
if (gpfnDbgDrv == IMG_NULL)
- {
+ {
return;
}
-
+
if(!gsDBGPdumpState.pszFile)
{
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0) != PVRSRV_OK)
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0,
+ "Filename string") != PVRSRV_OK)
{
goto init_failed;
}
- }
-
+ }
+
if(!gsDBGPdumpState.pszMsg)
{
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0) != PVRSRV_OK)
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0,
+ "Message string") != PVRSRV_OK)
{
goto init_failed;
}
}
-
+
if(!gsDBGPdumpState.pszScript)
{
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0) != PVRSRV_OK)
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0,
+ "Script string") != PVRSRV_OK)
{
- goto init_failed;
+ goto init_failed;
}
}
-
+
for(i=0; i < PDUMP_NUM_STREAMS; i++)
{
- gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
- DEBUG_CAPMODE_FRAMED,
- DEBUG_OUTMODE_STREAMENABLE,
+ gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
+ DEBUG_CAPMODE_FRAMED,
+ DEBUG_OUTMODE_STREAMENABLE,
0,
10);
-
+
gpfnDbgDrv->pfnSetCaptureMode(gsDBGPdumpState.psStream[i],DEBUG_CAPMODE_FRAMED,0xFFFFFFFF, 0xFFFFFFFF, 1);
gpfnDbgDrv->pfnSetFrame(gsDBGPdumpState.psStream[i],0);
}
return;
-init_failed:
+init_failed:
if(gsDBGPdumpState.pszFile)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
gsDBGPdumpState.pszFile = IMG_NULL;
}
-
+
if(gsDBGPdumpState.pszScript)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
IMG_VOID PDumpDeInit(IMG_VOID)
-{
- IMG_UINT32 i=0;
+{
+ IMG_UINT32 i;
for(i=0; i < PDUMP_NUM_STREAMS; i++)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
gsDBGPdumpState.pszFile = IMG_NULL;
}
-
+
if(gsDBGPdumpState.pszScript)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID)
{
IMG_UINT32 i;
-
+
if (gpfnDbgDrv)
{
PDUMPCOMMENT("Start Init Phase");
return PVRSRV_OK;
}
-IMG_VOID PDumpComment(IMG_CHAR *pszFormat, ...)
-{
- va_list ap;
-
- __PDBG_PDUMP_STATE_GET_MSG_STRING();
-
-
- va_start(ap, pszFormat);
- vsnprintf(pszMsg, SZ_MSG_SIZE_MAX, pszFormat, ap);
- va_end(ap);
-
- PDumpCommentKM(pszMsg, PDUMP_FLAGS_CONTINUOUS);
-}
-
-IMG_VOID PDumpCommentWithFlags(IMG_UINT32 ui32Flags, IMG_CHAR * pszFormat, ...)
-{
- va_list ap;
-
- __PDBG_PDUMP_STATE_GET_MSG_STRING();
-
-
- va_start(ap, pszFormat);
- vsnprintf(pszMsg, SZ_MSG_SIZE_MAX, pszFormat, ap);
- va_end(ap);
-
- PDumpCommentKM(pszMsg, ui32Flags);
-}
-
IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID)
{
return gpfnDbgDrv->pfnIsLastCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
}
-PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_UINT32 ui32Reg, IMG_UINT32 ui32Data, IMG_UINT32 ui32Flags)
+PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING(PVRSRV_ERROR_GENERIC);
+ IMG_UINT32 ui32Stream;
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "WRW :SGXREG:0x%8.8lX 0x%8.8lX\r\n", ui32Reg, ui32Data);
- PDumpWriteString2(pszScript, ui32Flags);
+ for (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
+ {
+ if (gsDBGPdumpState.psStream[ui32Stream])
+ {
+ DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
+ }
+ }
return PVRSRV_OK;
}
-IMG_VOID PDumpReg(IMG_UINT32 ui32Reg,IMG_UINT32 ui32Data)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "WRW :SGXREG:0x%8.8lX 0x%8.8lX\r\n", ui32Reg, ui32Data);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
-}
-
-PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask, IMG_UINT32 ui32Flags)
+PVRSRV_ERROR PDumpGetFrameKM(IMG_PUINT32 pui32Frame)
{
- #define POLL_DELAY 1000
- #define POLL_COUNT_LONG (2000000000 / POLL_DELAY)
- #define POLL_COUNT_SHORT (1000000 / POLL_DELAY)
-
- IMG_UINT32 ui32PollCount;
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING(PVRSRV_ERROR_GENERIC);
-
- if (((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
- (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_TA_FINISHED_MASK)) ||
- ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
- (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK)) ||
- ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
- (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK)))
- {
- ui32PollCount = POLL_COUNT_LONG;
- }
- else
- {
- ui32PollCount = POLL_COUNT_SHORT;
- }
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "POL :SGXREG:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %lu %d\r\n", ui32RegAddr, ui32RegValue, ui32Mask, 0, ui32PollCount, POLL_DELAY);
- PDumpWriteString2(pszScript, ui32Flags);
+ *pui32Frame = DbgGetFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask)
-{
- return PDumpRegPolWithFlagsKM(ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS);
-}
-IMG_VOID PDumpMallocPages (PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_UINT32 ui32DevVAddr,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_HANDLE hOSMemHandle,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag)
+static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
{
- IMG_UINT32 ui32Offset;
- IMG_UINT32 ui32NumPages;
- IMG_CPU_PHYADDR sCpuPAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_UINT32 ui32Page;
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
- PVR_UNREFERENCED_PARAMETER(pvLinAddr);
+ return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
+}
- PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & (ui32PageSize - 1)) == 0);
- PVR_ASSERT(hOSMemHandle);
- PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (ui32PageSize - 1)) == 0);
+static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
+{
+ IMG_UINT32 ui32Written = 0;
+ IMG_UINT32 ui32Off = 0;
-
+ if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
+ {
+ return IMG_TRUE;
+ }
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "-- MALLOC :SGXMEM:VA_%8.8lX 0x%8.8lX %lu\r\n", ui32DevVAddr, ui32NumBytes, ui32PageSize);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- ui32Offset = 0;
- ui32NumPages = ui32NumBytes / ui32PageSize;
- while (ui32NumPages--)
+ if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
{
- sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
- PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
- ui32Offset += ui32PageSize;
- sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- ui32Page = sDevPAddr.uiAddr / ui32PageSize;
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX %lu %lu 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
- ui32Page * ui32PageSize,
- ui32PageSize,
- ui32PageSize,
- ui32Page * ui32PageSize);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- }
-}
-
-IMG_VOID PDumpMallocPageTable (PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32PTSize,
- IMG_HANDLE hUniqueTag)
-{
- IMG_PUINT8 pui8LinAddr;
- IMG_UINT32 ui32NumPages;
- IMG_CPU_PHYADDR sCpuPAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_UINT32 ui32Page;
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
+ IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
- PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize - 1)) == 0);
+ if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
+ {
+ if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
+ {
+ DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
+ gsDBGPdumpState.ui32ParamFileNum++;
+ }
+ }
+ }
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "-- MALLOC :SGXMEM:PAGE_TABLE 0x%8.8lX %lu\r\n", ui32PTSize, SGX_MMU_PAGE_SIZE);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
+ while (((IMG_UINT32) ui32Count > 0) && (ui32Written != 0xFFFFFFFF))
+ {
+ ui32Written = DbgWrite(psStream, &pui8Data[ui32Off], ui32Count, ui32Flags);
-
+
- pui8LinAddr = (IMG_PUINT8) pvLinAddr;
-
-
-
-
+ if (ui32Written == 0)
+ {
+ OSReleaseThreadQuanta();
+ }
-
- ui32NumPages = 1;
+ if (ui32Written != 0xFFFFFFFF)
+ {
+ ui32Off += ui32Written;
+ ui32Count -= ui32Written;
+ }
+ }
- while (ui32NumPages--)
+ if (ui32Written == 0xFFFFFFFF)
{
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
- sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX 0x%lX %lu 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
- ui32Page * SGX_MMU_PAGE_SIZE,
- SGX_MMU_PAGE_SIZE,
- SGX_MMU_PAGE_SIZE,
- ui32Page * SGX_MMU_PAGE_SIZE);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- pui8LinAddr += SGX_MMU_PAGE_SIZE;
- }
-}
-
-IMG_VOID PDumpFreePages (BM_HEAP *psBMHeap,
- IMG_DEV_VIRTADDR sDevVAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag,
- IMG_BOOL bInterleaved)
-{
- IMG_UINT32 ui32NumPages, ui32PageCounter;
- IMG_DEV_PHYADDR sDevPAddr;
- PVRSRV_DEVICE_NODE *psDeviceNode;
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- PVR_ASSERT(((IMG_UINT32) sDevVAddr.uiAddr & (ui32PageSize - 1)) == 0);
- PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (ui32PageSize - 1)) == 0);
-
-
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "-- FREE :SGXMEM:VA_%8.8lX\r\n", sDevVAddr.uiAddr);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
-
-
-
- ui32NumPages = ui32NumBytes / ui32PageSize;
- psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
- for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages; ui32PageCounter++)
- {
- if (!bInterleaved || (ui32PageCounter % 2) == 0)
- {
- sDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->pMMUHeap, sDevVAddr);
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, sDevPAddr.uiAddr);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- }
- else
- {
-
- }
-
- sDevVAddr.uiAddr += ui32PageSize;
- }
-}
-
-IMG_VOID PDumpFreePageTable (PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32PTSize,
- IMG_HANDLE hUniqueTag)
-{
- IMG_PUINT8 pui8LinAddr;
- IMG_UINT32 ui32NumPages;
- IMG_CPU_PHYADDR sCpuPAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_UINT32 ui32Page;
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize - 1)) == 0);
-
-
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "-- FREE :SGXMEM:PAGE_TABLE\r\n");
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
-
-
-
- pui8LinAddr = (IMG_PUINT8) pvLinAddr;
-
-
-
-
-
-
-
- ui32NumPages = 1;
-
- while (ui32NumPages--)
- {
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
- sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
- pui8LinAddr += SGX_MMU_PAGE_SIZE;
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, ui32Page * SGX_MMU_PAGE_SIZE);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- }
-}
-
-IMG_VOID PDumpPDReg (IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32Data,
- IMG_HANDLE hUniqueTag)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
-
-
- snprintf (pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXREG:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- ui32Reg,
- (IMG_UINT32) hUniqueTag,
- ui32Data & ~(SGX_MMU_PAGE_SIZE - 1),
- ui32Data & (SGX_MMU_PAGE_SIZE - 1));
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
-}
-
-IMG_VOID PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32Data,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
-
-
- snprintf (pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXREG:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- ui32Reg,
- (IMG_UINT32) hUniqueTag,
- ui32Data & ~(SGX_MMU_PAGE_SIZE - 1),
- ui32Data & (SGX_MMU_PAGE_SIZE - 1));
- PDumpWriteString2(pszScript, ui32Flags);
-}
-
-PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
- IMG_UINT32 ui32Offset,
- IMG_UINT32 ui32Value,
- IMG_UINT32 ui32Mask,
- PDUMP_POLL_OPERATOR eOperator,
- IMG_BOOL bLastFrame,
- IMG_BOOL bOverwrite,
- IMG_HANDLE hUniqueTag)
-{
- #define MEMPOLL_DELAY (1000)
- #define MEMPOLL_COUNT (2000000000 / MEMPOLL_DELAY)
-
- IMG_UINT32 ui32PageOffset;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_DEV_VIRTADDR sDevVPageAddr;
- IMG_CPU_PHYADDR CpuPAddr;
- IMG_UINT32 ui32Flags;
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
-
-
- PVR_ASSERT((ui32Offset + sizeof(IMG_UINT32)) <= psMemInfo->ui32AllocSize);
-
- if (gsDBGPdumpState.ui32ParamFileNum == 0)
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
- }
- else
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm", gsDBGPdumpState.ui32ParamFileNum);
- }
-
-
- ui32Flags = 0;
-
- if (bLastFrame)
- {
- ui32Flags |= PDUMP_FLAGS_LASTFRAME;
- }
-
- if (bOverwrite)
- {
- ui32Flags |= PDUMP_FLAGS_RESETLFBUFFER;
- }
-
-
-
-
- CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle, ui32Offset);
- ui32PageOffset = CpuPAddr.uiAddr & (PAGE_SIZE -1);
-
-
- sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;
-
-
- BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
-
-
- sDevPAddr.uiAddr += ui32PageOffset;
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "POL :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- ui32Value,
- ui32Mask,
- eOperator,
- MEMPOLL_COUNT,
- MEMPOLL_DELAY);
- PDumpWriteString2(pszScript, ui32Flags);
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpMemKM(IMG_PVOID pvAltLinAddr,
- PVRSRV_KERNEL_MEM_INFO *psMemInfo,
- IMG_UINT32 ui32Offset,
- IMG_UINT32 ui32Bytes,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag)
-{
- IMG_UINT32 ui32PageByteOffset;
- IMG_UINT8* pui8DataLinAddr = IMG_NULL;
- IMG_DEV_VIRTADDR sDevVPageAddr;
- IMG_DEV_VIRTADDR sDevVAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_CPU_PHYADDR CpuPAddr;
- IMG_UINT32 ui32ParamOutPos;
- IMG_UINT32 ui32CurrentOffset;
- IMG_UINT32 ui32BytesRemaining;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
-
-
- PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
-
- if (ui32Bytes == 0)
- {
- return PVRSRV_OK;
- }
-
- if(pvAltLinAddr)
- {
- pui8DataLinAddr = pvAltLinAddr;
- }
- else if(psMemInfo->pvLinAddrKM)
- {
- pui8DataLinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM + ui32Offset;
- }
-
- PVR_ASSERT(pui8DataLinAddr);
-
- ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
-
-
-
- if(!PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
- pui8DataLinAddr,
- ui32Bytes,
- ui32Flags))
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
- if (gsDBGPdumpState.ui32ParamFileNum == 0)
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
- }
- else
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm", gsDBGPdumpState.ui32ParamFileNum);
- }
-
-
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "-- LDB :SGXMEM:VA_%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- psMemInfo->sDevVAddr.uiAddr,
- ui32Offset,
- ui32Bytes,
- ui32ParamOutPos,
- pszFile);
- PDumpWriteString2(pszScript, ui32Flags);
-
-
-
-
- CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle, ui32Offset);
- ui32PageByteOffset = CpuPAddr.uiAddr & (PAGE_SIZE -1);
-
-
- sDevVAddr = psMemInfo->sDevVAddr;
- sDevVAddr.uiAddr += ui32Offset;
-
- ui32BytesRemaining = ui32Bytes;
- ui32CurrentOffset = ui32Offset;
-
- while(ui32BytesRemaining > 0)
- {
- IMG_UINT32 ui32BlockBytes = MIN(ui32BytesRemaining, PAGE_SIZE);
- CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
- ui32CurrentOffset);
-
- sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32CurrentOffset - ui32PageByteOffset;
-
- BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
-
-
- sDevPAddr.uiAddr += ui32PageByteOffset;
-
- if(ui32PageByteOffset)
- {
- ui32BlockBytes =
- MIN(ui32BytesRemaining, PAGE_ALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
-
- ui32PageByteOffset = 0;
- }
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- ui32BlockBytes,
- ui32ParamOutPos,
- pszFile);
- PDumpWriteString2(pszScript, ui32Flags);
-
- ui32BytesRemaining -= ui32BlockBytes;
- ui32CurrentOffset += ui32BlockBytes;
- ui32ParamOutPos += ui32BlockBytes;
- }
-
- PVR_ASSERT(ui32BytesRemaining == 0);
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32Bytes,
- IMG_UINT32 ui32Flags,
- IMG_BOOL bInitialisePages,
- IMG_HANDLE hUniqueTag1,
- IMG_HANDLE hUniqueTag2)
-{
- IMG_UINT32 ui32NumPages;
- IMG_UINT32 ui32PageOffset;
- IMG_UINT32 ui32BlockBytes;
- IMG_UINT8* pui8LinAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_CPU_PHYADDR sCpuPAddr;
- IMG_UINT32 ui32Offset;
- IMG_UINT32 ui32ParamOutPos;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
-
- if (ui32Flags);
-
- if (!pvLinAddr)
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
- ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
-
- if (bInitialisePages)
- {
-
-
-
- if (!PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
- pvLinAddr,
- ui32Bytes,
- PDUMP_FLAGS_CONTINUOUS))
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
- if (gsDBGPdumpState.ui32ParamFileNum == 0)
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
- }
- else
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm", gsDBGPdumpState.ui32ParamFileNum);
- }
- }
-
-
-
-
- ui32PageOffset = (IMG_UINT32) pvLinAddr & (HOST_PAGESIZE() - 1);
- ui32NumPages = (ui32PageOffset + ui32Bytes + HOST_PAGESIZE() - 1) / HOST_PAGESIZE();
- pui8LinAddr = (IMG_UINT8*) pvLinAddr;
-
- while (ui32NumPages--)
- {
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
- sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
-
-
- if (ui32PageOffset + ui32Bytes > HOST_PAGESIZE())
- {
-
- ui32BlockBytes = HOST_PAGESIZE() - ui32PageOffset;
- }
- else
- {
-
- ui32BlockBytes = ui32Bytes;
- }
-
-
-
- if (bInitialisePages)
- {
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- ui32BlockBytes,
- ui32ParamOutPos,
- pszFile);
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- }
- else
- {
- for (ui32Offset = 0; ui32Offset < ui32BlockBytes; ui32Offset += sizeof(IMG_UINT32))
- {
- IMG_UINT32 ui32PTE = *((IMG_UINT32 *) (pui8LinAddr + ui32Offset));
-
- if ((ui32PTE & SGX_MMU_PDE_ADDR_MASK) != 0)
- {
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_SIZE - 1),
- (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_SIZE - 1),
- (IMG_UINT32) hUniqueTag2,
- ui32PTE & SGX_MMU_PDE_ADDR_MASK,
- ui32PTE & ~SGX_MMU_PDE_ADDR_MASK);
- }
- else
- {
- PVR_ASSERT(!(ui32PTE & SGX_MMU_PTE_VALID));
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_SIZE - 1),
- (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_SIZE - 1),
- ui32PTE,
- (IMG_UINT32) hUniqueTag2);
- }
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
- }
- }
-
-
-
-
- ui32PageOffset = 0;
-
- ui32Bytes -= ui32BlockBytes;
-
- pui8LinAddr += ui32BlockBytes;
-
- ui32ParamOutPos += ui32BlockBytes;
- }
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
- IMG_UINT32 ui32Offset,
- IMG_DEV_PHYADDR sPDDevPAddr,
- IMG_HANDLE hUniqueTag1,
- IMG_HANDLE hUniqueTag2)
-{
- IMG_UINT32 ui32ParamOutPos;
- IMG_CPU_PHYADDR CpuPAddr;
- IMG_UINT32 ui32PageByteOffset;
- IMG_DEV_VIRTADDR sDevVAddr;
- IMG_DEV_VIRTADDR sDevVPageAddr;
- IMG_DEV_PHYADDR sDevPAddr;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
-
- ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
-
- if(!PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
- (IMG_UINT8 *)&sPDDevPAddr,
- sizeof(IMG_DEV_PHYADDR),
- PDUMP_FLAGS_CONTINUOUS))
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
- if (gsDBGPdumpState.ui32ParamFileNum == 0)
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
- }
- else
- {
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm", gsDBGPdumpState.ui32ParamFileNum);
- }
-
- CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle, ui32Offset);
- ui32PageByteOffset = CpuPAddr.uiAddr & (PAGE_SIZE -1);
-
- sDevVAddr = psMemInfo->sDevVAddr;
- sDevVAddr.uiAddr += ui32Offset;
-
- sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
- BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
- sDevPAddr.uiAddr += ui32PageByteOffset;
-
- if ((sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK) != 0)
- {
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- (IMG_UINT32) hUniqueTag2,
- sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK,
- sPDDevPAddr.uiAddr & ~SGX_MMU_PDE_ADDR_MASK);
- }
- else
- {
- PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- sPDDevPAddr.uiAddr);
- }
- PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
-{
- IMG_UINT32 ui32Stream;
-
- for (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
- {
- if (gsDBGPdumpState.psStream[ui32Stream])
- {
- DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
- }
- }
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpGetFrameKM(IMG_PUINT32 pui32Frame)
-{
- *pui32Frame = DbgGetFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags)
-{
- IMG_UINT32 ui32Count = 0;
- PVRSRV_ERROR eError;
- __PDBG_PDUMP_STATE_GET_MSG_STRING(PVRSRV_ERROR_GENERIC);
-
- if(ui32Flags & PDUMP_FLAGS_CONTINUOUS)
- {
- eError = PVRSRV_ERROR_GENERIC;
- }
- else
- {
- eError = PVRSRV_ERROR_CMD_NOT_PROCESSED;
- }
-
- if (!PDumpWriteString2("-- ", ui32Flags))
- {
- return eError;
- }
-
-
- snprintf(pszMsg, SZ_MSG_SIZE_MAX, "%s",pszComment);
-
-
- while ((pszMsg[ui32Count]!=0) && (ui32Count<SZ_MSG_SIZE_MAX) )
- {
- ui32Count++;
- }
-
-
- if ( (pszMsg[ui32Count-1] != '\n') && (ui32Count<SZ_MSG_SIZE_MAX))
- {
- pszMsg[ui32Count] = '\n';
- ui32Count++;
- pszMsg[ui32Count] = '\0';
- }
- if ( (pszMsg[ui32Count-2] != '\r') && (ui32Count<SZ_MSG_SIZE_MAX) )
- {
- pszMsg[ui32Count-1] = '\r';
- pszMsg[ui32Count] = '\n';
- ui32Count++;
- pszMsg[ui32Count] = '\0';
- }
-
- PDumpWriteString2(pszMsg, ui32Flags);
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags)
-{
- IMG_UINT32 ui32Count = 0;
- __PDBG_PDUMP_STATE_GET_MSG_STRING(PVRSRV_ERROR_GENERIC);
-
-
- snprintf(pszMsg, SZ_MSG_SIZE_MAX, "%s", pszString);
-
-
- while ((pszMsg[ui32Count]!=0) && (ui32Count<SZ_MSG_SIZE_MAX) )
- {
- ui32Count++;
- }
-
-
- if ( (pszMsg[ui32Count-1] != '\n') && (ui32Count<SZ_MSG_SIZE_MAX))
- {
- pszMsg[ui32Count] = '\n';
- ui32Count++;
- pszMsg[ui32Count] = '\0';
- }
- if ( (pszMsg[ui32Count-2] != '\r') && (ui32Count<SZ_MSG_SIZE_MAX) )
- {
- pszMsg[ui32Count-1] = '\r';
- pszMsg[ui32Count] = '\n';
- ui32Count++;
- pszMsg[ui32Count] = '\0';
- }
-
- if (!PDumpWriteILock(gsDBGPdumpState.
- psStream[PDUMP_STREAM_DRIVERINFO],
- (IMG_UINT8 *)pszMsg,
- ui32Count,
- ui32Flags))
- {
- if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
- {
- return PVRSRV_ERROR_GENERIC;
- }
- else
- {
- return PVRSRV_ERROR_CMD_NOT_PROCESSED;
- }
- }
-
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpBitmapKM( IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_UINT32 ui32Width,
- IMG_UINT32 ui32Height,
- IMG_UINT32 ui32StrideInBytes,
- IMG_DEV_VIRTADDR sDevBaseAddr,
- IMG_UINT32 ui32Size,
- PDUMP_PIXEL_FORMAT ePixelFormat,
- PDUMP_MEM_FORMAT eMemFormat,
- IMG_UINT32 ui32PDumpFlags)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING(PVRSRV_ERROR_GENERIC);
- PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "\r\n-- Dump bitmap of render\r\n");
-
-#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "SII %s %s.bin :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
- pszFileName,
- pszFileName,
- PDUMP_DATAMASTER_PIXEL,
- sDevBaseAddr.uiAddr,
- ui32Size,
- ui32FileOffset,
- ePixelFormat,
- ui32Width,
- ui32Height,
- ui32StrideInBytes,
- eMemFormat);
-#else
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "SII %s %s.bin :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
- pszFileName,
- pszFileName,
- sDevBaseAddr.uiAddr,
- ui32Size,
- ui32FileOffset,
- ePixelFormat,
- ui32Width,
- ui32Height,
- ui32StrideInBytes,
- eMemFormat);
-#endif
-
- PDumpWriteString2( pszScript, ui32PDumpFlags);
- return PVRSRV_OK;
-}
-
-PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_UINT32 ui32Address,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PDumpFlags)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING(PVRSRV_ERROR_GENERIC);
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "SAB :SGXREG:0x%08lX 0x%08lX %s\r\n",
- ui32Address,
- ui32FileOffset,
- pszFileName);
-
- PDumpWriteString2( pszScript, ui32PDumpFlags);
-
- return PVRSRV_OK;
-}
-
-
-static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
-{
- return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
-}
-
-
-static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
-{
- IMG_UINT32 ui32Written = 0;
- IMG_UINT32 ui32Off = 0;
-
- if (!psStream || PDumpSuspended() || (ui32Flags & PDUMP_FLAGS_NEVER))
- {
- return IMG_TRUE;
- }
-
-
-
-
- if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
- {
- IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
-
- if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
- {
- if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
- {
- DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
- gsDBGPdumpState.ui32ParamFileNum++;
- }
- }
- }
-
-
- while (((IMG_UINT32) ui32Count > 0) && (ui32Written != 0xFFFFFFFF))
- {
- ui32Written = DbgWrite(psStream, &pui8Data[ui32Off], ui32Count, ui32Flags);
-
-
-
-
- if (ui32Written == 0)
- {
- OSReleaseThreadQuanta();
- }
-
- if (ui32Written != 0xFFFFFFFF)
- {
- ui32Off += ui32Written;
- ui32Count -= ui32Written;
- }
- }
-
- if (ui32Written == 0xFFFFFFFF)
- {
- return IMG_FALSE;
+ return IMG_FALSE;
}
return IMG_TRUE;
}
static IMG_VOID DbgSetFrame(PDBG_STREAM psStream, IMG_UINT32 ui32Frame)
-{
+{
gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
}
static IMG_UINT32 DbgGetFrame(PDBG_STREAM psStream)
-{
+{
return gpfnDbgDrv->pfnGetFrame(psStream);
}
static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
-{
+{
gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
}
{
IMG_UINT32 ui32BytesWritten;
- if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
+ if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)
{
- if ((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) &&
- (psStream->ui32Start == 0xFFFFFFFF) &&
- (psStream->ui32End == 0xFFFFFFFF) &&
- psStream->bInitPhaseComplete)
+ if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
+ (psStream->ui32Start == 0xFFFFFFFFUL) &&
+ (psStream->ui32End == 0xFFFFFFFFUL) &&
+ psStream->bInitPhaseComplete)
{
ui32BytesWritten = ui32BCount;
}
return ui32BytesWritten;
}
-IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame)
-{
- IMG_BOOL bFrameDumped;
-
-
-
- bFrameDumped = IMG_FALSE;
- PDumpSetFrameKM(ui32CurrentFrame + 1);
- bFrameDumped = PDumpIsCaptureFrameKM();
- PDumpSetFrameKM(ui32CurrentFrame);
-
- return bFrameDumped;
-}
-
-IMG_VOID PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters)
-{
- IMG_UINT32 ui32FileOffset, ui32Flags;
- IMG_UINT32 i;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING();
-
- ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
- ui32FileOffset = 0;
-
- PDUMPCOMMENTWITHFLAGS(ui32Flags, "\r\n-- Dump 3D signature registers\r\n");
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "out%lu_3d.sig", ui32DumpFrameNum);
-
- for (i = 0; i < ui32NumRegisters; i++)
- {
- PDumpReadRegKM(pszFile, ui32FileOffset, pui32Registers[i], sizeof(IMG_UINT32), ui32Flags);
- ui32FileOffset += sizeof(IMG_UINT32);
- }
-}
-
-static IMG_VOID PDumpCountRead(IMG_CHAR *pszFileName,
- IMG_UINT32 ui32Address,
- IMG_UINT32 ui32Size,
- IMG_UINT32 *pui32FileOffset,
- IMG_BOOL bLastFrame)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "SAB :SGXREG:0x%08lX 0x%08lX %s\r\n", ui32Address, *pui32FileOffset, pszFileName);
- PDumpWriteString2(pszScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
-
- *pui32FileOffset += ui32Size;
-}
-
-IMG_VOID PDumpCounterRegisters (IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters)
-{
- IMG_UINT32 ui32FileOffset;
- IMG_UINT32 i;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING();
-
- PDUMPCOMMENTWITHFLAGS(bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0, "\r\n-- Dump counter registers\r\n");
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "out%lu.perf", ui32DumpFrameNum);
- ui32FileOffset = 0;
-
- for (i = 0; i < ui32NumRegisters; i++)
- {
- PDumpCountRead(pszFile, pui32Registers[i], sizeof(IMG_UINT32), &ui32FileOffset, bLastFrame);
- }
-}
-
-IMG_VOID PDumpTASignatureRegisters (IMG_UINT32 ui32DumpFrameNum,
- IMG_UINT32 ui32TAKickCount,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters)
-{
- IMG_UINT32 ui32FileOffset, ui32Flags;
- IMG_UINT32 i;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING();
-
- ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
- PDUMPCOMMENTWITHFLAGS(ui32Flags, "\r\n-- Dump TA signature registers\r\n");
- snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "out%lu_ta.sig", ui32DumpFrameNum);
-
- ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(IMG_UINT32);
-
- for (i = 0; i < ui32NumRegisters; i++)
- {
- PDumpReadRegKM(pszFile, ui32FileOffset, pui32Registers[i], sizeof(IMG_UINT32), ui32Flags);
- ui32FileOffset += sizeof(IMG_UINT32);
- }
-}
-
-IMG_VOID PDumpRegRead(const IMG_UINT32 ui32RegOffset, IMG_UINT32 ui32Flags)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
- PDumpWriteString2(pszScript, ui32Flags);
-}
-
-IMG_VOID PDumpCycleCountRegRead(const IMG_UINT32 ui32RegOffset, IMG_BOOL bLastFrame)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- snprintf(pszScript, SZ_SCRIPT_SIZE_MAX, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
- PDumpWriteString2(pszScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
-}
-
-
-IMG_VOID PDumpHWPerfCBKM (IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_DEV_VIRTADDR sDevBaseAddr,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PDumpFlags)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
- PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "\r\n-- Dump Hardware Performance Circular Buffer\r\n");
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
-#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
- "SAB :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
- PDUMP_DATAMASTER_PIXEL,
-#else
- "SAB :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
-#endif
- sDevBaseAddr.uiAddr,
- ui32Size,
- ui32FileOffset,
- pszFileName);
-
- PDumpWriteString2( pszScript, ui32PDumpFlags);
-}
-
-
-IMG_VOID PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
- IMG_UINT32 ui32ROffOffset,
- IMG_UINT32 ui32WPosVal,
- IMG_UINT32 ui32PacketSize,
- IMG_UINT32 ui32BufferSize,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag)
-{
- IMG_UINT32 ui32PageOffset;
- IMG_DEV_VIRTADDR sDevVAddr;
- IMG_DEV_PHYADDR sDevPAddr;
- IMG_DEV_VIRTADDR sDevVPageAddr;
- IMG_CPU_PHYADDR CpuPAddr;
-
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
-
- PVR_ASSERT((ui32ROffOffset + sizeof(IMG_UINT32)) <= psROffMemInfo->ui32AllocSize);
-
- sDevVAddr = psROffMemInfo->sDevVAddr;
-
-
- sDevVAddr.uiAddr += ui32ROffOffset;
-
-
-
-
- CpuPAddr = OSMemHandleToCpuPAddr(psROffMemInfo->sMemBlk.hOSMemHandle, ui32ROffOffset);
- ui32PageOffset = CpuPAddr.uiAddr & (PAGE_SIZE -1);
-
-
- sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageOffset;
-
-
- BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);
-
-
- sDevPAddr.uiAddr += ui32PageOffset;
-
- snprintf(pszScript,
- SZ_SCRIPT_SIZE_MAX,
- "CBP :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
- ui32WPosVal,
- ui32PacketSize,
- ui32BufferSize);
- PDumpWriteString2(pszScript, ui32Flags);
-}
-
-
-IMG_VOID PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags)
-{
- __PDBG_PDUMP_STATE_GET_SCRIPT_STRING();
-
- sprintf(pszScript, "IDL %lu\r\n", ui32Clocks);
- PDumpWriteString2(pszScript, ui32Flags);
-}
-
-
-IMG_VOID PDumpIDL(IMG_UINT32 ui32Clocks)
-{
- PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS);
-}
-
IMG_VOID PDumpSuspendKM(IMG_VOID)
{
IMG_HANDLE hKernelMemInfo;
#endif
+#if defined(SUPPORT_MEMINFO_IDS)
+
+ IMG_UINT64 ui64Stamp;
+#endif
IMG_HANDLE hBlockAlloc;
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+ IMG_PVOID pPriv;
+#endif
}
PVRSRV_FILE_PRIVATE_DATA;
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
#include "services_headers.h"
#include "env_perproc.h"
#include "linkage.h"
+#include "lists.h"
+DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
+
+
static struct proc_dir_entry * dir;
+#ifndef PVR_PROC_USE_SEQ_FILE
static off_t procDumpSysNodes(IMG_CHAR *buf, size_t size, off_t off);
static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off);
+#endif
+
static const IMG_CHAR PVRProcDirRoot[] = "pvr";
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+#define PVR_PROC_SEQ_START_TOKEN (void*)1
+static IMG_INT pvr_proc_open(struct inode *inode,struct file *file);
+static void *pvr_proc_seq_start (struct seq_file *m, loff_t *pos);
+static void pvr_proc_seq_stop (struct seq_file *m, void *v);
+static void *pvr_proc_seq_next (struct seq_file *m, void *v, loff_t *pos);
+static int pvr_proc_seq_show (struct seq_file *m, void *v);
+static ssize_t pvr_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
+
+static struct file_operations pvr_proc_operations =
+{
+ .open = pvr_proc_open,
+ .read = seq_read,
+ .write = pvr_proc_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
+static struct seq_operations pvr_proc_seq_operations =
+{
+ .start = pvr_proc_seq_start,
+ .next = pvr_proc_seq_next,
+ .stop = pvr_proc_seq_stop,
+ .show = pvr_proc_seq_show,
+};
+
+static struct proc_dir_entry* g_pProcQueue;
+static struct proc_dir_entry* g_pProcVersion;
+static struct proc_dir_entry* g_pProcSysNodes;
+
+#ifdef DEBUG_PVR
+static struct proc_dir_entry* g_pProcDebugLevel;
+#endif
+
+#ifdef PVR_MANUAL_POWER_CONTROL
+static struct proc_dir_entry* g_pProcPowerLevel;
+#endif
+
+
+static void ProcSeqShowVersion(struct seq_file *sfile,void* el);
+
+static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el);
+static void* ProcSeqOff2ElementSysNodes(struct seq_file * sfile, loff_t off);
+
+#endif
+
off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * format, ...)
{
IMG_INT n;
- IMG_INT space = size - off;
+ size_t space = size - (size_t)off;
va_list ap;
PVR_ASSERT(space >= 0);
va_end (ap);
- if (n >= space || n < 0)
+ if (n >= (IMG_INT)space || n < 0)
{
buffer[size - 1] = 0;
- return size - 1;
+ return (off_t)(size - 1);
}
else
{
- return off + n;
+ return (off + (off_t)n);
+ }
+}
+
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+void* ProcSeq1ElementOff2Element(struct seq_file *sfile, loff_t off)
+{
+
+ if(!off)
+ return (void*)2;
+ return NULL;
+}
+
+
+void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off)
+{
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+
+ if(off == 1)
+ return (void*)2;
+
+ return NULL;
+}
+
+
+static IMG_INT pvr_proc_open(struct inode *inode,struct file *file)
+{
+ IMG_INT ret = seq_open(file, &pvr_proc_seq_operations);
+
+ struct seq_file *seq = (struct seq_file*)file->private_data;
+ struct proc_dir_entry* pvr_proc_entry = PDE(inode);
+
+
+ seq->private = pvr_proc_entry->data;
+ return ret;
+}
+
+static ssize_t pvr_proc_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ struct inode *inode = file->f_path.dentry->d_inode;
+ struct proc_dir_entry * dp;
+
+ dp = PDE(inode);
+
+ if (!dp->write_proc)
+ return -EIO;
+
+ return dp->write_proc(file, buffer, count, dp->data);
+}
+
+
+static void *pvr_proc_seq_start (struct seq_file *proc_seq_file, loff_t *pos)
+{
+ PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+ if(handlers->startstop != NULL)
+ handlers->startstop(proc_seq_file, IMG_TRUE);
+ return handlers->off2element(proc_seq_file, *pos);
+}
+
+static void pvr_proc_seq_stop (struct seq_file *proc_seq_file, void *v)
+{
+ PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+ if(handlers->startstop != NULL)
+ handlers->startstop(proc_seq_file, IMG_FALSE);
+}
+
+static void *pvr_proc_seq_next (struct seq_file *proc_seq_file, void *v, loff_t *pos)
+{
+ PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+ (*pos)++;
+ if( handlers->next != NULL)
+ return handlers->next( proc_seq_file, v, *pos );
+ return handlers->off2element(proc_seq_file, *pos);
+}
+
+static int pvr_proc_seq_show (struct seq_file *proc_seq_file, void *v)
+{
+ PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+ handlers->show( proc_seq_file,v );
+ return 0;
+}
+
+
+
+static struct proc_dir_entry* CreateProcEntryInDirSeq(
+ struct proc_dir_entry *pdir,
+ const IMG_CHAR * name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler,
+ write_proc_t whandler
+ )
+{
+
+ struct proc_dir_entry * file;
+ mode_t mode;
+
+ if (!dir)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDirSeq: cannot make proc entry /proc/%s/%s: no parent", PVRProcDirRoot, name));
+ return NULL;
+ }
+
+ mode = S_IFREG;
+
+ if (show_handler)
+ {
+ mode |= S_IRUGO;
+ }
+
+ if (whandler)
+ {
+ mode |= S_IWUSR;
+ }
+
+ file=create_proc_entry(name, mode, pdir);
+
+ if (file)
+ {
+ PVR_PROC_SEQ_HANDLERS *seq_handlers;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30))
+ file->owner = THIS_MODULE;
+#endif
+
+ file->proc_fops = &pvr_proc_operations;
+ file->write_proc = whandler;
+
+
+ file->data = kmalloc(sizeof(PVR_PROC_SEQ_HANDLERS), GFP_KERNEL);
+ if(file->data)
+ {
+ seq_handlers = (PVR_PROC_SEQ_HANDLERS*)file->data;
+ seq_handlers->next = next_handler;
+ seq_handlers->show = show_handler;
+ seq_handlers->off2element = off2element_handler;
+ seq_handlers->startstop = startstop_handler;
+ seq_handlers->data = data;
+
+ return file;
+ }
}
+
+ PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDirSeq: cannot make proc entry /proc/%s/%s: no memory", PVRProcDirRoot, name));
+ return 0;
+}
+
+
+struct proc_dir_entry* CreateProcReadEntrySeq (
+ const IMG_CHAR * name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler
+ )
+{
+ return CreateProcEntrySeq(name,
+ data,
+ next_handler,
+ show_handler,
+ off2element_handler,
+ startstop_handler,
+ NULL);
}
+struct proc_dir_entry* CreateProcEntrySeq (
+ const IMG_CHAR * name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler,
+ write_proc_t whandler
+ )
+{
+ return CreateProcEntryInDirSeq(
+ dir,
+ name,
+ data,
+ next_handler,
+ show_handler,
+ off2element_handler,
+ startstop_handler,
+ NULL
+ );
+}
+
+
+
+struct proc_dir_entry* CreatePerProcessProcEntrySeq (
+ const IMG_CHAR * name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler,
+ write_proc_t whandler
+ )
+{
+ PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+ IMG_UINT32 ui32PID;
+
+ if (!dir)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntrySeq: /proc/%s doesn't exist", PVRProcDirRoot));
+ return NULL;
+ }
+
+ ui32PID = OSGetCurrentProcessIDKM();
+
+ psPerProc = PVRSRVPerProcessPrivateData(ui32PID);
+ if (!psPerProc)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntrySeq: no per process data"));
+
+ return NULL;
+ }
+
+ if (!psPerProc->psProcDir)
+ {
+ IMG_CHAR dirname[16];
+ IMG_INT ret;
+
+ ret = snprintf(dirname, sizeof(dirname), "%lu", ui32PID);
+
+ if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't generate per process proc directory name \"%u\"", ui32PID));
+ return NULL;
+ }
+ else
+ {
+ psPerProc->psProcDir = proc_mkdir(dirname, dir);
+ if (!psPerProc->psProcDir)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't create per process proc directory /proc/%s/%u",
+ PVRProcDirRoot, ui32PID));
+ return NULL;
+ }
+ }
+ }
+
+ return CreateProcEntryInDirSeq(psPerProc->psProcDir, name, data, next_handler,
+ show_handler,off2element_handler,startstop_handler,whandler);
+}
+
+
+IMG_VOID RemoveProcEntrySeq( struct proc_dir_entry* proc_entry )
+{
+ if (dir)
+ {
+ void* data = proc_entry->data ;
+ PVR_DPF((PVR_DBG_MESSAGE, "Removing /proc/%s/%s", PVRProcDirRoot, proc_entry->name));
+
+ remove_proc_entry(proc_entry->name, dir);
+ if( data)
+ kfree( data );
+
+ }
+}
+
+IMG_VOID RemovePerProcessProcEntrySeq(struct proc_dir_entry* proc_entry)
+{
+ PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+
+ psPerProc = LinuxTerminatingProcessPrivateData();
+ if (!psPerProc)
+ {
+ psPerProc = PVRSRVFindPerProcessPrivateData();
+ if (!psPerProc)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: can't "
+ "remove %s, no per process data", proc_entry->name));
+ return;
+ }
+ }
+
+ if (psPerProc->psProcDir)
+ {
+ void* data = proc_entry->data ;
+ PVR_DPF((PVR_DBG_MESSAGE, "Removing proc entry %s from %s", proc_entry->name, psPerProc->psProcDir->name));
+
+ remove_proc_entry(proc_entry->name, psPerProc->psProcDir);
+ if(data)
+ kfree( data );
+ }
+}
+
+#endif
static IMG_INT pvr_read_proc(IMG_CHAR *page, IMG_CHAR **start, off_t off,
IMG_INT count, IMG_INT *eof, IMG_VOID *data)
{
- pvr_read_proc_t *pprn = data;
+ pvr_read_proc_t *pprn = (pvr_read_proc_t *)data;
- off_t len = pprn (page, count, off);
+ off_t len = pprn (page, (size_t)count, off);
if (len == END_OF_FILE)
{
ret = snprintf(dirname, sizeof(dirname), "%lu", ui32PID);
- if (ret <=0 || ret >= sizeof(dirname))
- {
- PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't generate per process proc directory name \"%u\"", ui32PID));
+ if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't generate per process proc directory name \"%u\"", ui32PID));
- return -ENOMEM;
- }
- else
- {
- psPerProc->psProcDir = proc_mkdir(dirname, dir);
- if (!psPerProc->psProcDir)
- {
- PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't create per process proc directory /proc/%s/%u", PVRProcDirRoot, ui32PID));
+ return -ENOMEM;
+ }
+ else
+ {
+ psPerProc->psProcDir = proc_mkdir(dirname, dir);
+ if (!psPerProc->psProcDir)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't create per process proc directory /proc/%s/%u", PVRProcDirRoot, ui32PID));
- return -ENOMEM;
- }
- }
+ return -ENOMEM;
+ }
+ }
}
return CreateProcEntryInDir(psPerProc->psProcDir, name, rhandler, whandler, data);
return -ENOMEM;
}
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_pProcQueue = CreateProcReadEntrySeq("queue", NULL, NULL, ProcSeqShowQueue, ProcSeqOff2ElementQueue, NULL);
+ g_pProcVersion = CreateProcReadEntrySeq("version", NULL, NULL, ProcSeqShowVersion, ProcSeq1ElementHeaderOff2Element, NULL);
+ g_pProcSysNodes = CreateProcReadEntrySeq("nodes", NULL, NULL, ProcSeqShowSysNodes, ProcSeqOff2ElementSysNodes, NULL);
+
+ if(!g_pProcQueue || !g_pProcVersion || !g_pProcSysNodes)
+#else
if (CreateProcReadEntry("queue", QueuePrintQueues) ||
CreateProcReadEntry("version", procDumpVersion) ||
CreateProcReadEntry("nodes", procDumpSysNodes))
+#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s files", PVRProcDirRoot));
return -ENOMEM;
}
-#ifdef DEBUG
+
+#ifdef DEBUG_PVR
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_pProcDebugLevel = CreateProcEntrySeq("debug_level", NULL, NULL,
+ ProcSeqShowDebugLevel,
+ ProcSeq1ElementOff2Element, NULL,
+ PVRDebugProcSetLevel);
+ if(!g_pProcDebugLevel)
+#else
if (CreateProcEntry ("debug_level", PVRDebugProcGetLevel, PVRDebugProcSetLevel, 0))
+#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/debug_level", PVRProcDirRoot));
}
#ifdef PVR_MANUAL_POWER_CONTROL
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_pProcPowerLevel = CreateProcEntrySeq("power_control", NULL, NULL,
+ ProcSeqShowPowerLevel,
+ ProcSeq1ElementOff2Element, NULL,
+ PVRProcSetPowerLevel);
+ if(!g_pProcPowerLevel)
+#else
if (CreateProcEntry("power_control", PVRProcGetPowerLevel, PVRProcSetPowerLevel, 0))
+#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/power_control", PVRProcDirRoot));
}
-IMG_VOID RemoveProcEntry(const IMG_CHAR *name)
+IMG_VOID RemoveProcEntry(const IMG_CHAR * name)
{
if (dir)
{
IMG_VOID RemovePerProcessProcEntry(const IMG_CHAR *name)
{
- PVRSRV_ENV_PER_PROCESS_DATA *psPerProc = PVRSRVFindPerProcessPrivateData();
+ PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+ psPerProc = LinuxTerminatingProcessPrivateData();
if (!psPerProc)
{
- PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: can't remove %s, no per process data", name));
- return;
+ psPerProc = PVRSRVFindPerProcessPrivateData();
+ if (!psPerProc)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: can't "
+ "remove %s, no per process data", name));
+ return;
+ }
}
if (psPerProc->psProcDir)
{
- remove_proc_entry(name, psPerProc->psProcDir);
+ remove_proc_entry(name, psPerProc->psProcDir);
- PVR_DPF((PVR_DBG_MESSAGE, "Removing proc entry %s from %s", name, psPerProc->psProcDir->name));
+ PVR_DPF((PVR_DBG_MESSAGE, "Removing proc entry %s from %s", name, psPerProc->psProcDir->name));
}
}
IMG_VOID RemoveProcEntries(IMG_VOID)
{
-#ifdef DEBUG
+#ifdef DEBUG_PVR
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq( g_pProcDebugLevel );
+#else
RemoveProcEntry("debug_level");
+#endif
+
#ifdef PVR_MANUAL_POWER_CONTROL
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq( g_pProcPowerLevel );
+#else
RemoveProcEntry("power_control");
-#endif
-#endif
+#endif
+#endif
+
+#endif
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq(g_pProcQueue);
+ RemoveProcEntrySeq(g_pProcVersion);
+ RemoveProcEntrySeq(g_pProcSysNodes);
+#else
RemoveProcEntry("queue");
- RemoveProcEntry("nodes");
RemoveProcEntry("version");
+ RemoveProcEntry("nodes");
+#endif
while (dir->subdir)
{
}
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void ProcSeqShowVersion(struct seq_file *sfile,void* el)
+{
+ SYS_DATA * psSysData;
+ IMG_CHAR *pszSystemVersionString = "None";
+
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+ seq_printf( sfile,
+ "Version %s (%s) %s\n",
+ PVRVERSION_STRING,
+ PVR_BUILD_TYPE, PVR_BUILD_DIR);
+ return;
+ }
+
+ SysAcquireData(&psSysData);
+
+ if(psSysData->pszVersionString)
+ {
+ pszSystemVersionString = psSysData->pszVersionString;
+ }
+
+ seq_printf( sfile, "System Version String: %s\n", pszSystemVersionString);
+}
+
+#else
+
static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off)
{
SYS_DATA *psSysData;
-
+
if (off == 0)
{
return printAppend(buf, size, 0,
PVR_BUILD_TYPE, PVR_BUILD_DIR);
}
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
+ SysAcquireData(&psSysData);
+
if (off == 1)
{
IMG_CHAR *pszSystemVersionString = "None";
{
pszSystemVersionString = psSysData->pszVersionString;
}
-
- if(strlen(pszSystemVersionString)
- + strlen("System Version String: \n")
+
+ if(strlen(pszSystemVersionString)
+ + strlen("System Version String: \n")
+ 1 > size)
{
return 0;
"System Version String: %s\n",
pszSystemVersionString);
}
-
+
return END_OF_FILE;
}
+#endif
+
static const IMG_CHAR *deviceTypeToString(PVRSRV_DEVICE_TYPE deviceType)
{
{
static IMG_CHAR text[10];
- sprintf(text, "?%x", deviceType);
+ sprintf(text, "?%x", (IMG_UINT)deviceType);
return text;
}
static const IMG_CHAR *deviceClassToString(PVRSRV_DEVICE_CLASS deviceClass)
{
- switch (deviceClass)
+ switch (deviceClass)
{
case PVRSRV_DEVICE_CLASS_3D:
{
{
static IMG_CHAR text[10];
- sprintf(text, "?%x", deviceClass);
+ sprintf(text, "?%x", (IMG_UINT)deviceClass);
return text;
}
}
}
+IMG_VOID* DecOffPsDev_AnyVaCb(PVRSRV_DEVICE_NODE *psNode, va_list va)
+{
+ off_t *pOff = va_arg(va, off_t*);
+ if (--(*pOff))
+ {
+ return IMG_NULL;
+ }
+ else
+ {
+ return psNode;
+ }
+}
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el)
+{
+ SYS_DATA * psSysData;
+ PVRSRV_DEVICE_NODE *psDevNode = (PVRSRV_DEVICE_NODE*)el;
+
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+ seq_printf( sfile,
+ "Registered nodes\n"
+ "Addr Type Class Index Ref pvDev Size Res\n");
+ return;
+ }
+
+ SysAcquireData(&psSysData);
+
+ seq_printf( sfile,
+ "%p %-8s %-8s %4d %2lu %p %3lu %p\n",
+ psDevNode,
+ deviceTypeToString(psDevNode->sDevId.eDeviceType),
+ deviceClassToString(psDevNode->sDevId.eDeviceClass),
+ psDevNode->sDevId.eDeviceClass,
+ psDevNode->ui32RefCount,
+ psDevNode->pvDevice,
+ psDevNode->ui32pvDeviceSize,
+ psDevNode->hResManContext);
+
+}
+
+static void* ProcSeqOff2ElementSysNodes(struct seq_file * sfile, loff_t off)
+{
+ SYS_DATA *psSysData;
+ PVRSRV_DEVICE_NODE *psDevNode;
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+ SysAcquireData(&psSysData);
+
+
+ psDevNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ DecOffPsDev_AnyVaCb,
+ &off);
+
+
+ return (void*)psDevNode;
+}
+
+#else
+
static
off_t procDumpSysNodes(IMG_CHAR *buf, size_t size, off_t off)
{
if (size < 80)
{
- return 0;
+ return 0;
}
if (off == 0)
{
- return printAppend(buf, size, 0,
+ return printAppend(buf, size, 0,
"Registered nodes\n"
"Addr Type Class Index Ref pvDev Size Res\n");
}
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
- {
- return PVRSRV_ERROR_GENERIC;
- }
+ SysAcquireData(&psSysData);
- for(psDevNode = psSysData->psDeviceNodeList;
- --off && psDevNode;
- psDevNode = psDevNode->psNext)
- ;
+ psDevNode = (PVRSRV_DEVICE_NODE*)
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ DecOffPsDev_AnyVaCb,
+ &off);
if (!psDevNode)
{
- return END_OF_FILE;
+ return END_OF_FILE;
}
len = printAppend(buf, size, 0,
return (len);
}
+#endif
+
#include <asm/system.h>
#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
#define END_OF_FILE (off_t) -1
typedef off_t (pvr_read_proc_t)(IMG_CHAR *, size_t, off_t);
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+#define PVR_PROC_SEQ_START_TOKEN (void*)1
+typedef void* (pvr_next_proc_seq_t)(struct seq_file *,void*,loff_t);
+typedef void* (pvr_off2element_proc_seq_t)(struct seq_file *, loff_t);
+typedef void (pvr_show_proc_seq_t)(struct seq_file *,void*);
+typedef void (pvr_startstop_proc_seq_t)(struct seq_file *, IMG_BOOL start);
+
+typedef struct _PVR_PROC_SEQ_HANDLERS_ {
+ pvr_next_proc_seq_t *next;
+ pvr_show_proc_seq_t *show;
+ pvr_off2element_proc_seq_t *off2element;
+ pvr_startstop_proc_seq_t *startstop;
+ IMG_VOID *data;
+} PVR_PROC_SEQ_HANDLERS;
+
+
+void* ProcSeq1ElementOff2Element(struct seq_file *sfile, loff_t off);
+
+void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off);
+
+
+#endif
+
off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * format, ...)
__attribute__((format(printf, 4, 5)));
IMG_VOID RemoveProcEntries(IMG_VOID);
+#ifdef PVR_PROC_USE_SEQ_FILE
+struct proc_dir_entry* CreateProcReadEntrySeq (
+ const IMG_CHAR* name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler
+ );
+
+struct proc_dir_entry* CreateProcEntrySeq (
+ const IMG_CHAR* name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler,
+ write_proc_t whandler
+ );
+
+struct proc_dir_entry* CreatePerProcessProcEntrySeq (
+ const IMG_CHAR* name,
+ IMG_VOID* data,
+ pvr_next_proc_seq_t next_handler,
+ pvr_show_proc_seq_t show_handler,
+ pvr_off2element_proc_seq_t off2element_handler,
+ pvr_startstop_proc_seq_t startstop_handler,
+ write_proc_t whandler
+ );
+
+
+IMG_VOID RemoveProcEntrySeq(struct proc_dir_entry* proc_entry);
+IMG_VOID RemovePerProcessProcEntrySeq(struct proc_dir_entry* proc_entry);
+
+#endif
+
#endif
#include "private_data.h"
#include "linkage.h"
+#if defined(SUPPORT_DRI_DRM)
+#include <drm/drmP.h>
+#endif
+
#if defined(SUPPORT_VGX)
#include "vgx_bridge.h"
#endif
#endif
+#if defined(SUPPORT_DRI_DRM)
+#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
+#else
+#define PRIVATE_DATA(pFile) ((pFile)->private_data)
+#endif
+
#if defined(DEBUG_BRIDGE_KM)
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+static struct proc_dir_entry *g_ProcBridgeStats =0;
+static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off);
+static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el);
+static void* ProcSeqOff2ElementBridgeStats(struct seq_file * sfile, loff_t off);
+static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start);
+
+#else
static off_t printLinuxBridgeStats(IMG_CHAR * buffer, size_t size, off_t off);
+#endif
+
#endif
extern PVRSRV_LINUX_MUTEX gPVRSRVLock;
+#if defined(SUPPORT_MEMINFO_IDS)
+static IMG_UINT64 ui64Stamp;
+#endif
PVRSRV_ERROR
LinuxBridgeInit(IMG_VOID)
#if defined(DEBUG_BRIDGE_KM)
{
IMG_INT iStatus;
+#ifdef PVR_PROC_USE_SEQ_FILE
+ g_ProcBridgeStats = CreateProcReadEntrySeq(
+ "bridge_stats",
+ NULL,
+ ProcSeqNextBridgeStats,
+ ProcSeqShowBridgeStats,
+ ProcSeqOff2ElementBridgeStats,
+ ProcSeqStartstopBridgeStats
+ );
+ iStatus = !g_ProcBridgeStats ? -1 : 0;
+#else
iStatus = CreateProcReadEntry("bridge_stats", printLinuxBridgeStats);
+#endif
+
if(iStatus!=0)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
LinuxBridgeDeInit(IMG_VOID)
{
#if defined(DEBUG_BRIDGE_KM)
+#ifdef PVR_PROC_USE_SEQ_FILE
+ RemoveProcEntrySeq(g_ProcBridgeStats);
+#else
RemoveProcEntry("bridge_stats");
#endif
+#endif
}
#if defined(DEBUG_BRIDGE_KM)
+
+#ifdef PVR_PROC_USE_SEQ_FILE
+
+static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start)
+{
+ if(start)
+ {
+ LinuxLockMutex(&gPVRSRVLock);
+ }
+ else
+ {
+ LinuxUnLockMutex(&gPVRSRVLock);
+ }
+}
+
+
+static void* ProcSeqOff2ElementBridgeStats(struct seq_file *sfile, loff_t off)
+{
+ if(!off)
+ {
+ return PVR_PROC_SEQ_START_TOKEN;
+ }
+
+ if(off > BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)
+ {
+ return (void*)0;
+ }
+
+
+ return (void*)&g_BridgeDispatchTable[off-1];
+}
+
+static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off)
+{
+ return ProcSeqOff2ElementBridgeStats(sfile,off);
+}
+
+
+static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el)
+{
+ PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY *psEntry = ( PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY*)el;
+
+ if(el == PVR_PROC_SEQ_START_TOKEN)
+ {
+ seq_printf(sfile,
+ "Total ioctl call count = %lu\n"
+ "Total number of bytes copied via copy_from_user = %lu\n"
+ "Total number of bytes copied via copy_to_user = %lu\n"
+ "Total number of bytes copied via copy_*_user = %lu\n\n"
+ "%-45s | %-40s | %10s | %20s | %10s\n",
+ g_BridgeGlobalStats.ui32IOCTLCount,
+ g_BridgeGlobalStats.ui32TotalCopyFromUserBytes,
+ g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
+ g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
+ "Bridge Name",
+ "Wrapper Function",
+ "Call Count",
+ "copy_from_user Bytes",
+ "copy_to_user Bytes"
+ );
+ return;
+ }
+
+ seq_printf(sfile,
+ "%-45s %-40s %-10lu %-20lu %-10lu\n",
+ psEntry->pszIOCName,
+ psEntry->pszFunctionName,
+ psEntry->ui32CallCount,
+ psEntry->ui32CopyFromUserTotalBytes,
+ psEntry->ui32CopyToUserTotalBytes);
+}
+
+#else
+
static off_t
printLinuxBridgeStats(IMG_CHAR * buffer, size_t count, off_t off)
{
return Ret;
}
#endif
+#endif
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT
+PVRSRV_BridgeDispatchKM(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile)
+#else
IMG_INT32
-PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg)
+PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT unref__ ioctlCmd, IMG_UINT32 arg)
+#endif
{
- IMG_UINT32 ui32BridgeID = PVRSRV_GET_BRIDGE_ID(cmd);
+ IMG_UINT32 cmd;
+#if !defined(SUPPORT_DRI_DRM)
PVRSRV_BRIDGE_PACKAGE *psBridgePackageUM = (PVRSRV_BRIDGE_PACKAGE *)arg;
PVRSRV_BRIDGE_PACKAGE sBridgePackageKM;
+#endif
+ PVRSRV_BRIDGE_PACKAGE *psBridgePackageKM;
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
PVRSRV_PER_PROCESS_DATA *psPerProc;
IMG_INT err = -EFAULT;
LinuxLockMutex(&gPVRSRVLock);
+#if defined(SUPPORT_DRI_DRM)
+ PVR_UNREFERENCED_PARAMETER(dev);
+
+ psBridgePackageKM = (PVRSRV_BRIDGE_PACKAGE *)arg;
+ PVR_ASSERT(psBridgePackageKM != IMG_NULL);
+#else
+ PVR_UNREFERENCED_PARAMETER(ioctlCmd);
+
+ psBridgePackageKM = &sBridgePackageKM;
if(!OSAccessOK(PVR_VERIFY_WRITE,
psBridgePackageUM,
if(OSCopyFromUser(IMG_NULL,
- &sBridgePackageKM,
+ psBridgePackageKM,
psBridgePackageUM,
sizeof(PVRSRV_BRIDGE_PACKAGE))
!= PVRSRV_OK)
{
goto unlock_and_return;
}
+#endif
-#ifdef MODULE_TEST
+ cmd = psBridgePackageKM->ui32BridgeID;
+
+#if defined(MODULE_TEST)
switch (cmd)
{
case PVRSRV_BRIDGE_SERVICES_TEST_MEM1:
{
PVRSRV_ERROR eError = MemTest1();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_MEM2:
{
PVRSRV_ERROR eError = MemTest2();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_RESOURCE:
{
PVRSRV_ERROR eError = ResourceTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_EVENTOBJECT:
{
PVRSRV_ERROR eError = EventObjectTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_MEMMAPPING:
{
PVRSRV_ERROR eError = MemMappingTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_PROCESSID:
{
PVRSRV_ERROR eError = ProcessIDTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_CLOCKUSWAITUS:
{
PVRSRV_ERROR eError = ClockusWaitusTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_TIMER:
{
PVRSRV_ERROR eError = TimerTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
case PVRSRV_BRIDGE_SERVICES_TEST_PRIVSRV:
{
PVRSRV_ERROR eError = PrivSrvTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
psPerProc = PVRSRVPerProcessData(ui32PID);
- eError = CopyDataTest(sBridgePackageKM.pvParamIn, sBridgePackageKM.pvParamOut, psPerProc);
+ eError = CopyDataTest(psBridgePackageKM->pvParamIn, psBridgePackageKM->pvParamOut, psPerProc);
- *(PVRSRV_ERROR*)sBridgePackageKM.pvParamOut = eError;
+ *(PVRSRV_ERROR*)psBridgePackageKM->pvParamOut = eError;
err = 0;
goto unlock_and_return;
}
case PVRSRV_BRIDGE_SERVICES_TEST_POWERMGMT:
{
PVRSRV_ERROR eError = PowerMgmtTest();
- if (sBridgePackageKM.ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+ if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
- PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)sBridgePackageKM.pvParamOut ;
+ PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
}
#endif
- if(ui32BridgeID != PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_CONNECT_SERVICES))
+ if(cmd != PVRSRV_BRIDGE_CONNECT_SERVICES)
{
PVRSRV_ERROR eError;
eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
(IMG_PVOID *)&psPerProc,
- sBridgePackageKM.hKernelServices,
+ psBridgePackageKM->hKernelServices,
PVRSRV_HANDLE_TYPE_PERPROC_DATA);
if(eError != PVRSRV_OK)
{
}
}
- sBridgePackageKM.ui32BridgeID = PVRSRV_GET_BRIDGE_ID(sBridgePackageKM.ui32BridgeID);
+ psBridgePackageKM->ui32BridgeID = PVRSRV_GET_BRIDGE_ID(psBridgePackageKM->ui32BridgeID);
#if defined(PVR_SECURE_FD_EXPORT)
switch(cmd)
{
case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
{
- PVRSRV_FILE_PRIVATE_DATA *psPrivateData = pFile->private_data;
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(psPrivateData->hKernelMemInfo)
{
case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
{
PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN =
- (PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)sBridgePackageKM.pvParamIn;
- PVRSRV_FILE_PRIVATE_DATA *psPrivateData = pFile->private_data;
+ (PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamIn;
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(!psPrivateData->hKernelMemInfo)
{
default:
{
- PVRSRV_FILE_PRIVATE_DATA *psPrivateData = pFile->private_data;
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(psPrivateData->hKernelMemInfo)
{
}
#endif
- err = BridgedDispatchKM(psPerProc, &sBridgePackageKM);
+ err = BridgedDispatchKM(psPerProc, psBridgePackageKM);
if(err != PVRSRV_OK)
goto unlock_and_return;
case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
{
PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT =
- (PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)sBridgePackageKM.pvParamOut;
- PVRSRV_FILE_PRIVATE_DATA *psPrivateData = pFile->private_data;
+ (PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)psBridgePackageKM->pvParamOut;
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
psPrivateData->hKernelMemInfo = psExportDeviceMemOUT->hMemInfo;
+#if defined(SUPPORT_MEMINFO_IDS)
+ psExportDeviceMemOUT->ui64Stamp = psPrivateData->ui64Stamp = ++ui64Stamp;
+#endif
break;
}
#endif
+#if defined(SUPPORT_MEMINFO_IDS)
+ case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
+ {
+ PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDeviceMemoryOUT =
+ (PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamOut;
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+ psMapDeviceMemoryOUT->sDstClientMemInfo.ui64Stamp = psPrivateData->ui64Stamp;
+ break;
+ }
+
+ case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
+ {
+ PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psDeviceClassMemoryOUT =
+ (PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *)psBridgePackageKM->pvParamOut;
+ psDeviceClassMemoryOUT->sClientMemInfo.ui64Stamp = ++ui64Stamp;
+ break;
+ }
+#endif
default:
break;
LinuxUnLockMutex(&gPVRSRVLock);
return err;
}
-
#include "mutex.h"
#include "linkage.h"
-#if defined(DEBUG) || defined(TIMING)
+#if defined(PVRSRV_NEED_PVR_DPF)
-IMG_UINT32 gPVRDebugLevel = DBGPRIV_WARNING;
+#define PVR_MAX_FILEPATH_LEN 256
+
+static IMG_UINT32 gPVRDebugLevel = DBGPRIV_WARNING;
+
+#endif
#define PVR_MAX_MSG_LEN PVR_MAX_DEBUG_MESSAGE_LEN
static PVRSRV_LINUX_MUTEX gsDebugMutexNonIRQ;
-static spinlock_t gsDebugLockIRQ = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(gsDebugLockIRQ);
#define USE_SPIN_LOCK (in_interrupt() || !preemptible())
return (i32Len < 0 || i32Len >= ui32Space);
}
+IMG_VOID PVRDPFInit(IMG_VOID)
+{
+ LinuxInitMutex(&gsDebugMutexNonIRQ);
+}
+
+IMG_VOID PVRSRVReleasePrintf(const IMG_CHAR *pszFormat, ...)
+{
+ va_list vaArgs;
+ unsigned long ulLockFlags = 0;
+ IMG_CHAR *pszBuf;
+ IMG_UINT32 ui32BufSiz;
+
+ SelectBuffer(&pszBuf, &ui32BufSiz);
+
+ va_start(vaArgs, pszFormat);
+
+ GetBufferLock(&ulLockFlags);
+ strncpy (pszBuf, "PVR_K: ", (ui32BufSiz -1));
+
+ if (VBAppend(pszBuf, ui32BufSiz, pszFormat, vaArgs))
+ {
+ printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+ }
+ else
+ {
+ printk(KERN_INFO "%s\n", pszBuf);
+ }
+
+ ReleaseBufferLock(ulLockFlags);
+ va_end(vaArgs);
+
+}
+
+#if defined(PVRSRV_NEED_PVR_ASSERT)
+
+IMG_VOID PVRSRVDebugAssertFail(const IMG_CHAR* pszFile, IMG_UINT32 uLine)
+{
+ PVRSRVDebugPrintf(DBGPRIV_FATAL, pszFile, uLine, "Debug assertion failed!");
+ BUG();
+}
+
+#endif
+
+#if defined(PVRSRV_NEED_PVR_TRACE)
+
+IMG_VOID PVRSRVTrace(const IMG_CHAR* pszFormat, ...)
+{
+ va_list VArgs;
+ unsigned long ulLockFlags = 0;
+ IMG_CHAR *pszBuf;
+ IMG_UINT32 ui32BufSiz;
+
+ SelectBuffer(&pszBuf, &ui32BufSiz);
+
+ va_start(VArgs, pszFormat);
+
+ GetBufferLock(&ulLockFlags);
+
+ strncpy(pszBuf, "PVR: ", (ui32BufSiz -1));
+
+ if (VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs))
+ {
+ printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+ }
+ else
+ {
+ printk(KERN_INFO "%s\n", pszBuf);
+ }
+
+ ReleaseBufferLock(ulLockFlags);
+
+ va_end(VArgs);
+}
+
+#endif
+
+#if defined(PVRSRV_NEED_PVR_DPF)
+
static IMG_BOOL BAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR *pszFormat, ...)
{
va_list VArgs;
IMG_VOID PVRSRVDebugPrintf (
IMG_UINT32 ui32DebugLevel,
- const IMG_CHAR* pszFileName,
+ const IMG_CHAR* pszFullFileName,
IMG_UINT32 ui32Line,
const IMG_CHAR* pszFormat,
...
)
{
IMG_BOOL bTrace, bDebug;
-#if !defined(__sh__)
- IMG_CHAR *pszLeafName;
-
- pszLeafName = (IMG_CHAR *)strrchr (pszFileName, '\\');
-
- if (pszLeafName)
- {
- pszFileName = pszLeafName;
- }
-#endif
+ const IMG_CHAR *pszFileName = pszFullFileName;
+ IMG_CHAR *pszLeafName;
bTrace = gPVRDebugLevel & ui32DebugLevel & DBGPRIV_CALLTRACE;
bDebug = ((gPVRDebugLevel & DBGPRIV_ALLLEVELS) >= ui32DebugLevel);
if (!bTrace)
{
+#ifdef DEBUG_LOG_PATH_TRUNCATE
+
+ static IMG_CHAR szFileNameRewrite[PVR_MAX_FILEPATH_LEN];
+
+ IMG_CHAR* pszTruncIter;
+ IMG_CHAR* pszTruncBackInter;
+
+
+ pszFileName = pszFullFileName + strlen(DEBUG_LOG_PATH_TRUNCATE)+1;
+
+
+ strncpy(szFileNameRewrite, pszFileName,PVR_MAX_FILEPATH_LEN);
+
+ if(strlen(szFileNameRewrite) == PVR_MAX_FILEPATH_LEN-1) {
+ IMG_CHAR szTruncateMassage[] = "FILENAME TRUNCATED";
+ strcpy(szFileNameRewrite + (PVR_MAX_FILEPATH_LEN - 1 - strlen(szTruncateMassage)), szTruncateMassage);
+ }
+
+ pszTruncIter = szFileNameRewrite;
+ while(*pszTruncIter++ != 0)
+ {
+ IMG_CHAR* pszNextStartPoint;
+
+ if(
+ !( ( *pszTruncIter == '/' && (pszTruncIter-4 >= szFileNameRewrite) ) &&
+ ( *(pszTruncIter-1) == '.') &&
+ ( *(pszTruncIter-2) == '.') &&
+ ( *(pszTruncIter-3) == '/') )
+ ) continue;
+
+
+ pszTruncBackInter = pszTruncIter - 3;
+ while(*(--pszTruncBackInter) != '/')
+ {
+ if(pszTruncBackInter <= szFileNameRewrite) break;
+ }
+ pszNextStartPoint = pszTruncBackInter;
+
+
+ while(*pszTruncIter != 0)
+ {
+ *pszTruncBackInter++ = *pszTruncIter++;
+ }
+ *pszTruncBackInter = 0;
+
+
+ pszTruncIter = pszNextStartPoint;
+ }
+
+ pszFileName = szFileNameRewrite;
+
+ if(*pszFileName == '/') pszFileName++;
+#endif
+
+#if !defined(__sh__)
+ pszLeafName = (IMG_CHAR *)strrchr (pszFileName, '\\');
+
+ if (pszLeafName)
+ {
+ pszFileName = pszLeafName;
+ }
+#endif
+
if (BAppend(pszBuf, ui32BufSiz, " [%lu, %s]", ui32Line, pszFileName))
{
printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
printk(KERN_INFO "%s\n", pszBuf);
}
}
+ else
+ {
+ printk(KERN_INFO "%s\n", pszBuf);
+ }
}
ReleaseBufferLock(ulLockFlags);
}
}
-IMG_VOID PVRSRVDebugAssertFail(const IMG_CHAR* pszFile, IMG_UINT32 uLine)
-{
- PVRSRVDebugPrintf(DBGPRIV_FATAL, pszFile, uLine, "Debug assertion failed!");
- BUG();
-}
-
-IMG_VOID PVRSRVTrace(const IMG_CHAR* pszFormat, ...)
-{
- va_list VArgs;
- unsigned long ulLockFlags = 0;
- IMG_CHAR *pszBuf;
- IMG_UINT32 ui32BufSiz;
-
- SelectBuffer(&pszBuf, &ui32BufSiz);
-
- va_start(VArgs, pszFormat);
-
- GetBufferLock(&ulLockFlags);
-
- strncpy(pszBuf, "PVR: ", (ui32BufSiz -1));
-
- if (VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs))
- {
- printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
- }
- else
- {
- printk(KERN_INFO "%s\n", pszBuf);
- }
-
- ReleaseBufferLock(ulLockFlags);
-
- va_end(VArgs);
-}
+#endif
+#if defined(DEBUG_PVR)
IMG_VOID PVRDebugSetLevel(IMG_UINT32 uDebugLevel)
{
return (count);
}
+#ifdef PVR_PROC_USE_SEQ_FILE
+void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el)
+{
+ seq_printf(sfile, "%lu\n", gPVRDebugLevel);
+}
+
+#else
IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
{
if (off == 0) {
}
#endif
-IMG_VOID
-PVRDPFInit(IMG_VOID)
-{
-#if defined(DEBUG) || defined(TIMING)
- LinuxInitMutex(&gsDebugMutexNonIRQ);
#endif
-}
-
IMG_UINT32 *pAvailableBytes);
-PVRSRV_ERROR BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
- IMG_DEV_VIRTADDR sDevVPageAddr,
+IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_DEV_VIRTADDR sDevVPageAddr,
IMG_DEV_PHYADDR *psDevPAddr);
PVRSRV_ERROR BM_GetHeapInfo(IMG_HANDLE hDevMemHeap,
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 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
+ *
+ ******************************************************************************/
+
+#ifndef __LISTS_UTILS__
+#define __LISTS_UTILS__
+
+#include <stdarg.h>
+#include "img_types.h"
+
+#define DECLARE_LIST_FOR_EACH(TYPE) \
+IMG_VOID List_##TYPE##_ForEach(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_FOR_EACH(TYPE) \
+IMG_VOID List_##TYPE##_ForEach(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode))\
+{\
+ while(psHead)\
+ {\
+ pfnCallBack(psHead);\
+ psHead = psHead->psNext;\
+ }\
+}
+
+
+#define DECLARE_LIST_FOR_EACH_VA(TYPE) \
+IMG_VOID List_##TYPE##_ForEach_va(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_FOR_EACH_VA(TYPE) \
+IMG_VOID List_##TYPE##_ForEach_va(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode, va_list va), ...) \
+{\
+ va_list ap;\
+ while(psHead)\
+ {\
+ va_start(ap, pfnCallBack);\
+ pfnCallBack(psHead, ap);\
+ psHead = psHead->psNext;\
+ va_end(ap);\
+ }\
+}
+
+
+#define DECLARE_LIST_ANY(TYPE) \
+IMG_VOID* List_##TYPE##_Any(TYPE *psHead, IMG_VOID* (*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_ANY(TYPE) \
+IMG_VOID* List_##TYPE##_Any(TYPE *psHead, IMG_VOID* (*pfnCallBack)(TYPE* psNode))\
+{ \
+ IMG_VOID *pResult;\
+ TYPE *psNextNode;\
+ pResult = IMG_NULL;\
+ psNextNode = psHead;\
+ while(psHead && !pResult)\
+ {\
+ psNextNode = psNextNode->psNext;\
+ pResult = pfnCallBack(psHead);\
+ psHead = psNextNode;\
+ }\
+ return pResult;\
+}
+
+
+#define DECLARE_LIST_ANY_VA(TYPE) \
+IMG_VOID* List_##TYPE##_Any_va(TYPE *psHead, IMG_VOID*(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_ANY_VA(TYPE) \
+IMG_VOID* List_##TYPE##_Any_va(TYPE *psHead, IMG_VOID*(*pfnCallBack)(TYPE* psNode, va_list va), ...)\
+{\
+ va_list ap;\
+ TYPE *psNextNode;\
+ IMG_VOID* pResult = IMG_NULL;\
+ while(psHead && !pResult)\
+ {\
+ psNextNode = psHead->psNext;\
+ va_start(ap, pfnCallBack);\
+ pResult = pfnCallBack(psHead, ap);\
+ va_end(ap);\
+ psHead = psNextNode;\
+ }\
+ return pResult;\
+}
+
+#define DECLARE_LIST_ANY_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any(TYPE *psHead, RTYPE (*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_ANY_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any(TYPE *psHead, RTYPE (*pfnCallBack)(TYPE* psNode))\
+{ \
+ RTYPE result;\
+ TYPE *psNextNode;\
+ result = CONTINUE;\
+ psNextNode = psHead;\
+ while(psHead && result == CONTINUE)\
+ {\
+ psNextNode = psNextNode->psNext;\
+ result = pfnCallBack(psHead);\
+ psHead = psNextNode;\
+ }\
+ return result;\
+}
+
+
+#define DECLARE_LIST_ANY_VA_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any_va(TYPE *psHead, RTYPE(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_ANY_VA_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any_va(TYPE *psHead, RTYPE(*pfnCallBack)(TYPE* psNode, va_list va), ...)\
+{\
+ va_list ap;\
+ TYPE *psNextNode;\
+ RTYPE result = CONTINUE;\
+ while(psHead && result == CONTINUE)\
+ {\
+ psNextNode = psHead->psNext;\
+ va_start(ap, pfnCallBack);\
+ result = pfnCallBack(psHead, ap);\
+ va_end(ap);\
+ psHead = psNextNode;\
+ }\
+ return result;\
+}
+
+
+#define DECLARE_LIST_REMOVE(TYPE) \
+IMG_VOID List_##TYPE##_Remove(TYPE *psNode)
+
+#define IMPLEMENT_LIST_REMOVE(TYPE) \
+IMG_VOID List_##TYPE##_Remove(TYPE *psNode)\
+{\
+ (*psNode->ppsThis)=psNode->psNext;\
+ if(psNode->psNext)\
+ {\
+ psNode->psNext->ppsThis = psNode->ppsThis;\
+ }\
+}
+
+#define DECLARE_LIST_INSERT(TYPE) \
+IMG_VOID List_##TYPE##_Insert(TYPE **ppsHead, TYPE *psNewNode)
+
+#define IMPLEMENT_LIST_INSERT(TYPE) \
+IMG_VOID List_##TYPE##_Insert(TYPE **ppsHead, TYPE *psNewNode)\
+{\
+ psNewNode->ppsThis = ppsHead;\
+ psNewNode->psNext = *ppsHead;\
+ *ppsHead = psNewNode;\
+ if(psNewNode->psNext)\
+ {\
+ psNewNode->psNext->ppsThis = &(psNewNode->psNext);\
+ }\
+}
+
+
+#define IS_LAST_ELEMENT(x) ((x)->psNext == IMG_NULL)
+
+#endif
IMG_UINT32 OSGetCurrentThreadID( IMG_VOID );
IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_SIZE_T ui32Size);
+PVRSRV_ERROR OSAllocPages_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_UINT32 ui32PageSize, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phPageAlloc);
+PVRSRV_ERROR OSFreePages(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hPageAlloc);
+
+
+#ifdef PVRSRV_LOG_MEMORY_ALLOCS
+ #define OSAllocMem(flags, size, linAddr, blockAlloc, logStr) \
+ (PVR_TRACE(("OSAllocMem(" #flags ", " #size ", " #linAddr ", " #blockAlloc "): " logStr " (size = 0x%lx)", size)), \
+ OSAllocMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__))
+
+ #define OSAllocPages(flags, size, pageSize, linAddr, pageAlloc) \
+ (PVR_TRACE(("OSAllocPages(" #flags ", " #size ", " #pageSize ", " #linAddr ", " #pageAlloc "): (size = 0x%lx)", size)), \
+ OSAllocPages_Impl(flags, size, pageSize, linAddr, pageAlloc))
+
+ #define OSFreeMem(flags, size, linAddr, blockAlloc) \
+ (PVR_TRACE(("OSFreeMem(" #flags ", " #size ", " #linAddr ", " #blockAlloc "): (pointer = 0x%X)", linAddr)), \
+ OSFreeMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__))
+#else
+ #define OSAllocMem(flags, size, linAddr, blockAlloc, logString) \
+ OSAllocMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__)
+
+ #define OSAllocPages OSAllocPages_Impl
+
+ #define OSFreeMem(flags, size, linAddr, blockAlloc) \
+ OSFreeMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__)
+#endif
+
+#ifdef PVRSRV_DEBUG_OS_MEMORY
+
+ PVRSRV_ERROR OSAllocMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+ IMG_UINT32 ui32Size,
+ IMG_PVOID *ppvCpuVAddr,
+ IMG_HANDLE *phBlockAlloc,
+ IMG_CHAR *pszFilename,
+ IMG_UINT32 ui32Line);
+
+ PVRSRV_ERROR OSFreeMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+ IMG_UINT32 ui32Size,
+ IMG_PVOID pvCpuVAddr,
+ IMG_HANDLE hBlockAlloc,
+ IMG_CHAR *pszFilename,
+ IMG_UINT32 ui32Line);
+
+
+ typedef struct
+ {
+ IMG_UINT8 sGuardRegionBefore[8];
+ IMG_CHAR sFileName[128];
+ IMG_UINT32 uLineNo;
+ IMG_SIZE_T uSize;
+ IMG_SIZE_T uSizeParityCheck;
+ enum valid_tag
+ { isFree = 0x277260FF,
+ isAllocated = 0x260511AA
+ } eValid;
+ } OSMEM_DEBUG_INFO;
+
+ #define TEST_BUFFER_PADDING_STATUS (sizeof(OSMEM_DEBUG_INFO))
+ #define TEST_BUFFER_PADDING_AFTER (8)
+ #define TEST_BUFFER_PADDING (TEST_BUFFER_PADDING_STATUS + TEST_BUFFER_PADDING_AFTER)
+#else
+ #define OSAllocMem_Debug_Wrapper OSAllocMem_Debug_Linux_Memory_Allocations
+ #define OSFreeMem_Debug_Wrapper OSFreeMem_Debug_Linux_Memory_Allocations
+#endif
+
#if defined(__linux__) && defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-PVRSRV_ERROR _OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
-#define OSAllocMem(ui32Flags, ui32Size, ppvLinAddr, phBlockAlloc) _OSAllocMem(ui32Flags, ui32Size, ppvLinAddr, phBlockAlloc, __FILE__, __LINE__)
-PVRSRV_ERROR _OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
-#define OSFreeMem(ui32Flags, ui32Size, pvLinAddr, phBlockAlloc) _OSFreeMem(ui32Flags, ui32Size, pvLinAddr, phBlockAlloc, __FILE__, __LINE__)
+ PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
+ PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
+
+ #define OSAllocMem_Debug_Linux_Memory_Allocations OSAllocMem_Impl
+ #define OSFreeMem_Debug_Linux_Memory_Allocations OSFreeMem_Impl
#else
-PVRSRV_ERROR OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc);
-PVRSRV_ERROR OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc);
+ PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc);
+ PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc);
+
+ #define OSAllocMem_Debug_Linux_Memory_Allocations(flags, size, addr, blockAlloc, file, line) \
+ OSAllocMem_Impl(flags, size, addr, blockAlloc)
+ #define OSFreeMem_Debug_Linux_Memory_Allocations(flags, size, addr, blockAlloc, file, line) \
+ OSFreeMem_Impl(flags, size, addr, blockAlloc)
#endif
-PVRSRV_ERROR OSAllocPages(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_UINT32 ui32PageSize, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phPageAlloc);
-PVRSRV_ERROR OSFreePages(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hPageAlloc);
+
+
+
#if defined(__linux__)
-IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_UINT32 ui32ByteOffset);
+IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_SIZE_T ui32ByteOffset);
#else
#ifdef INLINE_IS_PRAGMA
#pragma inline(OSMemHandleToCpuPAddr)
#endif
-static INLINE IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_HANDLE hOSMemHandle, IMG_UINT32 ui32ByteOffset)
+static INLINE IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_HANDLE hOSMemHandle, IMG_SIZE_T ui32ByteOffset)
{
IMG_CPU_PHYADDR sCpuPAddr;
PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
IMG_UINT32 ui32Value,
IMG_UINT32 ui32Mask,
PDUMP_POLL_OPERATOR eOperator,
- IMG_BOOL bLastFrame,
- IMG_BOOL bOverwrite,
+ IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag);
IMG_IMPORT PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psProcData,
PDUMP_PIXEL_FORMAT ePixelFormat,
PDUMP_MEM_FORMAT eMemFormat,
IMG_UINT32 ui32PDumpFlags);
- IMG_IMPORT IMG_VOID PDumpHWPerfCBKM(IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_DEV_VIRTADDR sDevBaseAddr,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PDumpFlags);
IMG_IMPORT PVRSRV_ERROR PDumpReadRegKM(IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Address,
IMG_UINT32 ui32Size,
IMG_UINT32 ui32PDumpFlags);
- IMG_VOID PDUMP_REG_FUNC_NAME(IMG_UINT32 dwReg,
- IMG_UINT32 dwData);
+
+ IMG_BOOL PDumpIsSuspended(IMG_VOID);
+
+#if defined(SGX_SUPPORT_COMMON_PDUMP) || !defined(SUPPORT_VGX)
+
+ PVRSRV_ERROR PDumpRegKM(IMG_UINT32 dwReg,
+ IMG_UINT32 dwData);
+ PVRSRV_ERROR PDumpComment(IMG_CHAR* pszFormat, ...);
+ PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags,
+ IMG_CHAR* pszFormat,
+ ...);
+
+ PVRSRV_ERROR PDumpPDReg(IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32dwData,
+ IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag);
+#else
+ IMG_VOID PDumpRegKM(IMG_UINT32 dwReg,
+ IMG_UINT32 dwData);
+ IMG_VOID PDumpComment(IMG_CHAR* pszFormat, ...);
+ IMG_VOID PDumpCommentWithFlags(IMG_UINT32 ui32Flags,
+ IMG_CHAR* pszFormat,
+ ...);
+
+
+ IMG_VOID PDumpPDReg(IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32dwData,
+ IMG_HANDLE hUniqueTag);
+ IMG_VOID PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag);
+#endif
IMG_VOID PDumpMsvdxRegRead(const IMG_CHAR* const pRegRegion,
const IMG_UINT32 dwRegOffset);
const IMG_UINT32 ui32VLROffset,
const IMG_UINT32 ui32Physical );
- IMG_VOID PDumpComment(IMG_CHAR* pszFormat, ...);
- IMG_VOID PDumpCommentWithFlags(IMG_UINT32 ui32Flags,
- IMG_CHAR* pszFormat,
- ...);
- PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr,
- IMG_UINT32 ui32RegValue,
- IMG_UINT32 ui32Mask);
- PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr,
- IMG_UINT32 ui32RegValue,
- IMG_UINT32 ui32Mask,
- IMG_UINT32 ui32Flags);
IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID);
IMG_IMPORT IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID);
- IMG_VOID PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_UINT32 ui32DevVAddr,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_HANDLE hOSMemHandle,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag);
IMG_VOID PDumpMallocPagesPhys(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_UINT32 ui32DevVAddr,
IMG_PUINT32 pui32PhysPages,
IMG_UINT32 ui32NumPages,
IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
PVRSRV_ERROR PDumpSetMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_CHAR *pszMemSpace,
IMG_UINT32 *pui32MMUContextID,
PVRSRV_ERROR PDumpClearMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_CHAR *pszMemSpace,
IMG_UINT32 ui32MMUContextID,
- IMG_UINT32 ui32MMUType);
- IMG_VOID PDumpFreePages(struct _BM_HEAP_ *psBMHeap,
- IMG_DEV_VIRTADDR sDevVAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag,
- IMG_BOOL bInterleaved);
- IMG_VOID PDumpFreePageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpPDReg(IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32dwData,
- IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32Data,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag);
+ IMG_UINT32 ui32MMUType);
PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
IMG_UINT32 ui32Offset,
IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame);
- IMG_VOID PDumpTASignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+
+#if defined(LINUX)
+#define COMMON_PDUMP_OS_SUPPORT
+#endif
+
+#if defined (COMMON_PDUMP_OS_SUPPORT) && !defined(SUPPORT_VGX)
+
+ PVRSRV_ERROR PDumpTASignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
IMG_UINT32 ui32TAKickCount,
IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
- IMG_VOID PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+ PVRSRV_ERROR PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
IMG_BOOL bLastFrame,
IMG_UINT32 *pui32Registers,
IMG_UINT32 ui32NumRegisters);
+ PVRSRV_ERROR PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
+
+ PVRSRV_ERROR PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32 ui32Flags);
+
+ PVRSRV_ERROR PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
+
+ PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
+ PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks);
+
+ PVRSRV_ERROR PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_UINT32 ui32DevVAddr,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpFreePages(struct _BM_HEAP_ *psBMHeap,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag,
+ IMG_BOOL bInterleaved);
+ PVRSRV_ERROR PDumpFreePageTable(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_HANDLE hUniqueTag);
+
+ IMG_IMPORT PVRSRV_ERROR PDumpHWPerfCBKM(IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags);
+
+ PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
+ IMG_UINT32 ui32ROffOffset,
+ IMG_UINT32 ui32WPosVal,
+ IMG_UINT32 ui32PacketSize,
+ IMG_UINT32 ui32BufferSize,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag);
+
+#else
+ IMG_VOID PDumpTASignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+ IMG_UINT32 ui32TAKickCount,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
+ IMG_VOID PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
+ IMG_VOID PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
+
IMG_VOID PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32 ui32Flags);
-
IMG_VOID PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
- IMG_VOID PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
+ IMG_VOID PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
+ IMG_VOID PDumpIDL(IMG_UINT32 ui32Clocks);
+
+
+ IMG_VOID PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_UINT32 ui32DevVAddr,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag);
+ IMG_VOID PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_HANDLE hUniqueTag);
+ IMG_VOID PDumpFreePages(struct _BM_HEAP_ *psBMHeap,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_HANDLE hUniqueTag,
+ IMG_BOOL bInterleaved);
+ IMG_VOID PDumpFreePageTable(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_HANDLE hUniqueTag);
+
+ IMG_IMPORT IMG_VOID PDumpHWPerfCBKM(IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags);
IMG_VOID PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
IMG_UINT32 ui32ROffOffset,
IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
- IMG_VOID PDumpIDL(IMG_UINT32 ui32Clocks);
+#endif
+
+ IMG_VOID PDumpVGXMemToFile(IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 uiAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags,
+ IMG_HANDLE hUniqueTag);
IMG_VOID PDumpSuspendKM(IMG_VOID);
IMG_VOID PDumpResumeKM(IMG_VOID);
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 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
+ *
+ ******************************************************************************/
+
+#ifndef __PDUMP_OSFUNC_H__
+#define __PDUMP_OSFUNC_H__
+
+#include <stdarg.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#define MAX_PDUMP_STRING_LENGTH (256)
+#define PDUMP_GET_SCRIPT_STRING() \
+ IMG_HANDLE hScript; \
+ IMG_UINT32 ui32MaxLen; \
+ PVRSRV_ERROR eError; \
+ eError = PDumpOSGetScriptString(&hScript, &ui32MaxLen);\
+ if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_MSG_STRING() \
+ IMG_HANDLE hMsg; \
+ IMG_UINT32 ui32MaxLen; \
+ PVRSRV_ERROR eError; \
+ eError = PDumpOSGetMessageString(&hMsg, &ui32MaxLen);\
+ if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_FILE_STRING() \
+ IMG_CHAR *pszFileName; \
+ IMG_UINT32 ui32MaxLen; \
+ PVRSRV_ERROR eError; \
+ eError = PDumpOSGetFilenameString(&pszFileName, &ui32MaxLen);\
+ if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_SCRIPT_AND_FILE_STRING() \
+ IMG_HANDLE hScript; \
+ IMG_CHAR *pszFileName; \
+ IMG_UINT32 ui32MaxLenScript; \
+ IMG_UINT32 ui32MaxLenFileName; \
+ PVRSRV_ERROR eError; \
+ eError = PDumpOSGetScriptString(&hScript, &ui32MaxLenScript);\
+ if(eError != PVRSRV_OK) return eError; \
+ eError = PDumpOSGetFilenameString(&pszFileName, &ui32MaxLenFileName);\
+ if(eError != PVRSRV_OK) return eError;
+
+
+
+ PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript, IMG_UINT32 *pui32MaxLen);
+
+
+ PVRSRV_ERROR PDumpOSGetMessageString(IMG_HANDLE *phMsg, IMG_UINT32 *pui32MaxLen);
+
+
+ PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile, IMG_UINT32 *pui32MaxLen);
+
+
+
+
+#define PDUMP_va_list va_list
+#define PDUMP_va_start va_start
+#define PDUMP_va_end va_end
+
+
+
+IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream);
+
+IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream);
+
+IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID);
+
+IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags);
+
+IMG_BOOL PDumpOSIsSuspended(IMG_VOID);
+
+IMG_BOOL PDumpOSJTInitialised(IMG_VOID);
+
+IMG_BOOL PDumpOSWriteString(IMG_HANDLE hDbgStream,
+ IMG_UINT8 *psui8Data,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32Flags);
+
+IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags);
+
+PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...);
+
+IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...);
+
+PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...);
+
+PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszMsg, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs);
+
+IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax);
+
+IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax);
+
+IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_UINT8 *pui8LinAddr,
+ IMG_UINT32 ui32PageSize,
+ IMG_DEV_PHYADDR *psDevPAddr);
+
+IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_PUINT8 pui8LinAddr,
+ IMG_UINT32 *pui32PageOffset);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif
+
PVR_POWER_STATE eDefaultPowerState;
PVR_POWER_STATE eCurrentPowerState;
struct _PVRSRV_POWER_DEV_TAG_ *psNext;
+ struct _PVRSRV_POWER_DEV_TAG_ **ppsThis;
} PVRSRV_POWER_DEV;
RESMAN_TYPE_DEVICEMEM_ALLOCATION,
RESMAN_TYPE_EVENT_OBJECT,
RESMAN_TYPE_SHARED_MEM_INFO,
+ RESMAN_TYPE_MODIFY_SYNC_OPS,
RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION
git.openpandora.org / sgx.git / commitdiff