void PDumpInit(void)
{
if (!gpszFile)
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
SZ_FILENAME_SIZE_MAX,
(void **)&gpszFile,
NULL) != PVRSRV_OK)
goto init_failed;
if (!gpszComment)
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
SZ_COMMENT_SIZE_MAX,
(void **)&gpszComment,
NULL) != PVRSRV_OK)
goto init_failed;
if (!gpszScript)
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
SZ_SCRIPT_SIZE_MAX,
(void **)&gpszScript,
NULL) != PVRSRV_OK)
goto init_failed;
if (pdumpfs_init()) {
pr_err("%s: pdumpfs_init failed.\n", __func__);
goto init_failed;
}
PDumpComment("Driver Product Name: %s", VS_PRODUCT_NAME);
PDumpComment("Driver Product Version: %s (%s)",
PVRVERSION_STRING, PVRVERSION_FILE);
PDumpComment("Start of Init Phase");
return;
init_failed:
if (gpszFile) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX,
(void *)gpszFile, NULL);
gpszFile = NULL;
}
if (gpszScript) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX,
(void *)gpszScript, NULL);
gpszScript = NULL;
}
if (gpszComment) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_COMMENT_SIZE_MAX,
(void *)gpszComment, NULL);
gpszComment = NULL;
}
}
PVRSRV_ERROR OSConnectionPrivateDataInit(IMG_HANDLE *phOsPrivateData, IMG_PVOID pvOSData)
{
ENV_CONNECTION_DATA *psEnvConnection;
#if defined(SUPPORT_ION)
ENV_ION_CONNECTION_DATA *psIonConnection;
#endif
*phOsPrivateData = OSAllocMem(sizeof(ENV_CONNECTION_DATA));
if (*phOsPrivateData == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "%s: OSAllocMem failed", __FUNCTION__));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psEnvConnection = (ENV_CONNECTION_DATA *)*phOsPrivateData;
OSMemSet(psEnvConnection, 0, sizeof(*psEnvConnection));
/* Save the pointer to our struct file */
psEnvConnection->psFile = pvOSData;
#if defined(SUPPORT_ION)
psIonConnection = (ENV_ION_CONNECTION_DATA *)OSAllocMem(sizeof(ENV_ION_CONNECTION_DATA));
if (psIonConnection == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "%s: OSAllocMem failed", __FUNCTION__));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psIonConnection, 0, sizeof(*psIonConnection));
psEnvConnection->psIonData = psIonConnection;
/*
We can have more then one connection per process so we need more then
the PID to have a unique name
*/
psEnvConnection->psIonData->psIonDev = IonDevAcquire();
OSSNPrintf(psEnvConnection->psIonData->azIonClientName, ION_CLIENT_NAME_SIZE, "pvr_ion_client-%p-%d", *phOsPrivateData, OSGetCurrentProcessIDKM());
psEnvConnection->psIonData->psIonClient =
ion_client_create(psEnvConnection->psIonData->psIonDev,
psEnvConnection->psIonData->azIonClientName);
if (IS_ERR_OR_NULL(psEnvConnection->psIonData->psIonClient))
{
PVR_DPF((PVR_DBG_ERROR, "OSConnectionPrivateDataInit: Couldn't create "
"ion client for per connection data"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psEnvConnection->psIonData->ui32IonClientRefCount = 1;
#endif /* SUPPORT_ION */
return PVRSRV_OK;
}
PVRSRV_ERROR IMG_CALLCONV PVRSRVInit(PSYS_DATA psSysData)
{
PVRSRV_ERROR eError;
eError = ResManInit();
if (eError != PVRSRV_OK)
{
goto Error;
}
eError = PVRSRVPerProcessDataInit();
if(eError != PVRSRV_OK)
{
goto Error;
}
eError = PVRSRVHandleInit();
if(eError != PVRSRV_OK)
{
goto Error;
}
eError = OSCreateResource(&psSysData->sPowerStateChangeResource);
if (eError != PVRSRV_OK)
{
goto Error;
}
psSysData->eCurrentPowerState = PVRSRV_SYS_POWER_STATE_D0;
psSysData->eFailedPowerState = PVRSRV_SYS_POWER_STATE_Unspecified;
if(OSAllocMem( PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_EVENTOBJECT) ,
(IMG_VOID **)&psSysData->psGlobalEventObject, 0,
"Event Object") != PVRSRV_OK)
{
goto Error;
}
if(OSEventObjectCreate("PVRSRV_GLOBAL_EVENTOBJECT", psSysData->psGlobalEventObject) != PVRSRV_OK)
{
goto Error;
}
PDUMPINIT();
g_ui32InitFlags |= INIT_DATA_ENABLE_PDUMPINIT;
return eError;
Error:
PVRSRVDeInit(psSysData);
return eError;
}
static struct BT *_SegmentSplit(struct RA_ARENA *pArena, struct BT *pBT,
size_t uSize)
{
struct BT *pNeighbour;
PVR_ASSERT(pArena != NULL);
if (pArena == NULL) {
PVR_DPF(PVR_DBG_ERROR,
"_SegmentSplit: invalid parameter - pArena");
return NULL;
}
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct BT),
(void **) &pNeighbour, NULL) != PVRSRV_OK)
return NULL;
pNeighbour->pPrevSegment = pBT;
pNeighbour->pNextSegment = pBT->pNextSegment;
if (pBT->pNextSegment == NULL)
pArena->pTailSegment = pNeighbour;
else
pBT->pNextSegment->pPrevSegment = pNeighbour;
pBT->pNextSegment = pNeighbour;
pNeighbour->type = btt_free;
pNeighbour->uSize = pBT->uSize - uSize;
pNeighbour->base = pBT->base + uSize;
pNeighbour->psMapping = pBT->psMapping;
pBT->uSize = uSize;
return pNeighbour;
}
/*
* ###################################################################
* Función :
* Descripción :
* Parmámetros :
* Retorna :
* ###################################################################
*/
OS_TIMER *OSTimerCreate(int16u period, bool periodic, OS_TIMER_CALLBACK callback, OS_ERROR *error)
{
OS_TIMER *timer;
if(error == NULL) // Si no tengo donde hacer registo del error, salir
return NULL;
period /= OS_TICK_MAX_COUNTER; // Normalizar
if(period == 0){ // El timer no puede ser instantaneo
*error = OS_ERROR_TIMER_ZERO_PERIOD;
return NULL;
}
if(callback == NULL){ // Funcion valida?
*error = OS_ERROR_TIMER_CALLBACK_NULL;
return NULL;
}
timer = OSAllocMem(sizeof(OS_TIMER));
if(timer == NULL){ // Verificar que se reservo la memoria
*error = OS_ERROR_TIMER_NO_MEMORY;
return NULL;
}
timer->OSTimerPeriod = period; // Inicializar campos
timer->OSTimerCounter = period; //
timer->OSPeriodic = periodic; //
timer->OSTimerCallback = callback; //
timer->OSEnabled = false; //
timer->OSTimerNext = NULL; //
timer->OSTimerPrev = NULL; //
*error = OS_ERROR_NONE;
return timer;
}
static BT *
_BuildBT (IMG_UINTPTR_T base, IMG_SIZE_T uSize)
{
BT *pBT;
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(BT),
(IMG_VOID **)&pBT, IMG_NULL,
"Boundary Tag") != PVRSRV_OK)
{
return IMG_NULL;
}
OSMemSet(pBT, 0, sizeof(BT));
#if defined(VALIDATE_ARENA_TEST)
pBT->ui32BoundaryTagID = ++ui32BoundaryTagID;
#endif
pBT->type = btt_free;
pBT->base = base;
pBT->uSize = uSize;
return pBT;
}
PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData)
{
PVRSRV_ERROR eError;
IMG_HANDLE hBlockAlloc;
PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
phOsPrivateData,
&hBlockAlloc,
"Environment per Process Data");
if (eError != PVRSRV_OK)
{
*phOsPrivateData = IMG_NULL;
PVR_DPF((PVR_DBG_ERROR, "%s: OSAllocMem failed (%d)", __FUNCTION__, eError));
return eError;
}
psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)*phOsPrivateData;
OSMemSet(psEnvPerProc, 0, sizeof(*psEnvPerProc));
psEnvPerProc->hBlockAlloc = hBlockAlloc;
LinuxMMapPerProcessConnect(psEnvPerProc);
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function PVRSRVTimeTraceBufferCreate
@Description
Create a trace buffer.
Note: We assume that this will only be called once per process.
@Input ui32PID : PID of the process that is creating the buffer
@Return none
******************************************************************************/
PVRSRV_ERROR PVRSRVTimeTraceBufferCreate(IMG_UINT32 ui32PID)
{
sTimeTraceBuffer *psBuffer;
PVRSRV_ERROR eError = PVRSRV_OK;
eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(sTimeTraceBuffer) + TIME_TRACE_BUFFER_SIZE,
(IMG_VOID **)&psBuffer, IMG_NULL,
"Time Trace Buffer");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferCreate: Error allocating trace buffer"));
return eError;
}
OSMemSet(psBuffer, 0, TIME_TRACE_BUFFER_SIZE);
if (!HASH_Insert(g_psBufferTable, (IMG_UINTPTR_T) ui32PID, (IMG_UINTPTR_T) psBuffer))
{
OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(sTimeTraceBuffer) + TIME_TRACE_BUFFER_SIZE,
psBuffer, NULL);
PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferCreate: Error adding trace buffer to hash table"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
return eError;
}
PVRSRV_ERROR SysCreateConfigData(PVRSRV_SYSTEM_CONFIG **ppsSysConfig)
{
PLAT_DATA *psPlatData;
PVRSRV_ERROR eError;
psPlatData = OSAllocMem(sizeof(PLAT_DATA));
OSMemSet(psPlatData, 0, sizeof(PLAT_DATA));
/* Query the Emu for reg and IRQ information */
eError = PCIInitDev(psPlatData);
if (eError != PVRSRV_OK)
{
goto e0;
}
/* Save data for this device */
sSysConfig.pasDevices[0].hSysData = (IMG_HANDLE) psPlatData;
#if defined (LMA)
/* Save private data for the physical memory heaps */
gsPhysHeapConfig[0].hPrivData = (IMG_HANDLE) psPlatData;
gsPhysHeapConfig[1].hPrivData = (IMG_HANDLE) psPlatData;
#endif
*ppsSysConfig = &sSysConfig;
/* Ion is only supported on UMA builds */
#if (defined(SUPPORT_ION) && (!defined(LMA)))
IonInit(NULL);
#endif
gpsPlatData = psPlatData;
return PVRSRV_OK;
e0:
return eError;
}
/* SyncRegisterConnection */
PVRSRV_ERROR SyncRegisterConnection(SYNC_CONNECTION_DATA **ppsSyncConnectionData)
{
SYNC_CONNECTION_DATA *psSyncConnectionData;
PVRSRV_ERROR eError;
psSyncConnectionData = OSAllocMem(sizeof(SYNC_CONNECTION_DATA));
if (psSyncConnectionData == IMG_NULL)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto fail_alloc;
}
eError = OSLockCreate(&psSyncConnectionData->hLock, LOCK_TYPE_PASSIVE);
if (eError != PVRSRV_OK)
{
goto fail_lockcreate;
}
dllist_init(&psSyncConnectionData->sListHead);
psSyncConnectionData->ui32RefCount = 1;
*ppsSyncConnectionData = psSyncConnectionData;
return PVRSRV_OK;
fail_lockcreate:
OSFreeMem(psSyncConnectionData);
fail_alloc:
PVR_ASSERT(eError != PVRSRV_OK);
return eError;
}
struct LinuxMemArea *NewAllocPagesLinuxMemArea(u32 ui32Bytes,
u32 ui32AreaFlags)
{
struct LinuxMemArea *psLinuxMemArea;
u32 ui32PageCount;
struct page **pvPageList;
void *hBlockPageList;
s32 i;
enum PVRSRV_ERROR eError;
psLinuxMemArea = LinuxMemAreaStructAlloc();
if (!psLinuxMemArea)
goto failed_area_alloc;
ui32PageCount = RANGE_TO_PAGES(ui32Bytes);
eError = OSAllocMem(0, sizeof(*pvPageList) * ui32PageCount,
(void **)&pvPageList, &hBlockPageList);
if (eError != PVRSRV_OK)
goto failed_page_list_alloc;
for (i = 0; i < ui32PageCount; i++) {
pvPageList[i] = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, 0);
if (!pvPageList[i])
goto failed_alloc_pages;
}
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES,
pvPageList, NULL, 0, NULL, PAGE_ALIGN(ui32Bytes),
"unknown", 0);
#endif
psLinuxMemArea->eAreaType = LINUX_MEM_AREA_ALLOC_PAGES;
psLinuxMemArea->uData.sPageList.pvPageList = pvPageList;
psLinuxMemArea->uData.sPageList.hBlockPageList = hBlockPageList;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEM_AREAS)
DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
#endif
return psLinuxMemArea;
failed_alloc_pages:
for (i--; i >= 0; i--)
__free_pages(pvPageList[i], 0);
OSFreeMem(0, sizeof(*pvPageList) * ui32PageCount, pvPageList,
hBlockPageList);
failed_page_list_alloc:
LinuxMemAreaStructFree(psLinuxMemArea);
failed_area_alloc:
PVR_DPF(PVR_DBG_ERROR, "%s: failed", __func__);
return NULL;
}
IMG_BOOL BM_Alloc(void *hDevMemHeap, struct IMG_DEV_VIRTADDR *psDevVAddr,
size_t uSize, u32 *pui32Flags, u32 uDevVAddrAlignment,
void **phBuf)
{
struct BM_BUF *pBuf;
struct BM_CONTEXT *pBMContext;
struct BM_HEAP *psBMHeap;
struct SYS_DATA *psSysData;
u32 uFlags;
if (pui32Flags == NULL) {
PVR_DPF(PVR_DBG_ERROR, "BM_Alloc: invalid parameter");
PVR_DBG_BREAK;
return IMG_FALSE;
}
uFlags = *pui32Flags;
PVR_DPF(PVR_DBG_MESSAGE,
"BM_Alloc (uSize=0x%x, uFlags=0x%x, uDevVAddrAlignment=0x%x)",
uSize, uFlags, uDevVAddrAlignment);
if (SysAcquireData(&psSysData) != PVRSRV_OK)
return IMG_FALSE;
psBMHeap = (struct BM_HEAP *)hDevMemHeap;
pBMContext = psBMHeap->pBMContext;
if (uDevVAddrAlignment == 0)
uDevVAddrAlignment = 1;
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct BM_BUF),
(void **)&pBuf, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "BM_Alloc: BM_Buf alloc FAILED");
return IMG_FALSE;
}
OSMemSet(pBuf, 0, sizeof(struct BM_BUF));
if (AllocMemory(pBMContext, psBMHeap, psDevVAddr, uSize, uFlags,
uDevVAddrAlignment, pBuf) != IMG_TRUE) {
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct BM_BUF), pBuf,
NULL);
PVR_DPF(PVR_DBG_ERROR, "BM_Alloc: AllocMemory FAILED");
return IMG_FALSE;
}
PVR_DPF(PVR_DBG_MESSAGE, "BM_Alloc (uSize=0x%x, uFlags=0x%x)=%08X",
uSize, uFlags, pBuf);
pBuf->ui32RefCount = 1;
pvr_get_ctx(pBMContext);
*phBuf = (void *) pBuf;
*pui32Flags = uFlags | psBMHeap->ui32Attribs;
return IMG_TRUE;
}
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;
}
PVRSRV_ERROR
PVRSRVSyncRecordAddKM(
SYNC_RECORD_HANDLE * phRecord,
SYNC_PRIMITIVE_BLOCK * hServerSyncPrimBlock,
IMG_UINT32 ui32FwBlockAddr,
IMG_UINT32 ui32SyncOffset,
IMG_BOOL bServerSync,
IMG_UINT32 ui32ClassNameSize,
const IMG_CHAR *pszClassName)
{
struct SYNC_RECORD * psSyncRec;
PVRSRV_ERROR eError = PVRSRV_OK;
if (!phRecord)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
*phRecord = IMG_NULL;
psSyncRec = OSAllocMem(sizeof(*psSyncRec));
if (!psSyncRec)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto fail_alloc;
}
psSyncRec->psServerSyncPrimBlock = hServerSyncPrimBlock;
psSyncRec->ui32SyncOffset = ui32SyncOffset;
psSyncRec->ui32FwBlockAddr = ui32FwBlockAddr;
psSyncRec->eRecordType = bServerSync? SYNC_RECORD_TYPE_SERVER: SYNC_RECORD_TYPE_CLIENT;
if(pszClassName)
{
if (ui32ClassNameSize >= SYNC_MAX_CLASS_NAME_LEN)
ui32ClassNameSize = SYNC_MAX_CLASS_NAME_LEN - 1;
/* Copy over the class name annotation */
OSStringNCopy(psSyncRec->szClassName, pszClassName, ui32ClassNameSize);
psSyncRec->szClassName[ui32ClassNameSize] = 0;
}
else
{
/* No class name annotation */
psSyncRec->szClassName[0] = 0;
}
OSLockAcquire(g_hSyncRecordListLock);
dllist_add_to_head(&g_sSyncRecordList, &psSyncRec->sNode);
OSLockRelease(g_hSyncRecordListLock);
*phRecord = (SYNC_RECORD_HANDLE)psSyncRec;
fail_alloc:
return eError;
}
IMG_EXPORT PVRSRV_ERROR
PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_UINT32 ui32Flags,
IMG_SIZE_T uSize,
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,
"Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for meminfo"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psKernelMemInfo, 0, sizeof(*psKernelMemInfo));
ui32Flags &= ~PVRSRV_HAP_MAPTYPE_MASK;
ui32Flags |= PVRSRV_HAP_MULTI_PROCESS;
psKernelMemInfo->ui32Flags = ui32Flags;
psKernelMemInfo->uAllocSize = uSize;
if(OSAllocPages(psKernelMemInfo->ui32Flags,
psKernelMemInfo->uAllocSize,
(IMG_UINT32)HOST_PAGESIZE(),
IMG_NULL,
0,
IMG_NULL,
&psKernelMemInfo->pvLinAddrKM,
&psKernelMemInfo->sMemBlk.hOSMemHandle)
!= PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for block"));
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO),
psKernelMemInfo,
0);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* register with the resman */
psKernelMemInfo->sMemBlk.hResItem =
ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_MEM_INFO,
psKernelMemInfo,
0,
&FreeSharedSysMemCallBack);
*ppsKernelMemInfo = psKernelMemInfo;
return PVRSRV_OK;
}
static IMG_INT
PVRSRVBridgeTLTestIoctl(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_TLTESTIOCTL *psTLTestIoctlIN,
PVRSRV_BRIDGE_OUT_TLTESTIOCTL *psTLTestIoctlOUT,
CONNECTION_DATA *psConnection)
{
IMG_BYTE *psIn1Int = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PVRTL_TLTESTIOCTL);
PVR_UNREFERENCED_PARAMETER(psConnection);
{
psIn1Int = OSAllocMem(PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE));
if (!psIn1Int)
{
psTLTestIoctlOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto TLTestIoctl_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psTLTestIoctlIN->psIn1, PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE))
|| (OSCopyFromUser(NULL, psIn1Int, psTLTestIoctlIN->psIn1,
PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE)) != PVRSRV_OK) )
{
psTLTestIoctlOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto TLTestIoctl_exit;
}
psTLTestIoctlOUT->eError =
TLServerTestIoctlKM(
psTLTestIoctlIN->ui32Cmd,
psIn1Int,
psTLTestIoctlIN->ui32In2,
&psTLTestIoctlOUT->ui32Out1,
&psTLTestIoctlOUT->ui32Out2);
TLTestIoctl_exit:
if (psIn1Int)
OSFreeMem(psIn1Int);
return 0;
}
/*************************************************************************/ /*!
@Function OSPCISetDev
@Description Set a PCI device for subsequent use.
@Input pvPCICookie Pointer to OS specific PCI structure
@Input eFlags Flags
@Return PVRSRV_PCI_DEV_HANDLE Pointer to PCI device handle
*/ /**************************************************************************/
PVRSRV_PCI_DEV_HANDLE OSPCISetDev(IMG_VOID *pvPCICookie, HOST_PCI_INIT_FLAGS eFlags)
{
int err;
IMG_UINT32 i;
PVR_PCI_DEV *psPVRPCI;
psPVRPCI = OSAllocMem(sizeof(*psPVRPCI));
if (psPVRPCI == IMG_NULL)
{
printk(KERN_ERR "OSPCISetDev: Couldn't allocate PVR PCI structure\n");
return IMG_NULL;
}
psPVRPCI->psPCIDev = (struct pci_dev *)pvPCICookie;
psPVRPCI->ePCIFlags = eFlags;
err = pci_enable_device(psPVRPCI->psPCIDev);
if (err != 0)
{
printk(KERN_ERR "OSPCISetDev: Couldn't enable device (%d)\n", err);
OSFreeMem(psPVRPCI);
return IMG_NULL;
}
if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER) /* PRQA S 3358 */ /* misuse of enums */
{
pci_set_master(psPVRPCI->psPCIDev);
}
if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI) /* PRQA S 3358 */ /* misuse of enums */
{
#if defined(CONFIG_PCI_MSI)
err = pci_enable_msi(psPVRPCI->psPCIDev);
if (err != 0)
{
printk(KERN_ERR "OSPCISetDev: Couldn't enable MSI (%d)", err);
psPVRPCI->ePCIFlags &= ~HOST_PCI_INIT_FLAG_MSI; /* PRQA S 1474,3358,4130 */ /* misuse of enums */
}
#else
printk(KERN_ERR "OSPCISetDev: MSI support not enabled in the kernel");
#endif
}
/* Initialise the PCI resource tracking array */
for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
{
psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
}
return (PVRSRV_PCI_DEV_HANDLE)psPVRPCI;
}
/*!
******************************************************************************
@Function PVRSRVRegisterDevice
@Description
registers a device with the system
@Input psSysData : sysdata structure
@Input pfnRegisterDevice : device registration function
@Input ui32SOCInterruptBit : SoC interrupt bit for this device
@Output pui32DeviceIndex : unique device key (for case of multiple identical devices)
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData,
PVRSRV_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*),
IMG_UINT32 ui32SOCInterruptBit,
IMG_UINT32 *pui32DeviceIndex)
{
PVRSRV_ERROR eError;
PVRSRV_DEVICE_NODE *psDeviceNode;
/* Allocate device node */
if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE),
(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);
}
OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
eError = pfnRegisterDevice(psDeviceNode);
if (eError != PVRSRV_OK)
{
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
/*not nulling pointer, out of scope*/
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to register device"));
return (PVRSRV_ERROR_DEVICE_REGISTER_FAILED);
}
/*
make the refcount 1 and test on this to initialise device
at acquiredevinfo. On release if refcount is 1, deinitialise
and when refcount is 0 (sysdata de-alloc) deallocate the device
structures
*/
psDeviceNode->ui32RefCount = 1;
psDeviceNode->psSysData = psSysData;
psDeviceNode->ui32SOCInterruptBit = ui32SOCInterruptBit;
/* all devices need a unique identifier */
AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex);
/* and finally insert the device into the dev-list */
List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
/* and copy back index */
*pui32DeviceIndex = psDeviceNode->sDevId.ui32DeviceIndex;
return PVRSRV_OK;
}
static IMG_INT
PVRSRVBridgeEnumerateDevices(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_ENUMERATEDEVICES *psEnumerateDevicesIN,
PVRSRV_BRIDGE_OUT_ENUMERATEDEVICES *psEnumerateDevicesOUT,
CONNECTION_DATA *psConnection)
{
PVRSRV_DEVICE_IDENTIFIER *psDeviceIdentifierInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_ENUMERATEDEVICES);
PVR_UNREFERENCED_PARAMETER(psConnection);
PVR_UNREFERENCED_PARAMETER(psEnumerateDevicesIN);
psEnumerateDevicesOUT->psDeviceIdentifier = psEnumerateDevicesIN->psDeviceIdentifier;
{
psDeviceIdentifierInt = OSAllocMem(PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER));
if (!psDeviceIdentifierInt)
{
psEnumerateDevicesOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto EnumerateDevices_exit;
}
}
psEnumerateDevicesOUT->eError =
PVRSRVEnumerateDevicesKM(
&psEnumerateDevicesOUT->ui32NumDevices,
psDeviceIdentifierInt);
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psEnumerateDevicesOUT->psDeviceIdentifier, (PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER)))
|| (OSCopyToUser(NULL, psEnumerateDevicesOUT->psDeviceIdentifier, psDeviceIdentifierInt,
(PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER))) != PVRSRV_OK) )
{
psEnumerateDevicesOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto EnumerateDevices_exit;
}
EnumerateDevices_exit:
if (psDeviceIdentifierInt)
OSFreeMem(psDeviceIdentifierInt);
return 0;
}
IMG_INTERNAL
PVRSRV_ERROR _DevmemMemDescAlloc(DEVMEM_MEMDESC **ppsMemDesc)
{
DEVMEM_MEMDESC *psMemDesc;
PVRSRV_ERROR eError;
psMemDesc = OSAllocMem(sizeof(DEVMEM_MEMDESC));
if (psMemDesc == IMG_NULL)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto failAlloc;
}
/* Structure must be zero'd incase it needs to be freed before it is initialised! */
OSMemSet(psMemDesc, 0, sizeof(DEVMEM_MEMDESC));
eError = OSLockCreate(&psMemDesc->hLock, LOCK_TYPE_PASSIVE);
if (eError != PVRSRV_OK)
{
goto failMDLock;
}
eError = OSLockCreate(&psMemDesc->sDeviceMemDesc.hLock, LOCK_TYPE_PASSIVE);
if (eError != PVRSRV_OK)
{
goto failDMDLock;
}
eError = OSLockCreate(&psMemDesc->sCPUMemDesc.hLock, LOCK_TYPE_PASSIVE);
if (eError != PVRSRV_OK)
{
goto failCMDLock;
}
*ppsMemDesc = psMemDesc;
return PVRSRV_OK;
failCMDLock:
OSLockDestroy(psMemDesc->sDeviceMemDesc.hLock);
failDMDLock:
OSLockDestroy(psMemDesc->hLock);
failMDLock:
OSFreeMem(psMemDesc);
failAlloc:
PVR_ASSERT(eError != PVRSRV_OK);
return eError;
}
/*!
******************************************************************************
@Function LinuxEventObjectAdd
@Description
Linux wait object addition
@Input hOSEventObjectList : Event object list handle
@Output phOSEventObject : Pointer to the event object handle
@Return PVRSRV_ERROR : Error code
******************************************************************************/
PVRSRV_ERROR LinuxEventObjectAdd(IMG_HANDLE hOSEventObjectList, IMG_HANDLE *phOSEventObject)
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject;
PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST*)hOSEventObjectList;
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
PVRSRV_PER_PROCESS_DATA *psPerProc;
unsigned long ulLockFlags;
psPerProc = PVRSRVPerProcessData(ui32PID);
if (psPerProc == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: Couldn't find per-process data"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* allocate completion variable */
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT),
(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;
}
INIT_LIST_HEAD(&psLinuxEventObject->sList);
atomic_set(&psLinuxEventObject->sTimeStamp, 0);
psLinuxEventObject->ui32TimeStampPrevious = 0;
#if defined(DEBUG)
psLinuxEventObject->ui32Stats = 0;
#endif
init_waitqueue_head(&psLinuxEventObject->sWait);
psLinuxEventObject->psLinuxEventObjectList = psLinuxEventObjectList;
psLinuxEventObject->hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_EVENT_OBJECT,
psLinuxEventObject,
0,
&LinuxEventObjectDeleteCallback);
write_lock_irqsave(&psLinuxEventObjectList->sLock, ulLockFlags);
list_add(&psLinuxEventObject->sList, &psLinuxEventObjectList->sList);
write_unlock_irqrestore(&psLinuxEventObjectList->sLock, ulLockFlags);
*phOSEventObject = psLinuxEventObject;
return PVRSRV_OK;
}
PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData)
{
PVRSRV_ERROR eError;
IMG_HANDLE hBlockAlloc;
PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
phOsPrivateData,
&hBlockAlloc,
"Environment per Process Data");
if (eError != PVRSRV_OK)
{
*phOsPrivateData = IMG_NULL;
PVR_DPF((PVR_DBG_ERROR, "%s: OSAllocMem failed (%d)", __FUNCTION__, eError));
return eError;
}
psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)*phOsPrivateData;
OSMemSet(psEnvPerProc, 0, sizeof(*psEnvPerProc));
psEnvPerProc->hBlockAlloc = hBlockAlloc;
/* Linux specific mmap processing */
LinuxMMapPerProcessConnect(psEnvPerProc);
#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
/* Linked list of PVRSRV_FILE_PRIVATE_DATA structures */
INIT_LIST_HEAD(&psEnvPerProc->sDRMAuthListHead);
#endif
#if defined(SUPPORT_ION)
OSSNPrintf(psEnvPerProc->azIonClientName, ION_CLIENT_NAME_SIZE, "pvr_ion_client-%d", OSGetCurrentProcessIDKM());
psEnvPerProc->psIONClient =
ion_client_create(gpsIonDev,
psEnvPerProc->azIonClientName);
if (IS_ERR_OR_NULL(psEnvPerProc->psIONClient))
{
PVR_DPF((PVR_DBG_ERROR, "OSPerProcessPrivateDataInit: Couldn't create "
"ion client for per process data"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
#endif /* defined(SUPPORT_ION) */
return PVRSRV_OK;
}
PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData,
PVRSRV_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*),
IMG_UINT32 ui32SOCInterruptBit,
IMG_UINT32 *pui32DeviceIndex)
{
PVRSRV_ERROR eError;
PVRSRV_DEVICE_NODE *psDeviceNode;
if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE),
(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);
}
OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
eError = pfnRegisterDevice(psDeviceNode);
if (eError != PVRSRV_OK)
{
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to register device"));
return (PVRSRV_ERROR_DEVICE_REGISTER_FAILED);
}
psDeviceNode->ui32RefCount = 1;
psDeviceNode->psSysData = psSysData;
psDeviceNode->ui32SOCInterruptBit = ui32SOCInterruptBit;
AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex);
List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
*pui32DeviceIndex = psDeviceNode->sDevId.ui32DeviceIndex;
return PVRSRV_OK;
}
static IMG_INT
PVRSRVBridgePVRSRVPDumpComment(IMG_UINT32 ui32DispatchTableEntry,
PVRSRV_BRIDGE_IN_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentIN,
PVRSRV_BRIDGE_OUT_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentOUT,
CONNECTION_DATA *psConnection)
{
IMG_CHAR *uiCommentInt = IMG_NULL;
PVR_UNREFERENCED_PARAMETER(psConnection);
{
uiCommentInt = OSAllocMem(PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR));
if (!uiCommentInt)
{
psPVRSRVPDumpCommentOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto PVRSRVPDumpComment_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPVRSRVPDumpCommentIN->puiComment, PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiCommentInt, psPVRSRVPDumpCommentIN->puiComment,
PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psPVRSRVPDumpCommentOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto PVRSRVPDumpComment_exit;
}
psPVRSRVPDumpCommentOUT->eError =
PDumpCommentKM(
uiCommentInt,
psPVRSRVPDumpCommentIN->ui32Flags);
PVRSRVPDumpComment_exit:
if (uiCommentInt)
OSFreeMem(uiCommentInt);
return 0;
}
static struct BT *_BuildBT(u32 base, size_t uSize)
{
struct BT *pBT;
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct BT),
(void **) &pBT, NULL) != PVRSRV_OK)
return NULL;
pBT->type = btt_free;
pBT->base = base;
pBT->uSize = uSize;
return pBT;
}
static struct BT *_BuildSpanMarker(u32 base, size_t uSize)
{
struct BT *pBT;
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct BT),
(void **) &pBT, NULL) != PVRSRV_OK)
return NULL;
pBT->type = btt_span;
pBT->base = base;
pBT->uSize = uSize;
pBT->psMapping = NULL;
return pBT;
}
/* PVRSRVConnectionConnect*/
PVRSRV_ERROR PVRSRVConnectionConnect(IMG_PVOID *ppvPrivData, IMG_PVOID pvOSData)
{
PVRSRV_DATA *psPVRSRVData = PVRSRVGetPVRSRVData();
CONNECTION_DATA *psConnection;
PVRSRV_ERROR eError = PVRSRV_OK;
/* Allocate per-process data area */
psConnection = OSAllocMem(sizeof(*psConnection));
if (psConnection == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionConnect: Couldn't allocate per-process data (%d)", eError));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet(psConnection, 0, sizeof(*psConnection));
/* Call environment specific per process init function */
eError = OSConnectionPrivateDataInit(&psConnection->hOsPrivateData, pvOSData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionConnect: OSConnectionPrivateDataInit failed (%d)", eError));
goto failure;
}
/* Allocate handle base for this process */
eError = PVRSRVAllocHandleBase(&psConnection->psHandleBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionConnect: Couldn't allocate handle base for process (%d)", eError));
goto failure;
}
/* Create a resource manager context for the process */
eError = PVRSRVResManConnect(psPVRSRVData->hResManDeferContext, &psConnection->hResManContext);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionConnect: Couldn't register with the resource manager"));
goto failure;
}
*ppvPrivData = psConnection;
return eError;
failure:
(IMG_VOID)FreeConnectionData(psConnection);
return eError;
}
PVRSRV_ERROR PVRSRVRegisterPowerDevice(IMG_UINT32 ui32DeviceIndex,
PFN_PRE_POWER pfnPrePower,
PFN_POST_POWER pfnPostPower,
PFN_PRE_CLOCKSPEED_CHANGE pfnPreClockSpeedChange,
PFN_POST_CLOCKSPEED_CHANGE pfnPostClockSpeedChange,
IMG_HANDLE hDevCookie,
PVRSRV_DEV_POWER_STATE eCurrentPowerState,
PVRSRV_DEV_POWER_STATE eDefaultPowerState)
{
PVRSRV_ERROR eError;
SYS_DATA *psSysData;
PVRSRV_POWER_DEV *psPowerDevice;
if (pfnPrePower == IMG_NULL &&
pfnPostPower == IMG_NULL)
{
return PVRSRVRemovePowerDevice(ui32DeviceIndex);
}
SysAcquireData(&psSysData);
eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_POWER_DEV),
(IMG_VOID **)&psPowerDevice, IMG_NULL,
"Power Device");
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterPowerDevice: Failed to alloc PVRSRV_POWER_DEV"));
return eError;
}
psPowerDevice->pfnPrePower = pfnPrePower;
psPowerDevice->pfnPostPower = pfnPostPower;
psPowerDevice->pfnPreClockSpeedChange = pfnPreClockSpeedChange;
psPowerDevice->pfnPostClockSpeedChange = pfnPostClockSpeedChange;
psPowerDevice->hDevCookie = hDevCookie;
psPowerDevice->ui32DeviceIndex = ui32DeviceIndex;
psPowerDevice->eCurrentPowerState = eCurrentPowerState;
psPowerDevice->eDefaultPowerState = eDefaultPowerState;
List_PVRSRV_POWER_DEV_Insert(&(psSysData->psPowerDeviceList), psPowerDevice);
return (PVRSRV_OK);
}
enum PVRSRV_ERROR PVRSRVRegisterPowerDevice(u32 ui32DeviceIndex,
enum PVRSRV_ERROR (*pfnPrePower)(void *, enum PVR_POWER_STATE,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPostPower)(void *, enum PVR_POWER_STATE,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPreClockSpeedChange)(void *, IMG_BOOL,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPostClockSpeedChange)(void *, IMG_BOOL,
enum PVR_POWER_STATE),
void *hDevCookie, enum PVR_POWER_STATE eCurrentPowerState,
enum PVR_POWER_STATE eDefaultPowerState)
{
enum PVRSRV_ERROR eError;
struct SYS_DATA *psSysData;
struct PVRSRV_POWER_DEV *psPowerDevice;
if (pfnPrePower == NULL && pfnPostPower == NULL)
return PVRSRVRemovePowerDevice(ui32DeviceIndex);
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK)
return eError;
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_POWER_DEV),
(void **) &psPowerDevice, NULL);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVRegisterPowerDevice: "
"Failed to alloc struct PVRSRV_POWER_DEV");
return eError;
}
psPowerDevice->pfnPrePower = pfnPrePower;
psPowerDevice->pfnPostPower = pfnPostPower;
psPowerDevice->pfnPreClockSpeedChange = pfnPreClockSpeedChange;
psPowerDevice->pfnPostClockSpeedChange = pfnPostClockSpeedChange;
psPowerDevice->hDevCookie = hDevCookie;
psPowerDevice->ui32DeviceIndex = ui32DeviceIndex;
psPowerDevice->eCurrentPowerState = eCurrentPowerState;
psPowerDevice->eDefaultPowerState = eDefaultPowerState;
psPowerDevice->psNext = psSysData->psPowerDeviceList;
psSysData->psPowerDeviceList = psPowerDevice;
return PVRSRV_OK;
}
PVRSRV_ERROR PhysHeapRegister(PHYS_HEAP_CONFIG *psConfig,
PHYS_HEAP **ppsPhysHeap)
{
PHYS_HEAP *psNew;
PHYS_HEAP *psTmp;
PVR_DPF_ENTERED;
if (psConfig->eType == PHYS_HEAP_TYPE_UNKNOWN)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
/* Check this heap ID isn't already in use */
psTmp = g_psPhysHeapList;
while (psTmp)
{
if (psTmp->ui32PhysHeapID == psConfig->ui32PhysHeapID)
{
return PVRSRV_ERROR_PHYSHEAP_ID_IN_USE;
}
psTmp = psTmp->psNext;
}
psNew = OSAllocMem(sizeof(PHYS_HEAP));
if (psNew == IMG_NULL)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
psNew->ui32PhysHeapID = psConfig->ui32PhysHeapID;
psNew->eType = psConfig->eType;
psNew->sStartAddr = psConfig->sStartAddr;
psNew->uiSize = psConfig->uiSize;
psNew->psMemFuncs = psConfig->psMemFuncs;
psNew->hPrivData = psConfig->hPrivData;
psNew->ui32RefCount = 0;
psNew->pszPDumpMemspaceName = psConfig->pszPDumpMemspaceName;
psNew->psNext = g_psPhysHeapList;
g_psPhysHeapList = psNew;
*ppsPhysHeap = psNew;
PVR_DPF_RETURN_RC1(PVRSRV_OK, *ppsPhysHeap);
}
