IMG_INTERNAL
void PVRSRVBMBufDecExport2(const IMG_CHAR *pszFile, IMG_INT iLine, BM_BUF *pBuf)
{
if(!(guiDebugMask & PVRSRV_REFCOUNT_CCB_DEBUG_BM_BUF2))
goto skip;
PVRSRV_LOCK_CCB();
gsRefCountCCB[giOffset].pszFile = pszFile;
gsRefCountCCB[giOffset].iLine = iLine;
gsRefCountCCB[giOffset].ui32PID = OSGetCurrentProcessIDKM();
snprintf(gsRefCountCCB[giOffset].pcMesg,
PVRSRV_REFCOUNT_CCB_MESG_MAX - 1,
PVRSRV_REFCOUNT_CCB_FMT_STRING,
"BM_BUF2",
NULL,
NULL,
BM_HandleToOSMemHandle(pBuf),
pBuf,
pBuf->ui32ExportCount,
pBuf->ui32ExportCount - 1,
(pBuf->pMapping) ? pBuf->pMapping->uSize : 0);
gsRefCountCCB[giOffset].pcMesg[PVRSRV_REFCOUNT_CCB_MESG_MAX - 1] = 0;
giOffset = (giOffset + 1) % PVRSRV_REFCOUNT_CCB_MAX;
PVRSRV_UNLOCK_CCB();
skip:
pBuf->ui32ExportCount--;
}
static enum PVRSRV_ERROR AllocDeviceMem(void *hDevCookie, void *hDevMemHeap,
u32 ui32Flags, u32 ui32Size,
u32 ui32Alignment,
struct PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo;
void *hBuffer;
struct PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
PVR_UNREFERENCED_PARAMETER(hDevCookie);
*ppsMemInfo = NULL;
if (OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO),
(void **) &psMemInfo, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"AllocDeviceMem: Failed to alloc memory for block");
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
psMemInfo->ui32Flags = ui32Flags | PVRSRV_MEM_RAM_BACKED_ALLOCATION;
bBMError = BM_Alloc(hDevMemHeap, NULL, ui32Size,
&psMemInfo->ui32Flags, ui32Alignment, &hBuffer);
if (!bBMError) {
PVR_DPF(PVR_DBG_ERROR, "AllocDeviceMem: BM_Alloc Failed");
OSFreeMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO), psMemInfo,
NULL);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (void *)hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32Size;
psMemInfo->pvSysBackupBuffer = NULL;
*ppsMemInfo = psMemInfo;
return PVRSRV_OK;
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE hDevCookie,
PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevMemContext,
IMG_SIZE_T ui32ByteSize,
IMG_SIZE_T ui32PageOffset,
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psExtSysPAddr,
IMG_VOID *pvLinAddr,
IMG_UINT32 ui32Flags,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
IMG_HANDLE hDevMemHeap = IMG_NULL;
PVRSRV_DEVICE_NODE* psDeviceNode;
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
BM_HEAP *psBMHeap;
PVRSRV_ERROR eError;
IMG_VOID *pvPageAlignedCPUVAddr;
IMG_SYS_PHYADDR *psIntSysPAddr = IMG_NULL;
IMG_HANDLE hOSWrapMem = IMG_NULL;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
IMG_UINT32 i;
IMG_SIZE_T ui32PageCount = 0;
psDeviceNode = (PVRSRV_DEVICE_NODE*)hDevCookie;
PVR_ASSERT(psDeviceNode != IMG_NULL);
if (psDeviceNode == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVWrapExtMemoryKM: invalid parameter"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
if(pvLinAddr)
{
ui32PageOffset = (IMG_UINTPTR_T)pvLinAddr & (ui32HostPageSize - 1);
ui32PageCount = HOST_PAGEALIGN(ui32ByteSize + ui32PageOffset) / ui32HostPageSize;
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvLinAddr - ui32PageOffset);
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageCount * sizeof(IMG_SYS_PHYADDR),
(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;
}
eError = OSAcquirePhysPageAddr(pvPageAlignedCPUVAddr,
ui32PageCount * ui32HostPageSize,
psIntSysPAddr,
&hOSWrapMem);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExitPhase1;
}
psExtSysPAddr = psIntSysPAddr;
bPhysContig = IMG_FALSE;
}
else
{
}
psDevMemoryInfo = &((BM_CONTEXT*)hDevMemContext)->psDeviceNode->sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
for(i=0; i<PVRSRV_MAX_CLIENT_HEAPS; i++)
{
if(HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) == psDevMemoryInfo->ui32MappingHeapID)
{
if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
{
hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
}
else
{
hDevMemHeap = psDevMemoryInfo->psDeviceMemoryHeap[i].hDevMemHeap;
}
break;
}
}
if(hDevMemHeap == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: unable to find mapping heap"));
eError = PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP;
goto ErrorExitPhase2;
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO),
(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;
goto ErrorExitPhase2;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemInfo->ui32Flags = ui32Flags;
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDevMemHeap,
ui32ByteSize,
ui32PageOffset,
bPhysContig,
psExtSysPAddr,
IMG_NULL,
&psMemInfo->ui32Flags,
&hBuffer);
if (!bBMError)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: BM_Wrap Failed"));
eError = PVRSRV_ERROR_BAD_MAPPING;
goto ErrorExitPhase3;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hOSWrapMem = hOSWrapMem;
psMemBlock->psIntSysPAddr = psIntSysPAddr;
psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32ByteSize;
psMemInfo->pvSysBackupBuffer = IMG_NULL;
psBMHeap = (BM_HEAP*)hDevMemHeap;
hDevMemContext = (IMG_HANDLE)psBMHeap->pBMContext;
eError = PVRSRVAllocSyncInfoKM(hDevCookie,
hDevMemContext,
&psMemInfo->psKernelSyncInfo);
if(eError != PVRSRV_OK)
{
goto ErrorExitPhase4;
}
psMemInfo->psKernelSyncInfo->ui32RefCount++;
psMemInfo->ui32RefCount++;
psMemInfo->memType = PVRSRV_MEMTYPE_WRAPPED;
psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICEMEM_WRAP,
psMemInfo,
0,
&UnwrapExtMemoryCallBack);
*ppsMemInfo = psMemInfo;
return PVRSRV_OK;
ErrorExitPhase4:
if(psMemInfo)
{
FreeDeviceMem(psMemInfo);
psMemInfo = IMG_NULL;
}
ErrorExitPhase3:
if(psMemInfo)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
}
ErrorExitPhase2:
if(psIntSysPAddr)
{
OSReleasePhysPageAddr(hOSWrapMem);
}
ErrorExitPhase1:
if(psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageCount * sizeof(IMG_SYS_PHYADDR), psIntSysPAddr, IMG_NULL);
}
return eError;
}
static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE hDevCookie,
IMG_HANDLE hDevMemHeap,
IMG_UINT32 ui32Flags,
IMG_SIZE_T ui32Size,
IMG_SIZE_T ui32Alignment,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo;
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
PVR_UNREFERENCED_PARAMETER(hDevCookie);
*ppsMemInfo = IMG_NULL;
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
(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);
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
psMemInfo->ui32Flags = ui32Flags | PVRSRV_MEM_RAM_BACKED_ALLOCATION;
bBMError = BM_Alloc (hDevMemHeap,
IMG_NULL,
ui32Size,
&psMemInfo->ui32Flags,
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;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32Size;
psMemInfo->pvSysBackupBuffer = IMG_NULL;
*ppsMemInfo = psMemInfo;
return (PVRSRV_OK);
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevMemContext,
IMG_HANDLE hDeviceClassBuffer,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo,
IMG_HANDLE *phOSMapInfo)
{
PVRSRV_ERROR eError;
PVRSRV_DEVICE_NODE* psDeviceNode;
PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
PVRSRV_DEVICECLASS_BUFFER *psDeviceClassBuffer;
IMG_SYS_PHYADDR *psSysPAddr;
IMG_VOID *pvCPUVAddr, *pvPageAlignedCPUVAddr;
IMG_BOOL bPhysContig;
BM_CONTEXT *psBMContext;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
IMG_HANDLE hDevMemHeap = IMG_NULL;
IMG_SIZE_T ui32ByteSize;
IMG_SIZE_T ui32Offset;
IMG_SIZE_T ui32PageSize = HOST_PAGESIZE();
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
IMG_UINT32 i;
PVRSRV_DC_MAPINFO *psDCMapInfo = IMG_NULL;
if(!hDeviceClassBuffer || !ppsMemInfo || !phOSMapInfo || !hDevMemContext)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DC_MAPINFO),
(IMG_VOID **)&psDCMapInfo, IMG_NULL,
"PVRSRV_DC_MAPINFO") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for psDCMapInfo"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psDCMapInfo, 0, sizeof(PVRSRV_DC_MAPINFO));
psDeviceClassBuffer = (PVRSRV_DEVICECLASS_BUFFER*)hDeviceClassBuffer;
eError = psDeviceClassBuffer->pfnGetBufferAddr(psDeviceClassBuffer->hExtDevice,
psDeviceClassBuffer->hExtBuffer,
&psSysPAddr,
&ui32ByteSize,
&pvCPUVAddr,
phOSMapInfo,
&bPhysContig,
&psDCMapInfo->ui32TilingStride);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to get buffer address"));
goto ErrorExitPhase1;
}
psBMContext = (BM_CONTEXT*)psDeviceClassBuffer->hDevMemContext;
psDeviceNode = psBMContext->psDeviceNode;
psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
for(i=0; i<PVRSRV_MAX_CLIENT_HEAPS; i++)
{
if(HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) == psDevMemoryInfo->ui32MappingHeapID)
{
if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
{
hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
}
else
{
hDevMemHeap = psDevMemoryInfo->psDeviceMemoryHeap[i].hDevMemHeap;
}
break;
}
}
if(hDevMemHeap == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to find mapping heap"));
eError = PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE;
goto ErrorExitPhase1;
}
ui32Offset = ((IMG_UINTPTR_T)pvCPUVAddr) & (ui32PageSize - 1);
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvCPUVAddr - ui32Offset);
eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
(IMG_VOID **)&psMemInfo, IMG_NULL,
"Kernel Memory Info");
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for block"));
goto ErrorExitPhase1;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDevMemHeap,
ui32ByteSize,
ui32Offset,
bPhysContig,
psSysPAddr,
pvPageAlignedCPUVAddr,
&psMemInfo->ui32Flags,
&hBuffer);
if (!bBMError)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: BM_Wrap Failed"));
eError = PVRSRV_ERROR_BAD_MAPPING;
goto ErrorExitPhase2;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32ByteSize;
psMemInfo->psKernelSyncInfo = psDeviceClassBuffer->psKernelSyncInfo;
psMemInfo->pvSysBackupBuffer = IMG_NULL;
psDCMapInfo->psMemInfo = psMemInfo;
#if defined(SUPPORT_MEMORY_TILING)
psDCMapInfo->psDeviceNode = psDeviceNode;
if(psDCMapInfo->ui32TilingStride > 0)
{
eError = psDeviceNode->pfnAllocMemTilingRange(psDeviceNode,
psMemInfo,
psDCMapInfo->ui32TilingStride,
&psDCMapInfo->ui32RangeIndex);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: AllocMemTilingRange failed"));
goto ErrorExitPhase3;
}
}
#endif
psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICECLASSMEM_MAPPING,
psDCMapInfo,
0,
&UnmapDeviceClassMemoryCallBack);
psMemInfo->ui32RefCount++;
psMemInfo->memType = PVRSRV_MEMTYPE_DEVICECLASS;
*ppsMemInfo = psMemInfo;
#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
PDUMPCOMMENT("Dump display surface");
PDUMPMEM(IMG_NULL, psMemInfo, ui32Offset, psMemInfo->ui32AllocSize, PDUMP_FLAGS_CONTINUOUS, ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping);
#endif
return PVRSRV_OK;
#if defined(SUPPORT_MEMORY_TILING)
ErrorExitPhase3:
if(psMemInfo)
{
FreeDeviceMem(psMemInfo);
psMemInfo = IMG_NULL;
}
#endif
ErrorExitPhase2:
if(psMemInfo)
{
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
}
ErrorExitPhase1:
if(psDCMapInfo)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psDCMapInfo, IMG_NULL);
}
return eError;
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
PVRSRV_KERNEL_MEM_INFO *psSrcMemInfo,
IMG_HANDLE hDstDevMemHeap,
PVRSRV_KERNEL_MEM_INFO **ppsDstMemInfo)
{
PVRSRV_ERROR eError;
IMG_UINT32 i;
IMG_SIZE_T ui32PageCount, ui32PageOffset;
IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
IMG_SYS_PHYADDR *psSysPAddr = IMG_NULL;
IMG_DEV_PHYADDR sDevPAddr;
BM_BUF *psBuf;
IMG_DEV_VIRTADDR sDevVAddr;
PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
BM_HANDLE hBuffer;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
PVRSRV_DEVICE_NODE *psDeviceNode;
IMG_VOID *pvPageAlignedCPUVAddr;
RESMAN_MAP_DEVICE_MEM_DATA *psMapData = IMG_NULL;
if(!psSrcMemInfo || !hDstDevMemHeap || !ppsDstMemInfo)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
*ppsDstMemInfo = IMG_NULL;
ui32PageOffset = psSrcMemInfo->sDevVAddr.uiAddr & (ui32HostPageSize - 1);
ui32PageCount = HOST_PAGEALIGN(psSrcMemInfo->ui32AllocSize + ui32PageOffset) / ui32HostPageSize;
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)psSrcMemInfo->pvLinAddrKM - ui32PageOffset);
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageCount*sizeof(IMG_SYS_PHYADDR),
(IMG_VOID **)&psSysPAddr, IMG_NULL,
"Array of Page Addresses") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc memory for block"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psBuf = psSrcMemInfo->sMemBlk.hBuffer;
psDeviceNode = psBuf->pMapping->pBMHeap->pBMContext->psDeviceNode;
sDevVAddr.uiAddr = psSrcMemInfo->sDevVAddr.uiAddr - IMG_CAST_TO_DEVVADDR_UINT(ui32PageOffset);
for(i=0; i<ui32PageCount; i++)
{
BM_GetPhysPageAddr(psSrcMemInfo, sDevVAddr, &sDevPAddr);
psSysPAddr[i] = SysDevPAddrToSysPAddr (psDeviceNode->sDevId.eDeviceType, sDevPAddr);
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,
"Resource Manager Map Data") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc resman map data"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExit;
}
if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
(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;
goto ErrorExit;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemInfo->ui32Flags = psSrcMemInfo->ui32Flags;
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDstDevMemHeap,
psSrcMemInfo->ui32AllocSize,
ui32PageOffset,
IMG_FALSE,
psSysPAddr,
pvPageAlignedCPUVAddr,
&psMemInfo->ui32Flags,
&hBuffer);
if (!bBMError)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: BM_Wrap Failed"));
eError = PVRSRV_ERROR_BAD_MAPPING;
goto ErrorExit;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
psMemBlock->psIntSysPAddr = psSysPAddr;
psMemInfo->pvLinAddrKM = psSrcMemInfo->pvLinAddrKM;
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = psSrcMemInfo->ui32AllocSize;
psMemInfo->psKernelSyncInfo = psSrcMemInfo->psKernelSyncInfo;
if( psMemInfo->psKernelSyncInfo )
psMemInfo->psKernelSyncInfo->ui32RefCount++;
psMemInfo->pvSysBackupBuffer = IMG_NULL;
psMemInfo->ui32RefCount++;
psSrcMemInfo->ui32RefCount++;
BM_Export(psSrcMemInfo->sMemBlk.hBuffer);
psMemInfo->memType = PVRSRV_MEMTYPE_MAPPED;
psMapData->psMemInfo = psMemInfo;
psMapData->psSrcMemInfo = psSrcMemInfo;
psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICEMEM_MAPPING,
psMapData,
0,
&UnmapDeviceMemoryCallBack);
*ppsDstMemInfo = psMemInfo;
return PVRSRV_OK;
ErrorExit:
if(psSysPAddr)
{
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, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
}
return eError;
}
enum PVRSRV_ERROR PVRSRVMapDeviceMemoryKM(
struct PVRSRV_PER_PROCESS_DATA *psPerProc,
struct PVRSRV_KERNEL_MEM_INFO *psSrcMemInfo,
void *hDstDevMemHeap,
struct PVRSRV_KERNEL_MEM_INFO **ppsDstMemInfo)
{
enum PVRSRV_ERROR eError;
u32 ui32PageOffset;
u32 ui32HostPageSize = HOST_PAGESIZE();
int page_count;
int i;
struct IMG_SYS_PHYADDR *psSysPAddr = NULL;
struct IMG_DEV_PHYADDR sDevPAddr;
struct BM_BUF *psBuf;
struct IMG_DEV_VIRTADDR sDevVAddr;
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo = NULL;
void *hBuffer;
struct PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
struct PVRSRV_DEVICE_NODE *psDeviceNode;
void *pvPageAlignedCPUVAddr;
struct RESMAN_MAP_DEVICE_MEM_DATA *psMapData = NULL;
if (!psSrcMemInfo || !hDstDevMemHeap || !ppsDstMemInfo) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVMapDeviceMemoryKM: invalid parameters");
return PVRSRV_ERROR_INVALID_PARAMS;
}
*ppsDstMemInfo = NULL;
get_page_details((u32)psSrcMemInfo->pvLinAddrKM,
psSrcMemInfo->ui32AllocSize,
&ui32PageOffset, &page_count);
pvPageAlignedCPUVAddr =
(void *) ((u8 *) psSrcMemInfo->pvLinAddrKM -
ui32PageOffset);
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
page_count * sizeof(struct IMG_SYS_PHYADDR),
(void **) &psSysPAddr, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceMemoryKM: "
"Failed to alloc memory for block");
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psBuf = psSrcMemInfo->sMemBlk.hBuffer;
psDeviceNode = psBuf->pMapping->pBMHeap->pBMContext->psDeviceNode;
sDevVAddr.uiAddr = psSrcMemInfo->sDevVAddr.uiAddr - ui32PageOffset;
for (i = 0; i < page_count; i++) {
eError =
BM_GetPhysPageAddr(psSrcMemInfo, sDevVAddr, &sDevPAddr);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceMemoryKM: "
"Failed to retrieve page list from device");
goto ErrorExit;
}
psSysPAddr[i] =
SysDevPAddrToSysPAddr(psDeviceNode->sDevId.eDeviceType,
sDevPAddr);
sDevVAddr.uiAddr += ui32HostPageSize;
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct RESMAN_MAP_DEVICE_MEM_DATA),
(void **)&psMapData, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceMemoryKM: "
"Failed to alloc resman map data");
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExit;
}
if (OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO),
(void **)&psMemInfo, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceMemoryKM: "
"Failed to alloc memory for block");
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExit;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDstDevMemHeap, psSrcMemInfo->ui32AllocSize,
ui32PageOffset, bm_is_continuous(psBuf), psSysPAddr,
pvPageAlignedCPUVAddr, &psMemInfo->ui32Flags,
&hBuffer);
if (!bBMError) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVMapDeviceMemoryKM: BM_Wrap Failed");
eError = PVRSRV_ERROR_BAD_MAPPING;
goto ErrorExit;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (void *) hBuffer;
psMemBlock->psIntSysPAddr = psSysPAddr;
psMemInfo->pvLinAddrKM = psSrcMemInfo->pvLinAddrKM;
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = psSrcMemInfo->ui32AllocSize;
psMemInfo->psKernelSyncInfo = psSrcMemInfo->psKernelSyncInfo;
psMemInfo->pvSysBackupBuffer = NULL;
psSrcMemInfo->ui32RefCount++;
psMapData->psMemInfo = psMemInfo;
psMapData->psSrcMemInfo = psSrcMemInfo;
psMemInfo->sMemBlk.hResItem =
ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICEMEM_MAPPING, psMapData, 0,
UnmapDeviceMemoryCallBack);
*ppsDstMemInfo = psMemInfo;
return PVRSRV_OK;
ErrorExit:
if (psSysPAddr) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct IMG_SYS_PHYADDR), psSysPAddr, NULL);
}
if (psMemInfo) {
OSFreeMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO), psMemInfo,
NULL);
}
if (psMapData) {
OSFreeMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct RESMAN_MAP_DEVICE_MEM_DATA), psMapData,
NULL);
}
return eError;
}
enum PVRSRV_ERROR PVRSRVWrapExtMemoryKM(void *hDevCookie,
struct PVRSRV_PER_PROCESS_DATA *psPerProc,
void *hDevMemContext, u32 ui32ByteSize,
u32 ui32PageOffset, IMG_BOOL bPhysContig,
struct IMG_SYS_PHYADDR *psExtSysPAddr,
void *pvLinAddr,
struct PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo = NULL;
struct DEVICE_MEMORY_INFO *psDevMemoryInfo;
u32 ui32HostPageSize = HOST_PAGESIZE();
void *hDevMemHeap = NULL;
struct PVRSRV_DEVICE_NODE *psDeviceNode;
void *hBuffer;
struct PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
struct BM_HEAP *psBMHeap;
enum PVRSRV_ERROR eError;
void *pvPageAlignedCPUVAddr;
struct IMG_SYS_PHYADDR *psIntSysPAddr = NULL;
void *hOSWrapMem = NULL;
struct DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
int page_count = 0;
u32 i;
psDeviceNode = (struct PVRSRV_DEVICE_NODE *)hDevCookie;
PVR_ASSERT(psDeviceNode != NULL);
if (!psDeviceNode || (!pvLinAddr && !psExtSysPAddr)) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVWrapExtMemoryKM: invalid parameter");
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (pvLinAddr) {
get_page_details((u32)pvLinAddr, ui32ByteSize,
&ui32PageOffset, &page_count);
pvPageAlignedCPUVAddr = (void *)((u8 *) pvLinAddr -
ui32PageOffset);
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
page_count * sizeof(struct IMG_SYS_PHYADDR),
(void **)&psIntSysPAddr, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVWrapExtMemoryKM: "
"Failed to alloc memory for block");
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
eError = OSAcquirePhysPageAddr(pvPageAlignedCPUVAddr,
page_count * ui32HostPageSize,
psIntSysPAddr, &hOSWrapMem);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVWrapExtMemoryKM:"
" Failed to alloc memory for block");
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExitPhase1;
}
psExtSysPAddr = psIntSysPAddr;
bPhysContig = IMG_FALSE;
}
psDevMemoryInfo =
&((struct BM_CONTEXT *)hDevMemContext)->psDeviceNode->
sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
for (i = 0; i < PVRSRV_MAX_CLIENT_HEAPS; i++) {
if (HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) ==
psDevMemoryInfo->ui32MappingHeapID) {
if (psDeviceMemoryHeap[i].DevMemHeapType ==
DEVICE_MEMORY_HEAP_PERCONTEXT) {
hDevMemHeap =
BM_CreateHeap(hDevMemContext,
&psDeviceMemoryHeap[i]);
} else {
hDevMemHeap =
psDevMemoryInfo->psDeviceMemoryHeap[i].
hDevMemHeap;
}
break;
}
}
if (hDevMemHeap == NULL) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVWrapExtMemoryKM: unable to find mapping heap");
eError = PVRSRV_ERROR_GENERIC;
goto ErrorExitPhase2;
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_KERNEL_MEM_INFO),
(void **) &psMemInfo, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVWrapExtMemoryKM: "
"Failed to alloc memory for block");
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExitPhase2;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDevMemHeap,
ui32ByteSize,
ui32PageOffset,
bPhysContig,
psExtSysPAddr,
NULL, &psMemInfo->ui32Flags, &hBuffer);
if (!bBMError) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVWrapExtMemoryKM: BM_Wrap Failed");
eError = PVRSRV_ERROR_BAD_MAPPING;
goto ErrorExitPhase3;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hOSWrapMem = hOSWrapMem;
psMemBlock->psIntSysPAddr = psIntSysPAddr;
psMemBlock->hBuffer = (void *) hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32ByteSize;
psMemInfo->pvSysBackupBuffer = NULL;
psBMHeap = (struct BM_HEAP *)hDevMemHeap;
hDevMemContext = (void *) psBMHeap->pBMContext;
eError = alloc_or_reuse_syncinfo(hDevCookie,
hDevMemContext,
&psMemInfo->psKernelSyncInfo,
psExtSysPAddr);
if (eError != PVRSRV_OK)
goto ErrorExitPhase4;
psMemInfo->ui32RefCount++;
psMemInfo->sMemBlk.hResItem =
ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICEMEM_WRAP, psMemInfo, 0,
UnwrapExtMemoryCallBack);
*ppsMemInfo = psMemInfo;
return PVRSRV_OK;
ErrorExitPhase4:
FreeDeviceMem(psMemInfo);
psMemInfo = NULL;
ErrorExitPhase3:
if (psMemInfo) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_KERNEL_MEM_INFO), psMemInfo,
NULL);
}
ErrorExitPhase2:
if (hOSWrapMem)
OSReleasePhysPageAddr(hOSWrapMem);
ErrorExitPhase1:
if (psIntSysPAddr) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
page_count * sizeof(struct IMG_SYS_PHYADDR),
psIntSysPAddr, NULL);
}
return eError;
}
enum PVRSRV_ERROR PVRSRVMapDeviceClassMemoryKM(
struct PVRSRV_PER_PROCESS_DATA *psPerProc,
void *hDevMemContext, void *hDeviceClassBuffer,
struct PVRSRV_KERNEL_MEM_INFO **ppsMemInfo,
void **phOSMapInfo)
{
enum PVRSRV_ERROR eError;
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo;
struct PVRSRV_DEVICECLASS_BUFFER *psDeviceClassBuffer;
struct IMG_SYS_PHYADDR *psSysPAddr;
void *pvCPUVAddr, *pvPageAlignedCPUVAddr;
IMG_BOOL bPhysContig;
struct BM_CONTEXT *psBMContext;
struct DEVICE_MEMORY_INFO *psDevMemoryInfo;
struct DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
void *hDevMemHeap = NULL;
u32 ui32ByteSize;
u32 ui32Offset;
u32 ui32PageSize = HOST_PAGESIZE();
void *hBuffer;
struct PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
u32 i;
if (!hDeviceClassBuffer || !ppsMemInfo || !phOSMapInfo ||
!hDevMemContext) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVMapDeviceClassMemoryKM: invalid parameters");
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDeviceClassBuffer = (struct PVRSRV_DEVICECLASS_BUFFER *)
hDeviceClassBuffer;
eError =
psDeviceClassBuffer->pfnGetBufferAddr(psDeviceClassBuffer->
hExtDevice,
psDeviceClassBuffer->
hExtBuffer, &psSysPAddr,
&ui32ByteSize,
(void __iomem **)&pvCPUVAddr,
phOSMapInfo, &bPhysContig);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceClassMemoryKM: "
"unable to get buffer address");
return PVRSRV_ERROR_GENERIC;
}
psBMContext = (struct BM_CONTEXT *)psDeviceClassBuffer->hDevMemContext;
psDevMemoryInfo = &psBMContext->psDeviceNode->sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
for (i = 0; i < PVRSRV_MAX_CLIENT_HEAPS; i++) {
if (HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) ==
psDevMemoryInfo->ui32MappingHeapID) {
if (psDeviceMemoryHeap[i].DevMemHeapType ==
DEVICE_MEMORY_HEAP_PERCONTEXT)
hDevMemHeap =
BM_CreateHeap(hDevMemContext,
&psDeviceMemoryHeap[i]);
else
hDevMemHeap =
psDevMemoryInfo->psDeviceMemoryHeap[i].
hDevMemHeap;
break;
}
}
if (hDevMemHeap == NULL) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceClassMemoryKM: "
"unable to find mapping heap");
return PVRSRV_ERROR_GENERIC;
}
ui32Offset = ((u32)pvCPUVAddr) & (ui32PageSize - 1);
pvPageAlignedCPUVAddr = (void *)((u8 *)pvCPUVAddr - ui32Offset);
if (OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO),
(void **)&psMemInfo, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVMapDeviceClassMemoryKM: "
"Failed to alloc memory for block");
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
psMemBlock = &(psMemInfo->sMemBlk);
bBMError = BM_Wrap(hDevMemHeap, ui32ByteSize, ui32Offset, bPhysContig,
psSysPAddr, pvPageAlignedCPUVAddr,
&psMemInfo->ui32Flags, &hBuffer);
if (!bBMError) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVMapDeviceClassMemoryKM: BM_Wrap Failed");
OSFreeMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_KERNEL_MEM_INFO), psMemInfo,
NULL);
return PVRSRV_ERROR_BAD_MAPPING;
}
psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
psMemBlock->hBuffer = (void *) hBuffer;
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32ByteSize;
psMemInfo->psKernelSyncInfo = psDeviceClassBuffer->psKernelSyncInfo;
psMemInfo->pvSysBackupBuffer = NULL;
psMemInfo->sMemBlk.hResItem =
ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICECLASSMEM_MAPPING, psMemInfo, 0,
UnmapDeviceClassMemoryCallBack);
*ppsMemInfo = psMemInfo;
return PVRSRV_OK;
}
