From: Grazvydas Ignotas Date: Wed, 9 May 2012 23:53:30 +0000 (+0300) Subject: merge common and linux layers from 1.5.15.2766 X-Git-Url: http://git.openpandora.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=49cbcc3668af558dcdcfe28e696e0b512ad64166;p=sgx.git merge common and linux layers from 1.5.15.2766 --- diff --git a/Kbuild b/Kbuild index 81043c1..9b8debf 100644 --- a/Kbuild +++ b/Kbuild @@ -12,6 +12,7 @@ services4/srvkm/common/resman.c \ 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 \ diff --git a/services4/include/pvr_bridge_km.h b/services4/include/pvr_bridge_km.h index ead1085..24439f9 100644 --- a/services4/include/pvr_bridge_km.h +++ b/services4/include/pvr_bridge_km.h @@ -85,7 +85,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfoKM(IMG_HANDLE hDevCookie, 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, @@ -94,6 +94,17 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie, 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); diff --git a/services4/include/servicesint.h b/services4/include/servicesint.h index c8ebd15..b7cbc28 100644 --- a/services4/include/servicesint.h +++ b/services4/include/servicesint.h @@ -63,6 +63,19 @@ typedef struct _PVRSRV_KERNEL_MEM_INFO_ 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; @@ -84,6 +97,9 @@ typedef struct _PVRSRV_KERNEL_SYNC_INFO_ PVRSRV_KERNEL_MEM_INFO *psSyncDataMemInfoKM; + + IMG_HANDLE hResItem; + } PVRSRV_KERNEL_SYNC_INFO; typedef struct _PVRSRV_DEVICE_SYNC_OBJECT_ diff --git a/services4/srvkm/bridged/bridged_pvr_bridge.c b/services4/srvkm/bridged/bridged_pvr_bridge.c index 0a92f26..2ffd682 100644 --- a/services4/srvkm/bridged/bridged_pvr_bridge.c +++ b/services4/srvkm/bridged/bridged_pvr_bridge.c @@ -441,7 +441,8 @@ PVRSRVAllocDeviceMemBW(IMG_UINT32 ui32BridgeID, psAllocDeviceMemIN->ui32Attribs, psAllocDeviceMemIN->ui32Size, psAllocDeviceMemIN->ui32Alignment, - &psMemInfo); + &psMemInfo, + "" ); if(psAllocDeviceMemOUT->eError != PVRSRV_OK) { @@ -981,7 +982,8 @@ PVRSRVWrapExtMemoryBW(IMG_UINT32 ui32BridgeID, 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, @@ -1573,7 +1575,8 @@ PVRSRVGetMiscInfoBW(IMG_UINT32 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); diff --git a/services4/srvkm/bridged/sgx/bridged_sgx_bridge.c b/services4/srvkm/bridged/sgx/bridged_sgx_bridge.c index ff78232..3df9c42 100644 --- a/services4/srvkm/bridged/sgx/bridged_sgx_bridge.c +++ b/services4/srvkm/bridged/sgx/bridged_sgx_bridge.c @@ -629,7 +629,8 @@ SGXGetMiscInfoBW(IMG_UINT32 ui32BridgeID, OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, allocatedSize, &pAllocated, - &hAllocatedHandle)); + &hAllocatedHandle, + "Array of Hardware Performance Circular Buffer Data")); psTmpUserData = sMiscInfo.uData.sRetrieveCB.psHWPerfData; @@ -754,7 +755,8 @@ SGXReadHWPerfCBBW(IMG_UINT32 ui32BridgeID, OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, ui32AllocatedSize, (IMG_VOID **)&psAllocated, - &hAllocatedHandle)); + &hAllocatedHandle, + "Array of Hardware Performance Circular Buffer Data")); psSGXReadHWPerfCBOUT->eError = SGXReadHWPerfCBKM(hDevCookieInt, psSGXReadHWPerfCBIN->ui32ArraySize, @@ -1616,7 +1618,8 @@ SGXAddSharedPBDescBW(IMG_UINT32 ui32BridgeID, 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; @@ -1636,7 +1639,8 @@ SGXAddSharedPBDescBW(IMG_UINT32 ui32BridgeID, 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; @@ -1926,7 +1930,8 @@ SGXPDumpBufferArrayBW(IMG_UINT32 ui32BridgeID, 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; } @@ -2008,7 +2013,8 @@ SGXPDump3DSignatureRegistersBW(IMG_UINT32 ui32BridgeID, 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; @@ -2061,7 +2067,8 @@ SGXPDumpCounterRegistersBW(IMG_UINT32 ui32BridgeID, 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; @@ -2115,7 +2122,8 @@ SGXPDumpTASignatureRegistersBW(IMG_UINT32 ui32BridgeID, 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; diff --git a/services4/srvkm/common/buffer_manager.c b/services4/srvkm/common/buffer_manager.c index 0ac347a..cefad6f 100644 --- a/services4/srvkm/common/buffer_manager.c +++ b/services4/srvkm/common/buffer_manager.c @@ -33,8 +33,25 @@ #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 @@ -189,7 +206,8 @@ AllocMemory (BM_CONTEXT *pBMContext, 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; @@ -243,7 +261,7 @@ AllocMemory (BM_CONTEXT *pBMContext, 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, @@ -253,7 +271,7 @@ WrapMemory (BM_HEAP *psBMHeap, 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)", @@ -261,7 +279,7 @@ WrapMemory (BM_HEAP *psBMHeap, 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); @@ -269,7 +287,8 @@ WrapMemory (BM_HEAP *psBMHeap, 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; @@ -358,7 +377,7 @@ WrapMemory (BM_HEAP *psBMHeap, pMapping, IMG_NULL, uFlags | PVRSRV_MEM_READ | PVRSRV_MEM_WRITE, - ui32PageSize, + IMG_CAST_TO_DEVVADDR_UINT(ui32PageSize), &DevVAddr); if (!bResult) { @@ -390,7 +409,7 @@ WrapMemory (BM_HEAP *psBMHeap, { 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) { @@ -442,13 +461,14 @@ fail_cleanup: } 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; @@ -478,8 +498,8 @@ ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_UINT32 ui32Bytes, IMG_UINT32 ui3 } else { - IMG_UINT32 ui32BytesRemaining = ui32Bytes; - IMG_UINT32 ui32CurrentOffset = 0; + IMG_SIZE_T ui32BytesRemaining = ui32Bytes; + IMG_SIZE_T ui32CurrentOffset = 0; IMG_CPU_PHYADDR CpuPAddr; @@ -487,7 +507,7 @@ ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_UINT32 ui32Bytes, IMG_UINT32 ui3 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)) @@ -545,6 +565,7 @@ FreeBuf (BM_BUF *pBuf, IMG_UINT32 ui32Flags) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL); + pBuf->pMapping = IMG_NULL; } } else @@ -585,12 +606,32 @@ FreeBuf (BM_BUF *pBuf, IMG_UINT32 ui32Flags) 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 @@ -599,7 +640,6 @@ BM_DestroyContext(IMG_HANDLE hBMContext, { PVRSRV_ERROR eError; BM_CONTEXT *pBMContext = (BM_CONTEXT*)hBMContext; - BM_HEAP *psBMHeap; PVR_DPF ((PVR_DBG_MESSAGE, "BM_DestroyContext")); @@ -627,38 +667,72 @@ BM_DestroyContext(IMG_HANDLE hBMContext, - 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; } @@ -668,10 +742,7 @@ static PVRSRV_ERROR BM_DestroyContextCallBack(IMG_PVOID pvParam, IMG_UINT32 ui32Param) { BM_CONTEXT *pBMContext = pvParam; - BM_CONTEXT **ppBMContext; - BM_HEAP *psBMHeap, *psTmpBMHeap; PVRSRV_DEVICE_NODE *psDeviceNode; - PVR_UNREFERENCED_PARAMETER(ui32Param); @@ -680,38 +751,12 @@ static PVRSRV_ERROR BM_DestroyContextCallBack(IMG_PVOID pvParam, - 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) @@ -734,26 +779,47 @@ static PVRSRV_ERROR BM_DestroyContextCallBack(IMG_PVOID pvParam, 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, @@ -761,7 +827,6 @@ BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_BOOL *pbCreated) { BM_CONTEXT *pBMContext; - BM_HEAP *psBMHeap; DEVICE_MEMORY_INFO *psDevMemoryInfo; IMG_BOOL bKernelContext; PRESMAN_CONTEXT hResManContext; @@ -789,24 +854,20 @@ BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode, 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; @@ -865,26 +926,13 @@ BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode, - 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); } @@ -909,12 +957,27 @@ BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode, 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) @@ -937,24 +1000,21 @@ BM_CreateHeap (IMG_HANDLE hBMContext, 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; @@ -1012,8 +1072,7 @@ BM_CreateHeap (IMG_HANDLE hBMContext, } - psBMHeap->psNext = pBMContext->psBMHeap; - pBMContext->psBMHeap = psBMHeap; + List_BM_HEAP_Insert(&pBMContext->psBMHeap, psBMHeap); return (IMG_HANDLE)psBMHeap; @@ -1028,7 +1087,8 @@ ErrorExit: } - OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, 0, psBMHeap, IMG_NULL); + OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL); + return IMG_NULL; } @@ -1042,9 +1102,7 @@ BM_DestroyHeap (IMG_HANDLE hDevMemHeap) PVR_DPF((PVR_DBG_MESSAGE, "BM_DestroyHeap")); if(psBMHeap) - { - BM_HEAP **ppsBMHeap; - + { if(psBMHeap->ui32Attribs & (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG @@ -1065,22 +1123,14 @@ BM_DestroyHeap (IMG_HANDLE hDevMemHeap) 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")); } } @@ -1123,10 +1173,7 @@ BM_Alloc ( IMG_HANDLE hDevMemHeap, "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; @@ -1139,7 +1186,8 @@ BM_Alloc ( IMG_HANDLE hDevMemHeap, 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; @@ -1156,6 +1204,7 @@ BM_Alloc ( IMG_HANDLE hDevMemHeap, 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; } @@ -1169,6 +1218,13 @@ BM_Alloc ( IMG_HANDLE hDevMemHeap, *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; } @@ -1176,7 +1232,7 @@ BM_Alloc ( IMG_HANDLE hDevMemHeap, #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; @@ -1202,7 +1258,7 @@ ValidSysPAddrArrayForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR *psSy } 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; @@ -1230,8 +1286,8 @@ ValidSysPAddrRangeForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR sStar 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, @@ -1250,15 +1306,17 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, 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) @@ -1271,7 +1329,7 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, } else { - IMG_UINT32 ui32HostPageSize = HOST_PAGESIZE(); + IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE(); if (!ValidSysPAddrArrayForDev(psBMContext->psDeviceNode, psSysAddr, WRAP_PAGE_COUNT(ui32Size, ui32Offset, ui32HostPageSize), ui32HostPageSize)) { @@ -1291,7 +1349,7 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, 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 || @@ -1313,7 +1371,8 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, 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; @@ -1325,6 +1384,7 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, { PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: WrapMemory FAILED")); OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL); + return IMG_FALSE; } @@ -1337,7 +1397,6 @@ BM_Wrap ( IMG_HANDLE hDevMemHeap, 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; } @@ -1377,8 +1436,7 @@ BM_Free (BM_HANDLE hBuf, return; } - if(SysAcquireData (&psSysData) != PVRSRV_OK) - return; + SysAcquireData(&psSysData); pBuf->ui32RefCount--; @@ -1608,12 +1666,12 @@ DevMemoryFree (BM_MAPPING *pMapping) 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 @@ -1650,7 +1708,8 @@ BM_ImportMemory (IMG_VOID *pH, 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; @@ -1684,12 +1743,21 @@ BM_ImportMemory (IMG_VOID *pH, 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", @@ -1703,6 +1771,14 @@ BM_ImportMemory (IMG_VOID *pH, 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); @@ -1724,7 +1800,7 @@ BM_ImportMemory (IMG_VOID *pH, pMapping->CpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr); if(OSReservePhys(pMapping->CpuPAddr, uPSize, - pBMHeap->ui32Attribs, + ui32Attribs, &pMapping->CpuVAddr, &pMapping->hOSMemHandle) != PVRSRV_OK) { @@ -1808,6 +1884,7 @@ fail_dev_mem_alloc: } fail_mapping_alloc: OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL); + fail_exit: return IMG_FALSE; } @@ -1872,13 +1949,14 @@ BM_FreeMemory (IMG_VOID *h, IMG_UINTPTR_T _base, BM_MAPPING *psMapping) } 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) { @@ -1886,11 +1964,7 @@ PVRSRV_ERROR BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo, 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); @@ -1899,8 +1973,6 @@ PVRSRV_ERROR BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo, *psDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pMMUHeap, sDevVPageAddr); - - return PVRSRV_OK; } diff --git a/services4/srvkm/common/deviceclass.c b/services4/srvkm/common/deviceclass.c index 4ba18b7..de0f7f5 100644 --- a/services4/srvkm/common/deviceclass.c +++ b/services4/srvkm/common/deviceclass.c @@ -29,10 +29,22 @@ #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 @@ -124,38 +136,45 @@ static PVRSRV_BUFFERCLASS_INFO* BCDeviceHandleToBCInfo (IMG_HANDLE hDeviceKM) 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) { @@ -193,11 +212,7 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, - if (SysAcquireData(&psSysData) != PVRSRV_OK) - { - PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed to get SysData")); - return PVRSRV_ERROR_GENERIC; - } + SysAcquireData(&psSysData); @@ -206,7 +221,8 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, 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; @@ -216,7 +232,8 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, 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; @@ -229,7 +246,8 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, 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; @@ -244,7 +262,11 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, 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) { @@ -255,8 +277,7 @@ PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable, SysRegisterExternalDevice(psDeviceNode); - psDeviceNode->psNext = psSysData->psDeviceNodeList; - psSysData->psDeviceNodeList = psDeviceNode; + List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode); return PVRSRV_OK; @@ -265,54 +286,37 @@ ErrorExit: 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; @@ -323,8 +327,8 @@ FoundDevice: { - *ppsDeviceNode = psDeviceNode->psNext; - + List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode); + SysRemoveExternalDevice(psDeviceNode); @@ -332,10 +336,13 @@ FoundDevice: 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 { @@ -367,11 +374,7 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl - if (SysAcquireData(&psSysData) != PVRSRV_OK) - { - PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to get SysData")); - return PVRSRV_ERROR_GENERIC; - } + SysAcquireData(&psSysData); @@ -379,7 +382,8 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl 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; @@ -389,7 +393,8 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl 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; @@ -402,7 +407,8 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl 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; @@ -417,7 +423,11 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl 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) { @@ -425,8 +435,7 @@ PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTabl } - psDeviceNode->psNext = psSysData->psDeviceNodeList; - psSysData->psDeviceNodeList = psDeviceNode; + List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode); return PVRSRV_OK; @@ -435,9 +444,11 @@ ErrorExit: 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; } @@ -446,44 +457,26 @@ ErrorExit: 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; @@ -494,16 +487,20 @@ FoundDevice: { - *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 { @@ -558,6 +555,7 @@ static PVRSRV_ERROR CloseDCDeviceCallBack(IMG_PVOID pvParam, } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO), psDCPerContextInfo, IMG_NULL); + return PVRSRV_OK; } @@ -573,6 +571,7 @@ PVRSRV_ERROR PVRSRVOpenDCDeviceKM (PVRSRV_PER_PROCESS_DATA *psPerProc, PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo; PVRSRV_DEVICE_NODE *psDeviceNode; SYS_DATA *psSysData; + PVRSRV_ERROR eError; if(!phDeviceKM || !hDevCookie) { @@ -580,39 +579,29 @@ PVRSRV_ERROR PVRSRVOpenDCDeviceKM (PVRSRV_PER_PROCESS_DATA *psPerProc, 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; @@ -621,7 +610,6 @@ FoundDevice: if(psDCInfo->ui32RefCount++ == 0) { - PVRSRV_ERROR eError; psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie; @@ -830,6 +818,7 @@ static PVRSRV_ERROR DestroyDCSwapChainCallBack(IMG_PVOID pvParam, IMG_UINT32 ui3 } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL); + return eError; } @@ -882,7 +871,8 @@ PVRSRV_ERROR PVRSRVCreateDCSwapChainKM (PVRSRV_PER_PROCESS_DATA *psPerProc, 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; @@ -976,6 +966,7 @@ ErrorExit: if(psSwapChain) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL); + } return eError; @@ -1232,7 +1223,7 @@ PVRSRV_ERROR PVRSRVSwapToDCBufferKM(IMG_HANDLE hDeviceKM, 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")); @@ -1353,6 +1344,7 @@ PVRSRV_ERROR PVRSRVSwapToDCSystemKM(IMG_HANDLE hDeviceKM, { goto ProcessedQueues; } + OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT); } END_LOOP_UNTIL_TIMEOUT(); @@ -1384,22 +1376,14 @@ PVRSRV_ERROR PVRSRVRegisterSystemISRHandler (PFN_ISR_HANDLER pfnISRHandler, 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) { @@ -1417,32 +1401,32 @@ PVRSRV_ERROR PVRSRVRegisterSystemISRHandler (PFN_ISR_HANDLER pfnISRHandler, 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); } @@ -1455,10 +1439,14 @@ IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable) 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; } @@ -1514,10 +1502,12 @@ static PVRSRV_ERROR CloseBCDeviceCallBack(IMG_PVOID pvParam, 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; } @@ -1542,40 +1532,29 @@ PVRSRV_ERROR PVRSRVOpenBCDeviceKM (PVRSRV_PER_PROCESS_DATA *psPerProc, 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; @@ -1615,7 +1594,8 @@ FoundDevice: 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")); @@ -1684,6 +1664,7 @@ ErrorExit: if(psBCInfo->psBuffer) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER), psBCInfo->psBuffer, IMG_NULL); + psBCInfo->psBuffer = IMG_NULL; } return eError; diff --git a/services4/srvkm/common/devicemem.c b/services4/srvkm/common/devicemem.c index fa50292..911985e 100644 --- a/services4/srvkm/common/devicemem.c +++ b/services4/srvkm/common/devicemem.c @@ -34,8 +34,8 @@ 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_ @@ -49,8 +49,7 @@ 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; @@ -289,8 +288,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfoKM(IMG_HANDLE hDevCookie 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; @@ -305,7 +304,8 @@ static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE hDevCookie, 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); @@ -322,13 +322,14 @@ static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE hDevCookie, 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; } @@ -376,9 +377,11 @@ static PVRSRV_ERROR FreeDeviceMem(PVRSRV_KERNEL_MEM_INFO *psMemInfo) { 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); } @@ -398,7 +401,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE hDevCookie, 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")); @@ -427,6 +431,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE hDevCookie, 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; } @@ -446,7 +451,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE hDevCookie, psKernelSyncInfo->psSyncDataMemInfoKM, 0, psKernelSyncInfo->psSyncDataMemInfoKM->ui32AllocSize, - 0, + PDUMP_FLAGS_CONTINUOUS, MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM)); #endif @@ -457,6 +462,9 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE hDevCookie, psKernelSyncInfo->psSyncDataMemInfoKM->psKernelSyncInfo = IMG_NULL; + psKernelSyncInfo->hResItem = IMG_NULL; + + *ppsKernelSyncInfo = psKernelSyncInfo; return PVRSRV_OK; @@ -466,10 +474,13 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE hDevCookie, 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; } @@ -538,7 +549,7 @@ IMG_EXPORT 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); @@ -554,7 +565,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie, else { - FreeDeviceMemCallBack(psMemInfo, 0); + eError = FreeDeviceMemCallBack(psMemInfo, 0); } return eError; @@ -562,12 +573,12 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie, 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; @@ -581,6 +592,16 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMemKM(IMG_HANDLE hDevCookie, 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, @@ -673,9 +694,9 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVDissociateDeviceMemKM(IMG_HANDLE hD 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) { @@ -722,6 +743,7 @@ static PVRSRV_ERROR UnwrapExtMemoryCallBack(IMG_PVOID pvParam, 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) @@ -745,8 +767,8 @@ IMG_EXPORT 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, @@ -754,8 +776,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE hDevCookie, { 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; @@ -766,7 +788,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE hDevCookie, 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; @@ -781,16 +803,17 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE 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; @@ -848,7 +871,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE hDevCookie, 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; @@ -936,6 +960,7 @@ ErrorExitPhase3: if(psMemInfo) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL); + } ErrorExitPhase2: @@ -948,6 +973,7 @@ ErrorExitPhase1: if(psIntSysPAddr) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageCount * sizeof(IMG_SYS_PHYADDR), psIntSysPAddr, IMG_NULL); + } return eError; @@ -977,6 +1003,7 @@ static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam, 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); @@ -989,7 +1016,32 @@ static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam, 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; } @@ -1003,8 +1055,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer { 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; @@ -1029,7 +1081,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer 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); @@ -1037,7 +1089,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer 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; @@ -1049,27 +1102,23 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer 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; isDevId.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; @@ -1079,7 +1128,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer 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; @@ -1087,6 +1137,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPer } OSMemSet(psMemInfo, 0, sizeof(*psMemInfo)); + psMemInfo->ui32Flags = psSrcMemInfo->ui32Flags; psMemBlock = &(psMemInfo->sMemBlk); @@ -1154,18 +1205,21 @@ ErrorExit: { 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; @@ -1212,9 +1266,9 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA * 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; @@ -1288,12 +1342,13 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA * } - 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); @@ -1316,6 +1371,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA * { 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; } diff --git a/services4/srvkm/common/handle.c b/services4/srvkm/common/handle.c index 385747d..054a6bd 100644 --- a/services4/srvkm/common/handle.c +++ b/services4/srvkm/common/handle.c @@ -30,7 +30,7 @@ #include "services_headers.h" #include "handle.h" -#ifdef DEBUG +#ifdef DEBUG_PVR #define HANDLE_BLOCK_SIZE 1 #else #define HANDLE_BLOCK_SIZE 256 @@ -49,7 +49,7 @@ #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)) @@ -223,7 +223,7 @@ IMG_BOOL HandleListIsEmpty(IMG_UINT32 ui32Index, struct sHandleList *psList) bIsEmpty = (IMG_BOOL)(psList->ui32Next == ui32Index); -#ifdef DEBUG +#ifdef DEBUG_PVR { IMG_BOOL bIsEmpty2; @@ -235,7 +235,7 @@ IMG_BOOL HandleListIsEmpty(IMG_UINT32 ui32Index, struct sHandleList *psList) return bIsEmpty; } -#ifdef DEBUG +#ifdef DEBUG_PVR #ifdef INLINE_IS_PRAGMA #pragma inline(NoChildren) #endif @@ -284,6 +284,7 @@ IMG_HANDLE ParentHandle(struct sHandle *psHandle) 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); @@ -306,7 +307,7 @@ IMG_VOID AdoptChild(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, struct { 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); @@ -320,6 +321,7 @@ IMG_VOID HandleListRemove(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32EntryIndex, { 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); @@ -357,6 +359,7 @@ PVRSRV_ERROR HandleListIterate(PVRSRV_HANDLE_BASE *psBase, struct sHandleList *p 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; @@ -501,6 +504,7 @@ static PVRSRV_ERROR FreeHandle(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHan if (BATCHED_HANDLE(psHandle) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle)) { + SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle); return PVRSRV_OK; @@ -651,7 +655,8 @@ static PVRSRV_ERROR ReallocMem(IMG_PVOID *ppvMem, IMG_HANDLE *phBlockAlloc, IMG_ 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)); @@ -896,10 +901,14 @@ static PVRSRV_ERROR AllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle 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)) { @@ -908,6 +917,7 @@ static PVRSRV_ERROR AllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle psBase->ui32FirstBatchIndexPlusOne = ui32NewIndex + 1; + SET_BATCHED_HANDLE(psNewHandle); } else @@ -1277,7 +1287,7 @@ static PVRSRV_ERROR PVRSRVHandleBatchCommitOrRelease(PVRSRV_HANDLE_BASE *psBase, if (!BATCHED_HANDLE_PARTIALLY_FREE(psHandle)) { - SET_UNBATCHED_HANDLE(psHandle); + SET_UNBATCHED_HANDLE(psHandle); } eError = FreeHandle(psBase, psHandle); @@ -1289,13 +1299,13 @@ static PVRSRV_ERROR PVRSRVHandleBatchCommitOrRelease(PVRSRV_HANDLE_BASE *psBase, } 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; @@ -1341,7 +1351,7 @@ PVRSRV_ERROR PVRSRVSetMaxHandle(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32MaxHa } - 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)); @@ -1446,7 +1456,8 @@ PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase) 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)); diff --git a/services4/srvkm/common/hash.c b/services4/srvkm/common/hash.c index 3f1f14c..5868639 100644 --- a/services4/srvkm/common/hash.c +++ b/services4/srvkm/common/hash.c @@ -48,7 +48,7 @@ struct _BUCKET_ IMG_UINTPTR_T v; - IMG_UINTPTR_T k[]; + IMG_UINTPTR_T k[]; }; typedef struct _BUCKET_ BUCKET; @@ -141,7 +141,7 @@ _ChainInsert (HASH_TABLE *pHash, BUCKET *pBucket, BUCKET **ppBucketTable, IMG_UI 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; @@ -184,9 +184,10 @@ _Resize (HASH_TABLE *pHash, IMG_UINT32 uNewSize) "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; @@ -198,7 +199,8 @@ _Resize (HASH_TABLE *pHash, IMG_UINT32 uNewSize) 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; } @@ -215,7 +217,8 @@ HASH_TABLE * HASH_Create_Extended (IMG_UINT32 uInitialLen, IMG_SIZE_T uKeySize, 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; } @@ -227,13 +230,15 @@ HASH_TABLE * HASH_Create_Extended (IMG_UINT32 uInitialLen, IMG_SIZE_T uKeySize, 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; } @@ -256,8 +261,15 @@ HASH_Delete (HASH_TABLE *pHash) 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); + } } @@ -279,12 +291,14 @@ HASH_Insert_Extended (HASH_TABLE *pHash, IMG_VOID *pKey, IMG_UINTPTR_T v) 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) { @@ -320,13 +334,13 @@ HASH_Remove_Extended(HASH_TABLE *pHash, IMG_VOID *pKey) 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; } @@ -334,6 +348,7 @@ HASH_Remove_Extended(HASH_TABLE *pHash, IMG_VOID *pKey) for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext)) { + if (KEY_COMPARE(pHash, (*ppBucket)->k, pKey)) { BUCKET *pBucket = *ppBucket; @@ -341,6 +356,7 @@ HASH_Remove_Extended(HASH_TABLE *pHash, IMG_VOID *pKey) (*ppBucket) = pBucket->pNext; OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET) + pHash->uKeySize, pBucket, IMG_NULL); + pHash->uCount--; @@ -380,13 +396,13 @@ HASH_Retrieve_Extended (HASH_TABLE *pHash, IMG_VOID *pKey) 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; } @@ -394,6 +410,7 @@ HASH_Retrieve_Extended (HASH_TABLE *pHash, IMG_VOID *pKey) for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext)) { + if (KEY_COMPARE(pHash, (*ppBucket)->k, pKey)) { BUCKET *pBucket = *ppBucket; diff --git a/services4/srvkm/common/lists.c b/services4/srvkm/common/lists.c new file mode 100644 index 0000000..58389bf --- /dev/null +++ b/services4/srvkm/common/lists.c @@ -0,0 +1,99 @@ +/********************************************************************** + * + * 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. + * 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; + } +} diff --git a/services4/srvkm/common/mem.c b/services4/srvkm/common/mem.c index a566518..870b9bc 100644 --- a/services4/srvkm/common/mem.c +++ b/services4/srvkm/common/mem.c @@ -25,15 +25,6 @@ ******************************************************************************/ #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" @@ -54,6 +45,7 @@ FreeSharedSysMemCallBack(IMG_PVOID pvParam, sizeof(PVRSRV_KERNEL_MEM_INFO), psKernelMemInfo, IMG_NULL); + return PVRSRV_OK; } @@ -62,14 +54,15 @@ FreeSharedSysMemCallBack(IMG_PVOID pvParam, 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; diff --git a/services4/srvkm/common/mem_debug.c b/services4/srvkm/common/mem_debug.c new file mode 100644 index 0000000..cbe9912 --- /dev/null +++ b/services4/srvkm/common/mem_debug.c @@ -0,0 +1,250 @@ +/********************************************************************** + * + * 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. + * 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 diff --git a/services4/srvkm/common/metrics.c b/services4/srvkm/common/metrics.c index ee5cabd..89b98b0 100644 --- a/services4/srvkm/common/metrics.c +++ b/services4/srvkm/common/metrics.c @@ -35,7 +35,7 @@ #include "sgxapi_km.h" #endif -#if defined(DEBUG) || defined(TIMING) +#if defined(DEBUG_PVR) || defined(TIMING) static volatile IMG_UINT32 *pui32TimerRegister = 0; diff --git a/services4/srvkm/common/pdump_common.c b/services4/srvkm/common/pdump_common.c index 8dc3798..c34dbec 100644 --- a/services4/srvkm/common/pdump_common.c +++ b/services4/srvkm/common/pdump_common.c @@ -25,79 +25,1506 @@ ******************************************************************************/ #if defined(PDUMP) +#include + #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, @@ -147,7 +1574,7 @@ PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc, PVRSRV_ERROR eError; IMG_UINT32 ui32BytesToDump = MIN(PDUMP_TEMP_BUFFER_SIZE, ui32Bytes - ui32BytesDumped); - eError = OSCopyFromUser(psPerProc, + eError = OSCopyFromUser(psPerProc, pvAddrKM, pvAddrUM, ui32BytesToDump); @@ -181,7 +1608,7 @@ PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc, } return PVRSRV_OK; -} +} static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID) @@ -191,17 +1618,17 @@ static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID) for(i=0; ihBlockAlloc); + if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't free per-process data (%d)", eError)); @@ -134,7 +135,8 @@ PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32 ui32PID) 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)); diff --git a/services4/srvkm/common/power.c b/services4/srvkm/common/power.c index 9bfa624..0f8c0f1 100644 --- a/services4/srvkm/common/power.c +++ b/services4/srvkm/common/power.c @@ -575,7 +575,8 @@ PVRSRV_ERROR PVRSRVRegisterPowerDevice(IMG_UINT32 ui32DeviceIndex, 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")); diff --git a/services4/srvkm/common/pvrsrv.c b/services4/srvkm/common/pvrsrv.c index 768413f..7b9b465 100644 --- a/services4/srvkm/common/pvrsrv.c +++ b/services4/srvkm/common/pvrsrv.c @@ -223,7 +223,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVInit(PSYS_DATA psSysData) 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; @@ -291,7 +292,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData, 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); diff --git a/services4/srvkm/common/queue.c b/services4/srvkm/common/queue.c index ffc2cdb..5b6fdeb 100644 --- a/services4/srvkm/common/queue.c +++ b/services4/srvkm/common/queue.c @@ -26,7 +26,12 @@ #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 @@ -34,13 +39,13 @@ QueuePrintCommands (PVRSRV_QUEUE_INFO * psQueue, IMG_CHAR * buffer, size_t size) { 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, @@ -63,14 +68,78 @@ QueuePrintCommands (PVRSRV_QUEUE_INFO * psQueue, IMG_CHAR * buffer, size_t size) } + +#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 \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, @@ -79,7 +148,7 @@ QueuePrintQueues (IMG_CHAR * buffer, size_t size, off_t off) - 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; @@ -97,9 +166,83 @@ QueuePrintQueues (IMG_CHAR * buffer, size_t size, off_t off) #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; @@ -116,25 +259,22 @@ IMG_UINT32 NearestPower2(IMG_UINT32 ui32Value) 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; @@ -147,7 +287,8 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_UINT32 ui32QueueSize, 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; @@ -201,12 +342,14 @@ 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; @@ -221,11 +364,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueue PVRSRV_ERROR eError; IMG_BOOL bTimeout = IMG_TRUE; - eError = SysAcquireData(&psSysData); - if (eError != PVRSRV_OK) - { - return eError; - } + SysAcquireData(&psSysData); psQueue = psSysData->psQueueList; @@ -235,7 +374,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueue { bTimeout = IMG_FALSE; break; - } + } OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT); } END_LOOP_UNTIL_TIMEOUT(); @@ -260,13 +399,16 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueue 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 { @@ -280,10 +422,13 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueue 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; @@ -326,7 +471,7 @@ ErrorExit: 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; @@ -345,7 +490,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVGetQueueSpaceKM(PVRSRV_QUEUE_INFO *psQueue, if (GET_SPACE_IN_CMDQ(psQueue) > ui32ParamSize) { bTimeout = IMG_FALSE; - break; + break; } OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT); } END_LOOP_UNTIL_TIMEOUT(); @@ -358,7 +503,7 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVGetQueueSpaceKM(PVRSRV_QUEUE_INFO *psQueue, } else { - *ppvSpace = (IMG_VOID *)(psQueue->ui32WriteOffset + (IMG_UINT32)psQueue->pvLinQueueUM); + *ppvSpace = (IMG_VOID *)((IMG_UINTPTR_T)psQueue->pvLinQueueUM + psQueue->ui32WriteOffset); } return PVRSRV_OK; @@ -374,15 +519,15 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO *psQueue, 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) @@ -406,13 +551,13 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO *psQueue, 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; @@ -422,6 +567,12 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO *psQueue, 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)); } @@ -430,6 +581,12 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO *psQueue, 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)); } @@ -448,18 +605,18 @@ PVRSRV_ERROR IMG_CALLCONV PVRSRVSubmitCommandKM(PVRSRV_QUEUE_INFO *psQueue, 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))); @@ -566,6 +723,12 @@ PVRSRV_ERROR PVRSRVProcessCommand(SYS_DATA *psSysData, for (i=0; iui32DstSyncCount; 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)); } @@ -573,6 +736,12 @@ PVRSRV_ERROR PVRSRVProcessCommand(SYS_DATA *psSysData, for (i=0; iui32SrcSyncCount; 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)); } @@ -600,6 +769,15 @@ PVRSRV_ERROR PVRSRVProcessCommand(SYS_DATA *psSysData, } +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) @@ -607,14 +785,9 @@ PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32 ui32CallerID, 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; @@ -664,7 +837,7 @@ PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32 ui32CallerID, { 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) { @@ -688,16 +861,9 @@ PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32 ui32CallerID, } - 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); @@ -713,27 +879,37 @@ PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32 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; iui32DstSyncCount; 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; iui32SrcSyncCount; 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)); } @@ -753,27 +929,23 @@ IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie, IMG_BOOL bScheduleMISR) } -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 @@ -785,7 +957,7 @@ PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex, SYS_DATA *psSysData; PVRSRV_ERROR eError; IMG_UINT32 i; - IMG_UINT32 ui32AllocSize; + IMG_SIZE_T ui32AllocSize; PFN_CMD_PROC *ppfnCmdProc; COMMAND_COMPLETE_DATA *psCmdCompleteData; @@ -799,17 +971,13 @@ PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex, } - 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")); @@ -829,7 +997,8 @@ PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex, 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")); @@ -848,7 +1017,8 @@ PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex, 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)); @@ -862,11 +1032,13 @@ PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex, 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; @@ -881,16 +1053,24 @@ ErrorExit: { 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; @@ -902,7 +1082,6 @@ PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32 ui32DevIndex, IMG_UINT32 ui32CmdCount) { SYS_DATA *psSysData; - PVRSRV_ERROR eError; IMG_UINT32 i; @@ -915,12 +1094,7 @@ PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32 ui32DevIndex, } - 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) { @@ -934,18 +1108,30 @@ PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32 ui32DevIndex, 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; diff --git a/services4/srvkm/common/ra.c b/services4/srvkm/common/ra.c index 8278abd..e38ee48 100644 --- a/services4/srvkm/common/ra.c +++ b/services4/srvkm/common/ra.c @@ -276,7 +276,8 @@ _SegmentSplit (RA_ARENA *pArena, BT *pBT, IMG_SIZE_T uSize) 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; } @@ -330,7 +331,8 @@ _BuildSpanMarker (IMG_UINTPTR_T base, IMG_SIZE_T uSize) 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; } @@ -350,7 +352,8 @@ _BuildBT (IMG_UINTPTR_T base, IMG_SIZE_T uSize) 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; } @@ -739,7 +742,8 @@ RA_Create (IMG_CHAR *name, 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; } diff --git a/services4/srvkm/common/resman.c b/services4/srvkm/common/resman.c index cf3c207..ab22f59 100644 --- a/services4/srvkm/common/resman.c +++ b/services4/srvkm/common/resman.c @@ -72,7 +72,7 @@ static DECLARE_MUTEX(lock); typedef struct _RESMAN_ITEM_ { -#ifdef DEBUG +#ifdef DEBUG_PVR IMG_UINT32 ui32Signature; #endif struct _RESMAN_ITEM_ **ppsThis; @@ -90,7 +90,7 @@ typedef struct _RESMAN_ITEM_ typedef struct _RESMAN_CONTEXT_ { -#ifdef DEBUG +#ifdef DEBUG_PVR IMG_UINT32 ui32Signature; #endif struct _RESMAN_CONTEXT_ **ppsThis; @@ -112,6 +112,16 @@ typedef struct 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) @@ -125,7 +135,7 @@ static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psContext, IMG_BOOL bExecuteCallback); -#ifdef DEBUG +#ifdef DEBUG_PVR static IMG_VOID ValidateResList(PRESMAN_LIST psResList); #define VALIDATERESLIST() ValidateResList(gpsResList) #else @@ -144,7 +154,8 @@ PVRSRV_ERROR ResManInit(IMG_VOID) 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; } @@ -166,6 +177,7 @@ IMG_VOID ResManDeInit(IMG_VOID) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*gpsResList), gpsResList, IMG_NULL); + gpsResList = IMG_NULL; } } @@ -184,7 +196,8 @@ PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE hPerProc, 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")); @@ -198,20 +211,14 @@ PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE hPerProc, 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(); @@ -246,6 +253,9 @@ IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext, 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); @@ -277,14 +287,11 @@ IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext, 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); + @@ -330,7 +337,8 @@ PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT psResManContext, 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")); @@ -342,7 +350,7 @@ PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT psResManContext, } -#ifdef DEBUG +#ifdef DEBUG_PVR psNewResItem->ui32Signature = RESMAN_SIGNATURE; #endif psNewResItem->ui32ResType = ui32ResType; @@ -352,13 +360,7 @@ PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT psResManContext, 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(); @@ -452,27 +454,18 @@ PVRSRV_ERROR ResManDissociateRes(RESMAN_ITEM *psResItem, 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 { @@ -487,11 +480,20 @@ PVRSRV_ERROR ResManDissociateRes(RESMAN_ITEM *psResItem, 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); @@ -503,7 +505,7 @@ IMG_INTERNAL PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT psResManContex return PVRSRV_ERROR_INVALID_PARAMS; } -#ifdef DEBUG +#ifdef DEBUG_PVR PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE); #endif @@ -522,28 +524,21 @@ IMG_INTERNAL PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT psResManContex 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, @@ -559,7 +554,7 @@ static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, return PVRSRV_ERROR_INVALID_PARAMS; } -#ifdef DEBUG +#ifdef DEBUG_PVR PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE); #endif @@ -574,11 +569,8 @@ static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, psItem->pfnFreeResource, psItem->ui32Flags)); - if (psItem->psNext) - { - psItem->psNext->ppsThis = psItem->ppsThis; - } - *psItem->ppsThis = psItem->psNext; + List_RESMAN_ITEM_Remove(psItem); + RELEASE_SYNC_OBJ; @@ -606,6 +598,40 @@ static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, 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, @@ -615,65 +641,27 @@ static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psResManContext, 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; diff --git a/services4/srvkm/devices/sgx/mmu.c b/services4/srvkm/devices/sgx/mmu.c index cd35220..6f68121 100644 --- a/services4/srvkm/devices/sgx/mmu.c +++ b/services4/srvkm/devices/sgx/mmu.c @@ -421,7 +421,8 @@ _DeferredAllocPagetables(MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR DevVAddr, IMG_UINT { 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")); @@ -613,7 +614,8 @@ MMU_Initialise (PVRSRV_DEVICE_NODE *psDeviceNode, MMU_CONTEXT **ppsMMUContext, I 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")); @@ -1211,7 +1213,8 @@ MMU_Create (MMU_CONTEXT *psMMUContext, 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")); diff --git a/services4/srvkm/devices/sgx/pb.c b/services4/srvkm/devices/sgx/pb.c index 7b91abd..d342334 100644 --- a/services4/srvkm/devices/sgx/pb.c +++ b/services4/srvkm/devices/sgx/pb.c @@ -80,7 +80,8 @@ SGXFindSharedPBDescKM(PVRSRV_PER_PROCESS_DATA *psPerProc, 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")); @@ -331,7 +332,8 @@ SGXAddSharedPBDescKM(PVRSRV_PER_PROCESS_DATA *psPerProc, 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")); @@ -346,7 +348,8 @@ SGXAddSharedPBDescKM(PVRSRV_PER_PROCESS_DATA *psPerProc, 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 " diff --git a/services4/srvkm/devices/sgx/sgxinit.c b/services4/srvkm/devices/sgx/sgxinit.c index 7b23933..a391e20 100644 --- a/services4/srvkm/devices/sgx/sgxinit.c +++ b/services4/srvkm/devices/sgx/sgxinit.c @@ -137,7 +137,8 @@ static PVRSRV_ERROR InitDevInfo(PVRSRV_PER_PROCESS_DATA *psPerProc, eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_SGX_CCB_INFO), - (IMG_VOID **)&psKernelCCBInfo, 0); + (IMG_VOID **)&psKernelCCBInfo, 0, + "SGX Circular Command Buffer Info"); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"InitDevInfo: Failed to alloc memory")); @@ -369,7 +370,8 @@ static PVRSRV_ERROR DevInitSGXPart1 (IMG_VOID *pvDeviceNode) if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_SGXDEV_INFO), - (IMG_VOID **)&psDevInfo, IMG_NULL) != PVRSRV_OK) + (IMG_VOID **)&psDevInfo, IMG_NULL, + "SGX Device Info") != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart1 : Failed to alloc memory for DevInfo")); return (PVRSRV_ERROR_OUT_OF_MEMORY); @@ -1010,7 +1012,8 @@ PVRSRV_ERROR SGXRegisterDevice (PVRSRV_DEVICE_NODE *psDeviceNode) if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP, sizeof(DEVICE_MEMORY_HEAP_INFO) * psDevMemoryInfo->ui32HeapCount, - (IMG_VOID **)&psDevMemoryInfo->psDeviceMemoryHeap, 0) != PVRSRV_OK) + (IMG_VOID **)&psDevMemoryInfo->psDeviceMemoryHeap, 0, + "Array of Device Memory Heap Info") != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"SGXRegisterDevice : Failed to alloc memory for DEVICE_MEMORY_HEAP_INFO")); return (PVRSRV_ERROR_OUT_OF_MEMORY); diff --git a/services4/srvkm/devices/sgx/sgxutils.c b/services4/srvkm/devices/sgx/sgxutils.c index c09cf44..9043a62 100644 --- a/services4/srvkm/devices/sgx/sgxutils.c +++ b/services4/srvkm/devices/sgx/sgxutils.c @@ -599,7 +599,8 @@ IMG_HANDLE SGXRegisterHWRenderContextKM(IMG_HANDLE psDeviceNode, 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) { @@ -668,7 +669,8 @@ IMG_HANDLE SGXRegisterHWTransferContextKM(IMG_HANDLE psDeviceNode, 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) { @@ -762,7 +764,8 @@ IMG_HANDLE SGXRegisterHW2DContextKM(IMG_HANDLE psDeviceNode, 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) { diff --git a/services4/srvkm/env/linux/env_data.h b/services4/srvkm/env/linux/env_data.h index 2d7d30b..3d41219 100644 --- a/services4/srvkm/env/linux/env_data.h +++ b/services4/srvkm/env/linux/env_data.h @@ -30,6 +30,10 @@ #include #include +#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE) +#include +#endif + #define PVRSRV_MAX_BRIDGE_IN_SIZE 0x1000 #define PVRSRV_MAX_BRIDGE_OUT_SIZE 0x1000 @@ -48,7 +52,15 @@ typedef struct _ENV_DATA_TAG 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 diff --git a/services4/srvkm/env/linux/env_perproc.h b/services4/srvkm/env/linux/env_perproc.h index 40404f5..eac8445 100644 --- a/services4/srvkm/env/linux/env_perproc.h +++ b/services4/srvkm/env/linux/env_perproc.h @@ -46,5 +46,7 @@ IMG_VOID LinuxMMapPerProcessDisconnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc PVRSRV_ERROR LinuxMMapPerProcessHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase); +IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID); + #endif diff --git a/services4/srvkm/env/linux/event.c b/services4/srvkm/env/linux/event.c index a10f874..5f12659 100644 --- a/services4/srvkm/env/linux/event.c +++ b/services4/srvkm/env/linux/event.c @@ -71,7 +71,7 @@ typedef struct PVRSRV_LINUX_EVENT_OBJECT_TAG { atomic_t sTimeStamp; IMG_UINT32 ui32TimeStampPrevious; -#if defined(DEBUG) +#if defined(DEBUG_PVR) IMG_UINT ui32Stats; #endif wait_queue_head_t sWait; @@ -85,7 +85,8 @@ PVRSRV_ERROR LinuxEventObjectListCreate(IMG_HANDLE *phEventObjectList) 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; @@ -113,6 +114,7 @@ PVRSRV_ERROR LinuxEventObjectListDestroy(IMG_HANDLE hEventObjectList) return PVRSRV_ERROR_GENERIC; } OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), psEvenObjectList, IMG_NULL); + } return PVRSRV_OK; } @@ -125,7 +127,7 @@ PVRSRV_ERROR LinuxEventObjectDelete(IMG_HANDLE hOSEventObjectList, IMG_HANDLE hO 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) @@ -151,11 +153,12 @@ static PVRSRV_ERROR LinuxEventObjectDeleteCallback(IMG_PVOID pvParam, IMG_UINT32 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; } @@ -175,7 +178,8 @@ PVRSRV_ERROR LinuxEventObjectAdd(IMG_HANDLE hOSEventObjectList, IMG_HANDLE *phOS 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; @@ -186,7 +190,7 @@ PVRSRV_ERROR LinuxEventObjectAdd(IMG_HANDLE hOSEventObjectList, IMG_HANDLE *phOS atomic_set(&psLinuxEventObject->sTimeStamp, 0); psLinuxEventObject->ui32TimeStampPrevious = 0; -#if defined(DEBUG) +#if defined(DEBUG_PVR) psLinuxEventObject->ui32Stats = 0; #endif init_waitqueue_head(&psLinuxEventObject->sWait); @@ -252,7 +256,7 @@ PVRSRV_ERROR LinuxEventObjectWait(IMG_HANDLE hOSEventObject, IMG_UINT32 ui32MSTi ui32TimeOutJiffies = (IMG_UINT32)schedule_timeout((IMG_INT32)ui32TimeOutJiffies); LinuxLockMutex(&gPVRSRVLock); -#if defined(DEBUG) +#if defined(DEBUG_PVR) psLinuxEventObject->ui32Stats++; #endif diff --git a/services4/srvkm/env/linux/kbuild/Makefile b/services4/srvkm/env/linux/kbuild/Makefile index 7001d9e..751f88e 100644 --- a/services4/srvkm/env/linux/kbuild/Makefile +++ b/services4/srvkm/env/linux/kbuild/Makefile @@ -23,13 +23,20 @@ # # -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 \ @@ -70,7 +77,9 @@ SOURCES += $(KBUILDROOT)/srvkm/common/buffer_manager.c \ $(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 @@ -119,7 +128,17 @@ endif # SUPPORT_SGX 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) @@ -127,3 +146,5 @@ INCLUDES += -I$(EURASIAROOT)/moduletests/include SOURCES += $(KBUILDROOT)/../moduletests/services_test/kern_test.c SYS_CFLAGS += -DMODULE_TEST endif + +include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common diff --git a/services4/srvkm/env/linux/linkage.h b/services4/srvkm/env/linux/linkage.h index 5c0bb0e..8962c09 100644 --- a/services4/srvkm/env/linux/linkage.h +++ b/services4/srvkm/env/linux/linkage.h @@ -27,17 +27,32 @@ #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 diff --git a/services4/srvkm/env/linux/mm.c b/services4/srvkm/env/linux/mm.c index 179dd48..c943436 100644 --- a/services4/srvkm/env/linux/mm.c +++ b/services4/srvkm/env/linux/mm.c @@ -53,6 +53,10 @@ #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, @@ -77,8 +81,16 @@ typedef struct _DEBUG_MEM_ALLOC_REC 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]; @@ -103,7 +115,17 @@ static IMG_VOID DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE eAllocType, IMG_V 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 @@ -115,8 +137,17 @@ typedef struct _DEBUG_LINUX_MEM_AREA_REC 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 @@ -126,7 +157,24 @@ static IMG_UINT32 g_LinuxMemAreaCount; 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; @@ -155,7 +203,19 @@ LinuxMMInit(IMG_VOID) #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; @@ -167,7 +227,20 @@ LinuxMMInit(IMG_VOID) #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; @@ -185,6 +258,66 @@ LinuxMMInit(IMG_VOID) 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) @@ -192,82 +325,37 @@ 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 @@ -297,6 +385,9 @@ _KMallocWrapper(IMG_UINT32 ui32ByteSize, IMG_CHAR *pszFileName, IMG_UINT32 ui32L ui32Line ); } +#else + PVR_UNREFERENCED_PARAMETER(pszFileName); + PVR_UNREFERENCED_PARAMETER(ui32Line); #endif return pvRet; } @@ -307,6 +398,9 @@ _KFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line) { #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); } @@ -339,8 +433,7 @@ DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE eAllocType, 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]) @@ -373,53 +466,61 @@ DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE 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); } @@ -485,6 +586,9 @@ _VMallocWrapper(IMG_UINT32 ui32Bytes, ui32Line ); } +#else + PVR_UNREFERENCED_PARAMETER(pszFileName); + PVR_UNREFERENCED_PARAMETER(ui32Line); #endif return pvRet; @@ -496,6 +600,9 @@ _VFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line) { #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); } @@ -612,7 +719,7 @@ _IORemapWrapper(IMG_CPU_PHYADDR BasePAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line) { - IMG_VOID *pvIORemapCookie = IMG_NULL; + IMG_VOID *pvIORemapCookie; switch(ui32MappingFlags & PVRSRV_HAP_CACHETYPE_MASK) { @@ -643,6 +750,9 @@ _IORemapWrapper(IMG_CPU_PHYADDR BasePAddr, ui32Line ); } +#else + PVR_UNREFERENCED_PARAMETER(pszFileName); + PVR_UNREFERENCED_PARAMETER(ui32Line); #endif return pvIORemapCookie; @@ -654,6 +764,9 @@ _IOUnmapWrapper(IMG_VOID *pvIORemapCookie, IMG_CHAR *pszFileName, IMG_UINT32 ui3 { #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); } @@ -712,19 +825,37 @@ FreeIORemapLinuxMemArea(LinuxMemArea *psLinuxMemArea) 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; + } } } @@ -743,7 +874,7 @@ LinuxMemArea *NewExternalKVLinuxMemArea(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *p 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) { @@ -855,13 +986,14 @@ NewAllocPagesLinuxMemArea(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags) } 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 KERNEL_VERSION(2,6,0)) SetPageReserved(pvPageList[i]); #else - mem_map_reserve(pvPageList[i]); + mem_map_reserve(pvPageList[i]); #endif #endif @@ -911,6 +1043,7 @@ failed_alloc_pages: __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: @@ -926,7 +1059,7 @@ FreeAllocPagesLinuxMemArea(LinuxMemArea *psLinuxMemArea) 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); @@ -943,19 +1076,20 @@ FreeAllocPagesLinuxMemArea(LinuxMemArea *psLinuxMemArea) DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, pvPageList, __FILE__, __LINE__); #endif - for(i=0;i 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); } @@ -973,20 +1107,21 @@ LinuxMemAreaOffsetToPage(LinuxMemArea *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; } } @@ -1021,7 +1156,7 @@ _KMemCacheAllocWrapper(LinuxKMemCache *psCache, #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) @@ -1040,6 +1175,9 @@ _KMemCacheAllocWrapper(LinuxKMemCache *psCache, pszFileName, ui32Line ); +#else + PVR_UNREFERENCED_PARAMETER(pszFileName); + PVR_UNREFERENCED_PARAMETER(ui32Line); #endif return pvRet; @@ -1051,6 +1189,9 @@ _KMemCacheFreeWrapper(LinuxKMemCache *psCache, IMG_VOID *pvObject, IMG_CHAR *psz { #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); @@ -1060,6 +1201,8 @@ _KMemCacheFreeWrapper(LinuxKMemCache *psCache, IMG_VOID *pvObject, IMG_CHAR *psz const IMG_CHAR * KMemCacheNameWrapper(LinuxKMemCache *psCache) { + PVR_UNREFERENCED_PARAMETER(psCache); + return ""; } @@ -1165,6 +1308,7 @@ LinuxMemAreaDeepFree(LinuxMemArea *psLinuxMemArea) default: PVR_DPF((PVR_DBG_ERROR, "%s: Unknown are type (%d)\n", __FUNCTION__, psLinuxMemArea->eAreaType)); + break; } } @@ -1196,8 +1340,8 @@ DebugLinuxMemAreaRecordAdd(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Flags) 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 { @@ -1222,24 +1366,34 @@ DebugLinuxMemAreaRecordAdd(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Flags) } + +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; @@ -1249,7 +1403,7 @@ exit_unlock: static IMG_VOID DebugLinuxMemAreaRecordRemove(LinuxMemArea *psLinuxMemArea) { - DEBUG_LINUX_MEM_AREA_REC **ppsCurrentRecord; + DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord; LinuxLockMutex(&g_sDebugMutex); @@ -1260,25 +1414,21 @@ DebugLinuxMemAreaRecordRemove(LinuxMemArea *psLinuxMemArea) 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 @@ -1298,7 +1448,7 @@ LinuxMemAreaToCpuVAddr(LinuxMemArea *psLinuxMemArea) case LINUX_MEM_AREA_SUB_ALLOC: { IMG_CHAR *pAddr = - LinuxMemAreaToCpuVAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea); + LinuxMemAreaToCpuVAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea); if(!pAddr) { return NULL; @@ -1378,7 +1528,8 @@ LinuxMemAreaToCpuPAddr(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32ByteOffset) default: PVR_DPF((PVR_DBG_ERROR, "%s: Unknown LinuxMemArea type (%d)\n", __FUNCTION__, psLinuxMemArea->eAreaType)); - } + break; + } PVR_ASSERT(CpuPAddr.uiAddr); return CpuPAddr; @@ -1402,6 +1553,7 @@ LinuxMemAreaPhysIsContig(LinuxMemArea *psLinuxMemArea) return IMG_FALSE; case LINUX_MEM_AREA_SUB_ALLOC: + return LinuxMemAreaPhysIsContig(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea); default: @@ -1439,7 +1591,133 @@ LinuxMemAreaTypeToString(LINUX_MEM_AREA_TYPE eMemAreaType) } +#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, + "\n" + "\t%lu\n" + "\t\n" + "\t\n" + "\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 + "\n" + "\t%8p\n" + "\t%s\n" + "\t%8p\n" + "\t%08lx\n" + "\t%ld\n" + "\t%u\n" + "\t%08lx\n" + "\t%s\n" + "\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) { @@ -1488,8 +1766,11 @@ 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; @@ -1533,8 +1814,256 @@ unlock_and_return: } #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, "\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, "\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, "\n\n"); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]); + seq_printf( sfile, + "\n", + g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]); + seq_printf( sfile, + "\n", + g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]); + seq_printf( sfile,"\n" ); + + seq_printf( sfile, + "\n", + g_SysRAMWaterMark); + seq_printf( sfile, + "\n", + g_SysRAMHighWaterMark); + seq_printf( sfile, + "\n", + g_IOMemWaterMark); + seq_printf( sfile, + "\n", + g_IOMemHighWaterMark); + + seq_printf( sfile, "\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 + "\n" + "\t%s\n" + "\t%-8p\n" + "\t%08lx\n" + "\t%ld\n" + "\t%d\n" + "\t%s\n" + "\t%s\n" + "\t%ld\n" + "\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 + "\n" + "\t%s\n" + "\t%-8p\n" + "\t%08lx\n" + "\t%ld\n" + "\t%d\n" + "\t%s\n" + "\t%s\n" + "\t%ld\n" + "\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) { @@ -1684,8 +2213,10 @@ 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) @@ -1757,6 +2288,7 @@ unlock_and_return: return Ret; } #endif +#endif #if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MMAP_AREAS) @@ -1827,4 +2359,3 @@ HAPFlagsToString(IMG_UINT32 ui32Flags) } #endif - diff --git a/services4/srvkm/env/linux/mm.h b/services4/srvkm/env/linux/mm.h index 7d2da4e..25e140d 100644 --- a/services4/srvkm/env/linux/mm.h +++ b/services4/srvkm/env/linux/mm.h @@ -323,7 +323,7 @@ LinuxMemAreaRootType(LinuxMemArea *psLinuxMemArea) 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 diff --git a/services4/srvkm/env/linux/mmap.c b/services4/srvkm/env/linux/mmap.c index 774d5ea..2b82b06 100644 --- a/services4/srvkm/env/linux/mmap.c +++ b/services4/srvkm/env/linux/mmap.c @@ -44,6 +44,9 @@ #include #include #endif +#if defined(SUPPORT_DRI_DRM) +#include +#endif #include "img_defs.h" #include "services.h" @@ -60,6 +63,9 @@ #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" @@ -75,23 +81,30 @@ static IMG_UINT32 g_ui32RegisteredAreas = 0; 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 @@ -141,9 +154,11 @@ CreateOffsetStruct(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Offset, IMG_UINT 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); @@ -233,7 +248,7 @@ PVRMMapOSMemHandleToMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc, LinuxMemArea *psLinuxMemArea; PKV_OFFSET_STRUCT psOffsetStruct; IMG_HANDLE hOSMemHandle; - PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC; + PVRSRV_ERROR eError; LinuxLockMutex(&g_sMMapMutex); @@ -259,7 +274,7 @@ PVRMMapOSMemHandleToMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc, if (psPerProc->ui32PID == psOffsetStruct->ui32PID) { - PVR_ASSERT(*pui32RealByteSize == psOffsetStruct->ui32RealByteSize); + PVR_ASSERT(*pui32RealByteSize == psOffsetStruct->ui32RealByteSize); *pui32MMapOffset = psOffsetStruct->ui32MMapOffset; *pui32UserVAddr = psOffsetStruct->ui32UserVAddr; @@ -267,7 +282,7 @@ PVRMMapOSMemHandleToMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc, eError = PVRSRV_OK; goto exit_unlock; - } + } } @@ -317,7 +332,7 @@ PVRMMapReleaseMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc, 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); @@ -348,7 +363,7 @@ PVRMMapReleaseMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc, 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; @@ -378,7 +393,7 @@ FindOffsetStructByOffset(IMG_UINT32 ui32Offset, IMG_UINT32 ui32RealByteSize) 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) @@ -401,7 +416,7 @@ DoMapToUser(LinuxMemArea *psLinuxMemArea, if (psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC) { - return DoMapToUser(LinuxMemAreaRoot(psLinuxMemArea), + return DoMapToUser(LinuxMemAreaRoot(psLinuxMemArea), ps_vma, psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset + ui32ByteOffset); } @@ -568,8 +583,8 @@ MMapVClose(struct vm_area_struct* ps_vma) static struct vm_operations_struct MMapIOOps = { - open: MMapVOpen, - close: MMapVClose + .open=MMapVOpen, + .close=MMapVClose }; @@ -577,7 +592,7 @@ int 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); @@ -592,27 +607,36 @@ PVRMMap(struct file* pFile, struct vm_area_struct* ps_vma) 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)); @@ -676,6 +700,125 @@ unlock_and_return: #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 + "\n" + "\t%lu\n" + "\t%lu\n" + "\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 + "\n" + "\t%-8p\n" + "\t%-8lx\n" + "\t%-8p\n" + "\t%08lx\n" + "\t%08lx\n" + "\t%-8ld\n" + "\t%-24s\n" + "\t%-5lu\n" + "\t%-8s\n" + "\t%08lx\n" + "\t%s\n" + "\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) { @@ -722,7 +865,7 @@ 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) @@ -775,22 +918,25 @@ unlock_and_return: 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); @@ -828,7 +974,7 @@ exit_unlock: PVRSRV_ERROR PVRMMapRemoveRegisteredArea(LinuxMemArea *psLinuxMemArea) { - PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC; + PVRSRV_ERROR eError; PKV_OFFSET_STRUCT psOffsetStruct, psTmpOffsetStruct; LinuxLockMutex(&g_sMMapMutex); @@ -915,7 +1061,7 @@ LinuxMMapPerProcessDisconnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc) 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) @@ -941,9 +1087,17 @@ PVRMMapInit(IMG_VOID) } #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: @@ -964,7 +1118,7 @@ PVRMMapCleanup(IMG_VOID) 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) @@ -978,7 +1132,13 @@ PVRMMapCleanup(IMG_VOID) } 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) { diff --git a/services4/srvkm/env/linux/module.c b/services4/srvkm/env/linux/module.c index b7ddda3..7d77f49 100644 --- a/services4/srvkm/env/linux/module.c +++ b/services4/srvkm/env/linux/module.c @@ -28,6 +28,19 @@ #include #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 #include #include @@ -35,15 +48,19 @@ #include #include -#if defined(LDM_PLATFORM) +#if defined(SUPPORT_DRI_DRM) +#include +#endif + +#if defined(PVR_LDM_PLATFORM_MODULE) #include #endif -#if defined(LDM_PCI) +#if defined(PVR_LDM_PCI_MODULE) #include #endif -#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL) +#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) #include #endif @@ -74,9 +91,14 @@ #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 @@ -90,54 +112,55 @@ MODULE_PARM_DESC(debug, "Sets the level of debug output (default=0x4)"); 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 @@ -145,7 +168,7 @@ static IMG_INT PVRSRVDriverSuspend(LDM_DEV *device, pm_message_t state); 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 } @@ -155,20 +178,20 @@ MODULE_DEVICE_TABLE(pci, powervr_id_table); #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, @@ -178,22 +201,27 @@ static LDM_DRV powervr_driver = { 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 { @@ -223,10 +251,10 @@ static IMG_INT __devinit PVRSRVDriverProbe(LDM_DEV *pDevice, const struct pci_de } -#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 { @@ -236,10 +264,10 @@ static IMG_VOID __devexit PVRSRVDriverRemove(LDM_DEV *pDevice) 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; } @@ -257,10 +285,10 @@ static IMG_VOID __devexit PVRSRVDriverRemove(LDM_DEV *pDevice) } #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 } @@ -270,16 +298,23 @@ static IMG_VOID PVRSRVDriverShutdown(LDM_DEV *pDevice) { 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; } @@ -288,30 +323,26 @@ static IMG_INT PVRSRVDriverSuspend(LDM_DEV *pDevice, pm_message_t state) } +#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]; @@ -332,14 +363,14 @@ IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT { 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; } @@ -351,6 +382,13 @@ IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT 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) { @@ -360,9 +398,15 @@ IMG_INT PVRProcGetPowerLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_IN *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; @@ -370,6 +414,12 @@ static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile) 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(); @@ -380,7 +430,8 @@ static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile) 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; @@ -390,8 +441,7 @@ static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile) #endif psPrivateData->ui32OpenPID = ui32PID; psPrivateData->hBlockAlloc = hBlockAlloc; - pFile->private_data = psPrivateData; - + PRIVATE_DATA(pFile) = psPrivateData; iRet = 0; err_unlock: LinuxUnLockMutex(&gPVRSRVLock); @@ -399,43 +449,61 @@ err_unlock: } +#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 @@ -457,9 +525,9 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) 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)); @@ -467,6 +535,7 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) goto init_failed; } +#if defined(MODULE) if ((error = platform_device_register(&powervr_device)) != 0) { platform_driver_unregister(&powervr_driver); @@ -475,9 +544,10 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) 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)); @@ -501,14 +571,8 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) 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) @@ -516,12 +580,13 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) 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"); @@ -547,24 +612,24 @@ static IMG_INT __init PVRCore_Init(IMG_VOID) 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 @@ -591,7 +656,11 @@ init_failed: } +#if defined(SUPPORT_DRI_DRM) +IMG_VOID PVRCore_Cleanup(IMG_VOID) +#else static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID) +#endif { SYS_DATA *psSysData; @@ -599,15 +668,16 @@ static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID) 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 @@ -616,23 +686,26 @@ static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID) 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; } @@ -651,11 +724,9 @@ static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID) 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 diff --git a/services4/srvkm/env/linux/mutex.c b/services4/srvkm/env/linux/mutex.c index 1ff98b8..d66e697 100644 --- a/services4/srvkm/env/linux/mutex.c +++ b/services4/srvkm/env/linux/mutex.c @@ -56,7 +56,9 @@ PVRSRV_ERROR LinuxLockMutexInterruptible(PVRSRV_LINUX_MUTEX *psPVRSRVMutex) if(mutex_lock_interruptible(psPVRSRVMutex) == -EINTR) { return PVRSRV_ERROR_GENERIC; - }else{ + } + else + { return PVRSRV_OK; } } @@ -73,7 +75,7 @@ IMG_VOID LinuxUnLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex) IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex) { - return mutex_is_locked(psPVRSRVMutex); + return (IMG_BOOL)mutex_is_locked(psPVRSRVMutex); } diff --git a/services4/srvkm/env/linux/mutils.c b/services4/srvkm/env/linux/mutils.c index 9abff78..83eab51 100644 --- a/services4/srvkm/env/linux/mutils.c +++ b/services4/srvkm/env/linux/mutils.c @@ -1,132 +1,133 @@ -/********************************************************************** - * - * 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. - * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK - * - ******************************************************************************/ - -#ifndef AUTOCONF_INCLUDED -#include -#endif -#include - -#include -#include -/* Compilation Error */ -/*#include */ - -#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 1 -#define PAT_X86_BIT_PCD 2 -#define PAT_X86_BIT_PAT 4 -#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 (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 -} - +/********************************************************************** + * + * 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. + * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK + * + ******************************************************************************/ + +#ifndef AUTOCONF_INCLUDED +#include +#endif +#include + +#include +#include +#include +#include + +#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 +} + diff --git a/services4/srvkm/env/linux/osfunc.c b/services4/srvkm/env/linux/osfunc.c index b96a6b7..ab7d7a9 100644 --- a/services4/srvkm/env/linux/osfunc.c +++ b/services4/srvkm/env/linux/osfunc.c @@ -34,6 +34,9 @@ #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)) #include #endif +#if defined(SUPPORT_CPU_CACHED_BUFFERS) +#include +#endif #include #include #include @@ -50,6 +53,9 @@ #include #include #include +#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE) +#include +#endif #include "img_types.h" #include "services_headers.h" @@ -67,9 +73,9 @@ #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); @@ -81,32 +87,32 @@ PVRSRV_ERROR _OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *p #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; @@ -114,9 +120,9 @@ PVRSRV_ERROR _OSAllocMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *p #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); @@ -125,15 +131,15 @@ PVRSRV_ERROR _OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvC 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 @@ -144,13 +150,13 @@ PVRSRV_ERROR _OSFreeMem(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvC 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); @@ -164,7 +170,7 @@ OSAllocPages(IMG_UINT32 ui32AllocFlags, #endif switch(ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK) - { + { case PVRSRV_HAP_KERNEL_ONLY: { psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags); @@ -183,12 +189,12 @@ OSAllocPages(IMG_UINT32 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__) @@ -199,22 +205,30 @@ OSAllocPages(IMG_UINT32 ui32AllocFlags, { 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; } @@ -243,14 +257,14 @@ OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_UINT32 ui32Bytes, IMG_VOID *pvCpuVAdd } 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; } @@ -340,7 +354,7 @@ IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_UINT32 ui32Size) Dst[i]=Src[i]; } #else - memcpy(pvDst, pvSrc, ui32Size); + memcpy(pvDst, pvSrc, ui32Size); #endif } @@ -357,14 +371,14 @@ IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_UINT32 ui32Size) 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, ...) @@ -381,127 +395,132 @@ IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_UINT32 ui32Size, const IMG_CHAR *pszFor 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 } @@ -510,49 +529,46 @@ IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID) 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 } @@ -560,157 +576,160 @@ out: 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); } @@ -728,8 +747,21 @@ PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData) 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; @@ -749,13 +781,16 @@ PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData) 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; @@ -763,107 +798,257 @@ PVRSRV_ERROR OSScheduleMISR(IMG_VOID *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)")); @@ -895,9 +1080,9 @@ OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Mappi 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) { @@ -907,8 +1092,8 @@ RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr, { 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; @@ -917,7 +1102,7 @@ RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr, } case PVRSRV_HAP_SINGLE_PROCESS: { - psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags); + psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags); if(!psLinuxMemArea) { @@ -933,7 +1118,7 @@ RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr, ui32MappingFlags &= ~PVRSRV_HAP_CACHED; #endif - psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags); + psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags); if(!psLinuxMemArea) { @@ -958,20 +1143,20 @@ RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr, 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); } @@ -1016,7 +1201,7 @@ OSUnRegisterMem (IMG_VOID *pvCpuVAddr, 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 @@ -1046,17 +1231,17 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr, 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; } @@ -1080,7 +1265,7 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr, *ppvCpuVAddr = NULL; *phOSMemHandle = (IMG_HANDLE)0; return PVRSRV_ERROR_GENERIC; - } + } *phOSMemHandle = (IMG_HANDLE)psLinuxMemArea; *ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea); @@ -1151,7 +1336,7 @@ PVRSRV_ERROR OSBaseAllocContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR *pvLi #endif if (!pvKernLinAddr) { - return PVRSRV_ERROR_OUT_OF_MEMORY; + return PVRSRV_ERROR_OUT_OF_MEMORY; } *pvLinAddr = pvKernLinAddr; @@ -1183,18 +1368,18 @@ PVRSRV_ERROR OSBaseFreeContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR pvLinA 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 } @@ -1202,302 +1387,304 @@ IMG_VOID OSWriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UIN 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 @@ -1506,290 +1693,305 @@ PVRSRV_ERROR OSPCIResumeDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI) 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, @@ -1797,12 +1999,12 @@ 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, @@ -1810,419 +2012,466 @@ 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 + diff --git a/services4/srvkm/env/linux/osperproc.c b/services4/srvkm/env/linux/osperproc.c index 0793875..1b2b6a6 100644 --- a/services4/srvkm/env/linux/osperproc.c +++ b/services4/srvkm/env/linux/osperproc.c @@ -30,6 +30,8 @@ #include "env_perproc.h" #include "proc.h" +extern IMG_UINT32 gui32ReleasePID; + PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData) { PVRSRV_ERROR eError; @@ -39,7 +41,8 @@ PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData) eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_ENV_PER_PROCESS_DATA), phOsPrivateData, - &hBlockAlloc); + &hBlockAlloc, + "Environment per Process Data"); if (eError != PVRSRV_OK) { @@ -82,6 +85,8 @@ PVRSRV_ERROR OSPerProcessPrivateDataDeInit(IMG_HANDLE hOsPrivateData) sizeof(PVRSRV_ENV_PER_PROCESS_DATA), hOsPrivateData, psEnvPerProc->hBlockAlloc); + + if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "%s: OSFreeMem failed (%d)", __FUNCTION__, eError)); @@ -95,3 +100,9 @@ PVRSRV_ERROR OSPerProcessSetHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase) return LinuxMMapPerProcessHandleOptions(psHandleBase); } +IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID) +{ + if(!gui32ReleasePID) + return NULL; + return PVRSRVPerProcessPrivateData(gui32ReleasePID); +} diff --git a/services4/srvkm/env/linux/pdump.c b/services4/srvkm/env/linux/pdump.c index b7f948a..11d69d1 100644 --- a/services4/srvkm/env/linux/pdump.c +++ b/services4/srvkm/env/linux/pdump.c @@ -26,6 +26,7 @@ #if defined (SUPPORT_SGX) #if defined (PDUMP) + #include #include #include "sgxdefs.h" @@ -49,6 +50,7 @@ static IMG_VOID DbgSetMarker (PDBG_STREAM psStream, IMG_UINT32 ui32Marker); 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) @@ -58,31 +60,12 @@ static atomic_t gsPDumpSuspended = ATOMIC_INIT(0); 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; @@ -109,55 +92,306 @@ static inline IMG_BOOL PDumpSuspended(IMG_VOID) 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= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32CountpfnGetStreamOffset(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); } @@ -169,14 +403,14 @@ IMG_VOID PDumpInit(IMG_VOID) 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); @@ -194,8 +428,8 @@ init_failed: IMG_VOID PDumpDeInit(IMG_VOID) -{ - IMG_UINT32 i=0; +{ + IMG_UINT32 i; for(i=0; i < PDUMP_NUM_STREAMS; i++) { @@ -207,7 +441,7 @@ IMG_VOID PDumpDeInit(IMG_VOID) 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); @@ -226,7 +460,7 @@ IMG_VOID PDumpDeInit(IMG_VOID) PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID) { IMG_UINT32 i; - + if (gpfnDbgDrv) { PDUMPCOMMENT("Start Init Phase"); @@ -254,34 +488,6 @@ PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID) 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]); @@ -297,953 +503,104 @@ IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID) 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) && (ui32CountpfnGetStreamOffset(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); } @@ -1251,14 +608,14 @@ static IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 { 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; } @@ -1290,210 +647,6 @@ static IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 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) { diff --git a/services4/srvkm/env/linux/private_data.h b/services4/srvkm/env/linux/private_data.h index 9629a63..93b4ff6 100644 --- a/services4/srvkm/env/linux/private_data.h +++ b/services4/srvkm/env/linux/private_data.h @@ -37,9 +37,17 @@ typedef struct 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; diff --git a/services4/srvkm/env/linux/proc.c b/services4/srvkm/env/linux/proc.c index bc8fd00..b3e2e5f 100644 --- a/services4/srvkm/env/linux/proc.c +++ b/services4/srvkm/env/linux/proc.c @@ -33,6 +33,7 @@ #include #include #include +#include #include "services_headers.h" @@ -46,17 +47,72 @@ #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); @@ -67,25 +123,320 @@ off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * fo 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) { @@ -186,22 +537,22 @@ IMG_INT CreatePerProcessProcEntry(const IMG_CHAR * name, read_proc_t rhandler, w 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); @@ -246,17 +597,35 @@ IMG_INT CreateProcEntries(IMG_VOID) 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)); @@ -264,7 +633,15 @@ IMG_INT CreateProcEntries(IMG_VOID) } #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)); @@ -277,7 +654,7 @@ IMG_INT CreateProcEntries(IMG_VOID) } -IMG_VOID RemoveProcEntry(const IMG_CHAR *name) +IMG_VOID RemoveProcEntry(const IMG_CHAR * name) { if (dir) { @@ -289,19 +666,25 @@ IMG_VOID RemoveProcEntry(const IMG_CHAR *name) 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)); } } @@ -322,15 +705,33 @@ IMG_VOID RemovePerProcessProcDir(PVRSRV_ENV_PER_PROCESS_DATA *psPerProc) 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) { @@ -343,10 +744,38 @@ IMG_VOID RemoveProcEntries(IMG_VOID) } +#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, @@ -355,11 +784,8 @@ static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off) PVR_BUILD_TYPE, PVR_BUILD_DIR); } - if (SysAcquireData(&psSysData) != PVRSRV_OK) - { - return PVRSRV_ERROR_GENERIC; - } - + SysAcquireData(&psSysData); + if (off == 1) { IMG_CHAR *pszSystemVersionString = "None"; @@ -368,9 +794,9 @@ static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off) { pszSystemVersionString = psSysData->pszVersionString; } - - if(strlen(pszSystemVersionString) - + strlen("System Version String: \n") + + if(strlen(pszSystemVersionString) + + strlen("System Version String: \n") + 1 > size) { return 0; @@ -379,10 +805,12 @@ static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off) "System Version String: %s\n", pszSystemVersionString); } - + return END_OF_FILE; } +#endif + static const IMG_CHAR *deviceTypeToString(PVRSRV_DEVICE_TYPE deviceType) { @@ -392,7 +820,7 @@ 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; } @@ -402,7 +830,7 @@ static const IMG_CHAR *deviceTypeToString(PVRSRV_DEVICE_TYPE deviceType) static const IMG_CHAR *deviceClassToString(PVRSRV_DEVICE_CLASS deviceClass) { - switch (deviceClass) + switch (deviceClass) { case PVRSRV_DEVICE_CLASS_3D: { @@ -420,12 +848,78 @@ static const IMG_CHAR *deviceClassToString(PVRSRV_DEVICE_CLASS deviceClass) { 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) { @@ -436,30 +930,27 @@ 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, @@ -475,3 +966,5 @@ off_t procDumpSysNodes(IMG_CHAR *buf, size_t size, off_t off) return (len); } +#endif + diff --git a/services4/srvkm/env/linux/proc.h b/services4/srvkm/env/linux/proc.h index dbb5a7a..3200961 100644 --- a/services4/srvkm/env/linux/proc.h +++ b/services4/srvkm/env/linux/proc.h @@ -29,11 +29,36 @@ #include #include +#include #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))); @@ -51,4 +76,40 @@ IMG_VOID RemovePerProcessProcEntry(const IMG_CHAR * name); 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 diff --git a/services4/srvkm/env/linux/pvr_bridge_k.c b/services4/srvkm/env/linux/pvr_bridge_k.c index c211023..6e725bc 100644 --- a/services4/srvkm/env/linux/pvr_bridge_k.c +++ b/services4/srvkm/env/linux/pvr_bridge_k.c @@ -35,6 +35,10 @@ #include "private_data.h" #include "linkage.h" +#if defined(SUPPORT_DRI_DRM) +#include +#endif + #if defined(SUPPORT_VGX) #include "vgx_bridge.h" #endif @@ -51,12 +55,32 @@ #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) @@ -64,7 +88,20 @@ 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; @@ -78,11 +115,89 @@ IMG_VOID 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) { @@ -143,21 +258,39 @@ unlock_and_return: 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, @@ -171,23 +304,26 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -196,9 +332,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -208,9 +344,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -220,9 +356,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -232,9 +368,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -244,9 +380,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -256,9 +392,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -268,9 +404,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -280,9 +416,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -300,9 +436,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } @@ -311,9 +447,9 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; } } @@ -323,13 +459,13 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) } #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) { @@ -358,14 +494,14 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) } } - 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) { @@ -380,8 +516,8 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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) { @@ -397,7 +533,7 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) default: { - PVRSRV_FILE_PRIVATE_DATA *psPrivateData = pFile->private_data; + PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile); if(psPrivateData->hKernelMemInfo) { @@ -410,7 +546,7 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) } #endif - err = BridgedDispatchKM(psPerProc, &sBridgePackageKM); + err = BridgedDispatchKM(psPerProc, psBridgePackageKM); if(err != PVRSRV_OK) goto unlock_and_return; @@ -420,14 +556,35 @@ PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT cmd, IMG_UINT32 arg) 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; @@ -437,4 +594,3 @@ unlock_and_return: LinuxUnLockMutex(&gPVRSRVLock); return err; } - diff --git a/services4/srvkm/env/linux/pvr_debug.c b/services4/srvkm/env/linux/pvr_debug.c index bdee215..a5cdab1 100644 --- a/services4/srvkm/env/linux/pvr_debug.c +++ b/services4/srvkm/env/linux/pvr_debug.c @@ -44,9 +44,13 @@ #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 @@ -56,7 +60,7 @@ static IMG_CHAR gszBufferIRQ[PVR_MAX_MSG_LEN + 1]; static PVRSRV_LINUX_MUTEX gsDebugMutexNonIRQ; -static spinlock_t gsDebugLockIRQ = SPIN_LOCK_UNLOCKED; +static DEFINE_SPINLOCK(gsDebugLockIRQ); #define USE_SPIN_LOCK (in_interrupt() || !preemptible()) @@ -115,6 +119,84 @@ static IMG_BOOL VBAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR 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; @@ -131,23 +213,15 @@ static IMG_BOOL BAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR 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); @@ -216,6 +290,69 @@ IMG_VOID PVRSRVDebugPrintf ( 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); @@ -225,6 +362,10 @@ IMG_VOID PVRSRVDebugPrintf ( printk(KERN_INFO "%s\n", pszBuf); } } + else + { + printk(KERN_INFO "%s\n", pszBuf); + } } ReleaseBufferLock(ulLockFlags); @@ -233,41 +374,9 @@ IMG_VOID PVRSRVDebugPrintf ( } } -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) { @@ -296,6 +405,13 @@ IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT 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) { @@ -307,11 +423,4 @@ IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_IN } #endif -IMG_VOID -PVRDPFInit(IMG_VOID) -{ -#if defined(DEBUG) || defined(TIMING) - LinuxInitMutex(&gsDebugMutexNonIRQ); #endif -} - diff --git a/services4/srvkm/include/buffer_manager.h b/services4/srvkm/include/buffer_manager.h index 014c99f..a47086d 100644 --- a/services4/srvkm/include/buffer_manager.h +++ b/services4/srvkm/include/buffer_manager.h @@ -187,8 +187,8 @@ BM_ContiguousStatistics (IMG_UINT32 uFlags, 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, diff --git a/services4/srvkm/include/lists.h b/services4/srvkm/include/lists.h new file mode 100644 index 0000000..76d5af2 --- /dev/null +++ b/services4/srvkm/include/lists.h @@ -0,0 +1,176 @@ +/********************************************************************** + * + * 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. + * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK + * + ******************************************************************************/ + +#ifndef __LISTS_UTILS__ +#define __LISTS_UTILS__ + +#include +#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 diff --git a/services4/srvkm/include/osfunc.h b/services4/srvkm/include/osfunc.h index af6b00e..55fef3e 100644 --- a/services4/srvkm/include/osfunc.h +++ b/services4/srvkm/include/osfunc.h @@ -237,24 +237,95 @@ IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID); 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); diff --git a/services4/srvkm/include/pdump_km.h b/services4/srvkm/include/pdump_km.h index 783aa40..c780e22 100644 --- a/services4/srvkm/include/pdump_km.h +++ b/services4/srvkm/include/pdump_km.h @@ -68,8 +68,7 @@ extern "C" { 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, @@ -134,18 +133,47 @@ extern "C" { 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); @@ -166,36 +194,14 @@ extern "C" { 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, @@ -205,24 +211,7 @@ extern "C" { 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, @@ -232,25 +221,121 @@ extern "C" { 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, @@ -260,8 +345,15 @@ extern "C" { 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); diff --git a/services4/srvkm/include/pdump_osfunc.h b/services4/srvkm/include/pdump_osfunc.h new file mode 100644 index 0000000..7c6db05 --- /dev/null +++ b/services4/srvkm/include/pdump_osfunc.h @@ -0,0 +1,137 @@ +/********************************************************************** + * + * 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. + * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK + * + ******************************************************************************/ + +#ifndef __PDUMP_OSFUNC_H__ +#define __PDUMP_OSFUNC_H__ + +#include + +#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 + diff --git a/services4/srvkm/include/power.h b/services4/srvkm/include/power.h index 09ae046..d09ebc9 100644 --- a/services4/srvkm/include/power.h +++ b/services4/srvkm/include/power.h @@ -44,6 +44,7 @@ typedef struct _PVRSRV_POWER_DEV_TAG_ PVR_POWER_STATE eDefaultPowerState; PVR_POWER_STATE eCurrentPowerState; struct _PVRSRV_POWER_DEV_TAG_ *psNext; + struct _PVRSRV_POWER_DEV_TAG_ **ppsThis; } PVRSRV_POWER_DEV; diff --git a/services4/srvkm/include/resman.h b/services4/srvkm/include/resman.h index 37d5e3e..da1e078 100644 --- a/services4/srvkm/include/resman.h +++ b/services4/srvkm/include/resman.h @@ -61,6 +61,7 @@ enum { RESMAN_TYPE_DEVICEMEM_ALLOCATION, RESMAN_TYPE_EVENT_OBJECT, RESMAN_TYPE_SHARED_MEM_INFO, + RESMAN_TYPE_MODIFY_SYNC_OPS, RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION