自学教程：C++ IMG_ASSERT函数代码示例

/*!****************************************************************************** @Function				SYSDEVKM_OpenDevice******************************************************************************/IMG_RESULT SYSDEVKM_OpenDevice(	IMG_CHAR *				pszDeviceName,	IMG_HANDLE *			phSysDevHandle){	IMG_UINT32			ui32Result;	SYSDEVKM_sDevice *	psDevice;	/* Allocate a device structure...*/	psDevice = IMG_MALLOC(sizeof(*psDevice));	IMG_ASSERT(psDevice != IMG_NULL);	if (psDevice == IMG_NULL)	{		return IMG_ERROR_OUT_OF_MEMORY;	}	IMG_MEMSET(psDevice, 0, sizeof(*psDevice));	/* Get the device id...*/	ui32Result = SYSDEVU_GetDeviceId(pszDeviceName, &psDevice->ui32DeviceId);	IMG_ASSERT(ui32Result == IMG_SUCCESS);	if (ui32Result != IMG_SUCCESS)	{		return ui32Result;	}	/* Return the device handle...*/	*phSysDevHandle = psDevice;	/* Update count...*/	SYSOSKM_DisableInt();	gsActiveOpenCnt++;	SYSOSKM_EnableInt();	return IMG_SUCCESS;}

/*!****************************************************************************** @Function                POOL_PoolCreate******************************************************************************/IMG_RESULT POOL_PoolCreate(    IMG_HANDLE *  phPoolHandle){    POOL_sResPool *  psResPool;    IMG_UINT32       ui32Result;    IMG_ASSERT(gInitialised);    /* Allocate a pool structure...*/    psResPool = IMG_MALLOC(sizeof(*psResPool));    IMG_ASSERT(psResPool != IMG_NULL);    if (psResPool == IMG_NULL)    {        return IMG_ERROR_OUT_OF_MEMORY;    }    IMG_MEMSET(psResPool, 0, sizeof(*psResPool));    /* Initialise the pool info...*/    LST_init(&psResPool->sFreeResList);    LST_init(&psResPool->sActResList);    /* Create mutex...*/    ui32Result = SYSOSKM_CreateMutex(&psResPool->hMutexHandle);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        goto error_create_mutex;    }    /* Create context for the Id generator...*/    ui32Result = IDGEN_CreateContext(POOL_IDGEN_MAX_ID, POOL_IDGEN_BLOCK_SIZE,IMG_FALSE, &psResPool->hIdGenHandle);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        goto error_create_context;    }    /* Disable interrupts.  */    SYSOSKM_DisableInt();    /* Add to list of pools...*/    LST_add(&gsPoolList, psResPool);    /* Enable interrupts.  */    SYSOSKM_EnableInt();    /* Return handle to pool...*/    *phPoolHandle = psResPool;    return IMG_SUCCESS;    /* Error handling. */error_create_context:    SYSOSKM_DestroyMutex(psResPool->hMutexHandle);error_create_mutex:    IMG_FREE(psResPool);    return ui32Result;}

static uint32_tjpg_vlc_decode_direct_symbols(const vlc_symbol_code_jpeg * symbol_code, uint16_t * const table_ram, const uint32_t width,                              const uint32_t leading) {    uint32_t offset, limit;    uint16_t entry;    /* this function is only for codes short enough to produce valid symbols */    IMG_ASSERT( symbol_code->code_length <= leading + width );    IMG_ASSERT( symbol_code->code_length > leading );    /* lose bits already decoded */    offset = symbol_code->code << leading;    offset &= JPG_MAKE_MASK(JPG_VLC_MAX_CODE_LEN);    /* convert truncated code to offset */    offset >>= (JPG_VLC_MAX_CODE_LEN - width);    /* expand offset to encorporate undefined code bits */    limit = offset + (1 << (width - (symbol_code->code_length - leading)));    /* for all code variants - insert symbol into the decode direct result table */    entry = jpg_vlc_valid_symbol( symbol_code, leading );    for (; offset < limit; offset++) {        table_ram[offset] = entry;    }    /* return the number of entries written */    return limit - offset - 1;}

/*!****************************************************************************** @Function              VXDIO_PDUMPDisableCmds******************************************************************************/IMG_UINT32VXDIO_PDUMPDisableCmds(    const IMG_HANDLE    hVxdCtx,    IMG_UINT32          ui32MemRegion,    IMG_UINT32          ui32Offset,    IMG_UINT32          ui32DisableFlags){    VXDIO_sContext *psVxdCtx  = (VXDIO_sContext *)hVxdCtx;    IMG_ASSERT(psVxdCtx != IMG_NULL);    IMG_ASSERT(psVxdCtx->ui32MemSpaceCount != 0);    if (ui32MemRegion >= psVxdCtx->ui32MemSpaceCount)    {        REPORT(REPORT_MODULE_VXDIO, REPORT_ERR,               "A valid VXD memory region must be provided");        return IMG_ERROR_INVALID_PARAMETERS;    }    TALPDUMP_DisableCmds(psVxdCtx->pahMemSpace[ui32MemRegion],        ui32Offset, ui32DisableFlags);    return IMG_SUCCESS;}

/*!****************************************************************************** @Function				SYSDEVU_InvokeDevKmLisr******************************************************************************/IMG_RESULT SYSDEVU_InvokeDevKmLisr(	IMG_UINT32					ui32DeviceId){    IMG_UINT32  ui32Result;	SYSDEVU_sInfo *dev = findDeviceById(ui32DeviceId);	if(!gSysDevInitialised || !dev)	{		IMG_ASSERT(gSysDevInitialised);		IMG_ASSERT(dev);		ui32Result = IMG_ERROR_INVALID_PARAMETERS;        return ui32Result;	}	IMG_ASSERT(dev->pfnDevKmLisr != IMG_NULL);    if(dev->pfnDevKmLisr == IMG_NULL)	{		ui32Result = IMG_ERROR_INVALID_PARAMETERS;        return ui32Result;	}	dev->pfnDevKmLisr(dev->pvParam);    return IMG_SUCCESS;}

static IMG_PHYSADDR CpuKmAddrToCpuPAddr(    SYSMEM_Heap *  heap,    IMG_VOID *     pvCpuKmAddr){    IMG_PHYSADDR ret = 0;    if(virt_addr_valid(pvCpuKmAddr))    {        /* direct mapping of kernel addresses.         * this works for kmalloc.         */        ret = virt_to_phys(pvCpuKmAddr);    }    else    {        /* walk the page table.         * Works for ioremap, vmalloc, and kmalloc(GPF_DMA),          but not, for some reason, kmalloc(GPF_KERNEL)         */        struct page * pg = vmalloc_to_page(pvCpuKmAddr);        if(pg) {            ret = page_to_phys(pg);        }        else {            IMG_ASSERT(!"vmalloc_to_page failure");        }    }    IMG_ASSERT(ret != 0);    return ret;}

/*!******************************************************************************** @Function				POOL_Free @Description Free an sObject previously allocated from an sObject sPool. @Input	    psPool      : Object Pool pointer. @Output    hObject     : Handle to the object to be freed. @Return    IMG_RESULT  : IMG_SUCCESS or an error code.********************************************************************************/IMG_RESULT POOL_Free(    struct  sPool * const       psPool,             IMG_HANDLE const    hObject){    struct sObject * psObject = IMG_NULL;    IMG_UINT32 ui32Result = IMG_ERROR_FATAL;    IMG_ASSERT(IMG_NULL != psPool);    IMG_ASSERT(IMG_NULL != hObject);    if (IMG_NULL == psPool ||        IMG_NULL == hObject)    {        ui32Result = IMG_ERROR_INVALID_PARAMETERS;        goto error;    }    psObject = (struct sObject *)hObject;    psObject->psNext = psPool->psObjects;    psPool->psObjects = psObject;    ui32Result = IMG_SUCCESS;error:    return ui32Result;}

IMG_VOID SYSDEVU_GetMemoryInfo(	IMG_UINT32			ui32DeviceId,	IMG_VOID **			ppvKmMemory,	IMG_PHYSADDR *			ppaPhysMemory,	IMG_UINT64 *		pui64MemSize,	IMG_UINT64 *		pui64DevMemoryBase) {#ifndef __FAKE_HW__	SYSDEVU_sInfo *dev = findDeviceById(ui32DeviceId);	if(!gSysDevInitialised || !dev)	{		IMG_ASSERT(gSysDevInitialised);		IMG_ASSERT(dev);		return;	}	if(ppvKmMemory)		*ppvKmMemory = dev->pui32KmMemBase;	if(ppaPhysMemory)		*ppaPhysMemory = dev->paPhysMemBase;	if(pui64MemSize)		*pui64MemSize = dev->ui32MemSize;	if(pui64DevMemoryBase)		*pui64DevMemoryBase = (IMG_UINT64)dev->pui64DevMemoryBase;#endif}

/*!****************************************************************************** @Function				mmu_GetTileRegion******************************************************************************/IMG_INT32 mmu_GetTileRegion(    IMG_UINT32				ui32MMUId,    IMG_UINT64              ui64DevVirtAddr){    IMG_UINT32              i;	MMU_sContextCB			*psContextCB = mmu_GetContext(ui32MMUId);	IMG_ASSERT(gbMMUInitialised);	IMG_ASSERT (psContextCB);    /* If the context has tile regions...*/    if (psContextCB->bTiledRegionDefined)    {        /* Loop over regions...*/        for (i=0; i<MMU_NUMBER_OF_TILED_REGIONS; i++)        {            /* If region defined...*/            if (psContextCB->asTiledRegionCB[i].ui64Size != 0)            {                /* If device virtual address is within a tiled region...*/                if (                        (ui64DevVirtAddr >= psContextCB->asTiledRegionCB[i].ui64DevVirtAddr) &&                        (ui64DevVirtAddr < (psContextCB->asTiledRegionCB[i].ui64DevVirtAddr+psContextCB->asTiledRegionCB[i].ui64Size))                        )                {                    return i;                }            }        }    }    return -1;}

/*!****************************************************************************** @Function				LOG_Enable******************************************************************************/IMG_VOID LOG_Enable(	IMG_UINT32		ui32Api,	LOG_eLevel		eLevel,	LOG_eLogMode	eLogMode){	if (ui32Api == LOG_ALL_APIS)	{		/* Loop over APIs */		for (ui32Api=0; ui32Api<API_ID_MAX; ui32Api++)		{			LOG_Enable(ui32Api, eLevel, eLogMode);		}	}	else	{		IMG_ASSERT(gInitialised);		/* Ensure that the API is valid */		IMG_ASSERT(ui32Api < API_ID_MAX);		gbLogEnabled = IMG_TRUE;		/* Set log level and mode */		gaeLogApi[ui32Api].eLevel	= eLevel;		gaeLogApi[ui32Api].eLogMode = eLogMode;	}}

/*!****************************************************************************** @Function                SYSDEVU_SetPowerState******************************************************************************/IMG_VOID SYSDEVU_SetPowerState(    IMG_HANDLE           hSysDevHandle,    SYSOSKM_ePowerState  ePowerState,    IMG_BOOL             forAPM){	SYSDEVU_sInfo *  psDevice = (SYSDEVU_sInfo *)hSysDevHandle;    IMG_ASSERT(gSysDevInitialised);    IMG_ASSERT(hSysDevHandle != IMG_NULL);    if (hSysDevHandle == IMG_NULL)    {        return;    }    switch(ePowerState) {    case SYSOSKM_POWERSTATE_S5:        // suspend        SYSDEVU_HandleSuspend(psDevice, forAPM);        break;    case SYSOSKM_POWERSTATE_S0:        // resume        SYSDEVU_HandleResume(psDevice, forAPM);        break;    }}

/*!****************************************************************************** @Function				MMU_Setup******************************************************************************/IMG_RESULT MMU_Setup (	IMG_UINT32		ui32MMUId,	IMG_UINT64		ui64PCAddress,	IMG_UINT32		ui32MMUType,	MMU_pfnReadMem	pfnReadMem	){	MMU_sContextCB *psContextCB;	IMG_ASSERT(gbMMUInitialised);	IMG_ASSERT(ui32MMUId < MMU_NUMBER_OF_CONTEXTS);		psContextCB = &gasContextCBs[ui32MMUId];	if (psContextCB->ui32MMUType == MMU_TYPE_NONE)		gui32ContextsInUse++;	memset(psContextCB, 0, sizeof(MMU_sContextCB));	psContextCB->ui64PCAddress = ui64PCAddress;	psContextCB->ui32MMUType = ui32MMUType;	psContextCB->ui32BusWidth = gasMMUTypesLookup[ui32MMUType].ui32BusWidth;	psContextCB->pfnReadLookup = pfnReadMem;	psContextCB->pfnReadPage = pfnReadMem;		return IMG_SUCCESS;}

/*!****************************************************************************** @Function                SYSDEVU_RegisterDevKmLisr******************************************************************************/IMG_VOID SYSDEVU_RegisterDevKmLisr(    IMG_HANDLE             hSysDevHandle,    SYSDEVU_pfnDevKmLisr  pfnDevKmLisr,    IMG_VOID *             pvParam){	SYSDEVU_sInfo *  dev = (SYSDEVU_sInfo *)hSysDevHandle;    IMG_ASSERT(gSysDevInitialised);    IMG_ASSERT(hSysDevHandle != IMG_NULL);    if (hSysDevHandle == IMG_NULL)    {        return;    }	if (			(pfnDevKmLisr != IMG_NULL) &&			(dev->pfnDevKmLisr != IMG_NULL)		)	{		IMG_ASSERT(dev->pfnDevKmLisr == pfnDevKmLisr);		IMG_ASSERT(dev->pvParam == pvParam);	}	else	{		dev->pfnDevKmLisr = pfnDevKmLisr;		dev->pvParam = pvParam;	}}

/*!****************************************************************************** @Function                SYSDEVU_CpuPAddrToDevPAddr******************************************************************************/IMG_PHYSADDR SYSDEVU_CpuPAddrToDevPAddr(    IMG_HANDLE  hSysDevHandle,    IMG_PHYSADDR  paCpuPAddr){    SYSDEVU_sInfo *  psSysDev = (SYSDEVU_sInfo *)hSysDevHandle;    IMG_ASSERT(gSysDevInitialised);    IMG_ASSERT(hSysDevHandle != IMG_NULL);    if (hSysDevHandle == IMG_NULL)    {        return 0;    }    /*     * If conversion routines isn't added by the customer ( using sysdev ),     *  we assume that it's a unified memory model where pa == dev_pa     */    if (!psSysDev->ops->paddr_to_devpaddr)    	return paCpuPAddr;    return psSysDev->ops->paddr_to_devpaddr(psSysDev, paCpuPAddr);}

/*!****************************************************************************** @Function				SYSDEVU_Initialise******************************************************************************/IMG_RESULT SYSDEVU_Initialise(IMG_VOID){	/* If not initialised...*/	if (!gSysDevInitialised)	{		IMG_RESULT eResult;		eResult = SYSOSKM_CreateAtomic(&gsActiveOpenCnt);		IMG_ASSERT(eResult == IMG_SUCCESS);		if (eResult != IMG_SUCCESS)		{			return eResult;		}		LST_init(&gsDevList);		eResult = SYSOSKM_CreateMutex(&hNextDeviceIdMutex);		IMG_ASSERT(eResult == IMG_SUCCESS);		if (eResult != IMG_SUCCESS)		{			return eResult;		}		/* use a magic number to help detect dereferences of		   DeviceId when (wrongly) casted as a pointer */		gui32NextDeviceId = 0xbeef00;		/* Now we are initialised...*/		gSysDevInitialised = IMG_TRUE;	}	return IMG_SUCCESS;}

/*!****************************************************************************** @Function				SYSDEVKM_CpuPAddrToDevPAddr******************************************************************************/IMG_PHYSADDR SYSDEVKM_CpuPAddrToDevPAddr(	IMG_HANDLE				hSysDevHandle,	IMG_PHYSADDR				paCpuPAddr){	SYSDEVKM_sDevice *	psDevice = (SYSDEVKM_sDevice *)hSysDevHandle;		IMG_ASSERT(gSysDevInitialised);	IMG_ASSERT(hSysDevHandle != IMG_NULL);	if (hSysDevHandle == IMG_NULL)	{		return 0;	}	if (asDevMem[psDevice->ui32DeviceId].ui64MemorySize == 0)	{		SYSDEVU_GetMemoryInfo(			psDevice->ui32DeviceId,			&asDevMem[psDevice->ui32DeviceId].pvKmMemory,			&asDevMem[psDevice->ui32DeviceId].paPhysMemory,			&asDevMem[psDevice->ui32DeviceId].ui64MemorySize,			&asDevMem[psDevice->ui32DeviceId].ui64DevMemoryBase		);	}	paCpuPAddr -= (IMG_UINTPTR)asDevMem[psDevice->ui32DeviceId].pvKmMemory;	paCpuPAddr += asDevMem[psDevice->ui32DeviceId].ui64DevMemoryBase;	IMG_ASSERT(paCpuPAddr < asDevMem[psDevice->ui32DeviceId].ui64MemorySize);	/* One-to-one CPU to device mapping...*/	return paCpuPAddr;}

/*!****************************************************************************** @Function				MMU_GetPageDirEntryAddress******************************************************************************/IMG_UINT64 MMU_GetPageDirEntryAddress (	IMG_UINT32				ui32MMUId,	IMG_UINT64              ui64DevVirtAddr,	IMG_UINT64				ui64PCEntry){	MMU_sContextCB			*psContextCB = mmu_GetContext(ui32MMUId);	IMG_UINT64				ui64PageDirAddr, ui64PageDirEntryAddr;	IMG_ASSERT(gbMMUInitialised);	IMG_ASSERT (psContextCB);		switch (psContextCB->ui32MMUType)	{	case MMU_TYPE_VP_40BIT_ADDR:		ui64PageDirAddr = MMU_MASK_AND_SHIFTL(ui64PCEntry, MMU_PC_PDP_MASK, MMU_PC_PDP_SHIFT);		break;	case MMU_TYPE_NONE:	case MMU_TYPE_4K_PAGES_32BIT_ADDR:	case MMU_TYPE_VARIABLE_PAGE_32BIT_ADDR:	case MMU_TYPE_4K_PAGES_36BIT_ADDR:	case MMU_TYPE_4K_PAGES_40BIT_ADDR:		ui64PageDirAddr = psContextCB->ui64PCAddress;		break;	default:		IMG_ASSERT(IMG_FALSE);	}	ui64PageDirEntryAddr = ui64PageDirAddr;	ui64PageDirEntryAddr |= MMU_MASK_AND_SHIFTR(ui64DevVirtAddr, THIS_BUS_WIDTH.ui64Vaddr_PDMask, THIS_BUS_WIDTH.ui32Vaddr_PDShift );	return ui64PageDirEntryAddr;}

/*!****************************************************************************** @Function                pciio_DeviceAttach******************************************************************************/static IMG_RESULT pciio_DeviceAttach(    IMG_CHAR *      pszDevName,    SECDEV_eMapArea  eArea){    IMG_UINT32  ui32Result;    IMG_ASSERT(gpszDevName != IMG_NULL);    if (gpszDevName != IMG_NULL)    {        IMG_ASSERT(IMG_STRCMP(pszDevName, gpszDevName) == 0);    }    else    {        return IMG_ERROR_GENERIC_FAILURE;    }    /* In this implementation we initialise the PCI component */    ui32Result = pciio_PciDetectDevice(eArea);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        return ui32Result;    }    return IMG_SUCCESS;}

IMG_VOID MMU_SetTiledRegion(	IMG_UINT32				ui32MMUId,    IMG_UINT32              ui32TiledRegionNo,	IMG_UINT64				ui64DevVirtAddr,    IMG_UINT64              ui64Size,    IMG_UINT32              ui32XTileStride){	MMU_sContextCB *psContextCB;	IMG_UINT32		i;	IMG_ASSERT(gbMMUInitialised);	/* Check MMU Id and Tiled Id are Valid */	IMG_ASSERT(ui32MMUId < MMU_NUMBER_OF_CONTEXTS);	IMG_ASSERT(ui32TiledRegionNo < MMU_NUMBER_OF_TILED_REGIONS);	psContextCB = &gasContextCBs[ui32MMUId];	IMG_ASSERT(psContextCB->ui32MMUType < MMU_NO_TYPES);	IMG_ASSERT(psContextCB->ui32MMUType != MMU_TYPE_NONE);	    /* Set the tiled region parameters...*/    psContextCB->asTiledRegionCB[ui32TiledRegionNo].ui64DevVirtAddr    = ui64DevVirtAddr;    psContextCB->asTiledRegionCB[ui32TiledRegionNo].ui64Size           = ui64Size;    psContextCB->asTiledRegionCB[ui32TiledRegionNo].ui32XTileStride    = ui32XTileStride;    /* See if tiled region defined...*/    psContextCB->bTiledRegionDefined = IMG_FALSE;    for (i=0; i<MMU_NUMBER_OF_TILED_REGIONS; i++)    {        if (psContextCB->asTiledRegionCB[i].ui64Size != 0)        {            psContextCB->bTiledRegionDefined = IMG_TRUE;        }    }}

/*!****************************************************************************** @Function				LOG_ElapseTimeStart******************************************************************************/IMG_VOID LOG_ElapseTimeStart(	LOG_sElapseTime	*	psElapseTime){	IMG_ASSERT(0);#if 0 	volatile IMG_UINT32 *       pTimer = LOG_TIMER_ADDR;	IMG_UINT32					ui32Time = *pTimer;	/* Cannot start when the previous count was not finished */	IMG_ASSERT ( psElapseTime->bCounting == IMG_FALSE );	/* If the "looks" like teh fisrt time...*/	if (psElapseTime->ui32TimeStamp == 0)	{		/* Reset minimum */		psElapseTime->ui32MinTime = 0xFFFFFFFF;	}	/* Set the time stamp */	psElapseTime->ui32TimeStamp = ui32Time;	psElapseTime->ui32StartCount ++;	psElapseTime->bCounting = IMG_TRUE;#endif}

/*!******************************************************************************@Function				ADDR_CxMallocRes******************************************************************************/IMG_RESULT ADDR_CxMallocRes(            ADDR_sContext * const   psContext,    const   IMG_CHAR * const        pszName,            IMG_UINT64              ui64Size,            IMG_UINT64 * const      pui64Base){    IMG_RESULT ui32Result = IMG_ERROR_FATAL;    IMG_ASSERT(IMG_NULL != psContext);    IMG_ASSERT(IMG_NULL != pszName);    IMG_ASSERT(IMG_NULL != pui64Base);    if(IMG_NULL == psContext ||        IMG_NULL == pszName ||        IMG_NULL == pui64Base)    {        ui32Result = IMG_ERROR_INVALID_PARAMETERS;        goto error_invalid_parameters;    }    addr_alloc_Lock();    ui32Result = addr_CxMalloc1(psContext, pszName, ui64Size, 1, pui64Base);    addr_alloc_UnLock();    IMG_ASSERT(IMG_SUCCESS == ui32Result);    if (IMG_SUCCESS != ui32Result)    {        //error handling    }error_invalid_parameters:    return ui32Result;}

IMG_RESULT SYSDEVU_UnRegisterDevice(	SYSDEVU_sInfo *psInfo){	IMG_UINT32			ui32Result;	IMG_ASSERT(gSysDevInitialised);	if(!LST_remove(&gsDevList, psInfo))	{		IMG_ASSERT(IMG_FALSE);		return IMG_ERROR_GENERIC_FAILURE;	}	gui32NoDevices--;	ui32Result = DMANKM_UnRegisterDevice(psInfo->sDevInfo.pszDeviceName);	IMG_ASSERT(ui32Result == IMG_SUCCESS);	if(ui32Result != IMG_SUCCESS)		return ui32Result;	/* Initialise parts of the device info structure...*/	psInfo->bDevLocated	= IMG_FALSE;	psInfo->pvLocParam = IMG_NULL;	/* Return success...*/	return IMG_SUCCESS;}

/*!******************************************************************************@Function				ADDR_CxMalloc1Res******************************************************************************/IMG_RESULT ADDR_CxMalloc1Res(            ADDR_sContext * const   psContext,    const   IMG_CHAR * const        pszName,            IMG_UINT64              ui64Size,            IMG_UINT64              ui64Alignment,            IMG_UINT64 * const      pui64Base){    IMG_RESULT ui32Result;    IMG_ASSERT(IMG_NULL != psContext);    IMG_ASSERT(IMG_NULL != pui64Base);    if(IMG_NULL == psContext ||        IMG_NULL == pui64Base)    {        ui32Result = IMG_ERROR_INVALID_PARAMETERS;        goto error_invalid_parameters;    }    addr_alloc_Lock();    ui32Result = addr_CxMalloc1(psContext, pszName, ui64Size, ui64Alignment, pui64Base);    addr_alloc_UnLock();error_invalid_parameters:    return ui32Result;}

/*!****************************************************************************** @Function				SYSDEVU_RegisterDevKmLisr******************************************************************************/IMG_VOID SYSDEVU_RegisterDevKmLisr(	IMG_UINT32					ui32DeviceId,	SYSDEVKM_pfnDevKmLisr		pfnDevKmLisr,    IMG_VOID *                  pvParam){	SYSDEVU_sInfo *dev = findDeviceById(ui32DeviceId);	if(!gSysDevInitialised || !dev)	{		IMG_ASSERT(gSysDevInitialised);		IMG_ASSERT(dev);		return;	}	if (			(pfnDevKmLisr != IMG_NULL) &&			(dev->pfnDevKmLisr != IMG_NULL)		)	{		IMG_ASSERT(dev->pfnDevKmLisr == pfnDevKmLisr);		IMG_ASSERT(dev->pvParam == pvParam);	}	else	{		dev->pfnDevKmLisr = pfnDevKmLisr;		dev->pvParam = pvParam;	}}

/*!****************************************************************************** @Function                PALLOCKM_CloneAlloc******************************************************************************/IMG_RESULT PALLOCKM_CloneAlloc(    IMG_UINT32    ui32AllocId,    IMG_HANDLE    hResBHandle,    IMG_HANDLE *  phResHandle,    IMG_UINT32 *  pui32AllocId){    IMG_UINT32  ui32Result;    IMG_HANDLE  hResHandle;    /* Get the resource info from the id...*/    ui32Result = RMAN_GetResource(ui32AllocId, PALLOC_RES_TYPE_1, IMG_NULL, &hResHandle);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        return ui32Result;    }    /* Create a cloned reference...*/    ui32Result = RMAN_CloneResourceHandle(hResHandle, hResBHandle, phResHandle, pui32AllocId);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        return ui32Result;    }    /* Return IMG_SUCCESS...*/    return IMG_SUCCESS;}

/*!****************************************************************************** @Function				SYSDEVU_RegisterDevices******************************************************************************/IMG_RESULT SYSDEVU_RegisterDevice(	SYSDEVU_sInfo *psInfo){	IMG_UINT32			ui32Result;	IMG_ASSERT(gSysDevInitialised);	/* Initialise parts of the device info structure...*/	psInfo->bDevLocated	= IMG_FALSE;	psInfo->pvLocParam = IMG_NULL;	SYSOSKM_LockMutex(hNextDeviceIdMutex);	psInfo->ui32DeviceId = gui32NextDeviceId;	gui32NextDeviceId += 1;	SYSOSKM_UnlockMutex(hNextDeviceIdMutex);	/* Register the device with the device manager...*/	ui32Result = DMANKM_RegisterDevice(psInfo->sDevInfo.pszDeviceName, psInfo->sDevInfo.pfnDevRegister);	IMG_ASSERT(ui32Result == IMG_SUCCESS);	if (ui32Result != IMG_SUCCESS)	{		return ui32Result;	}	/* Initialise the devices...*/	LST_add(&gsDevList, psInfo);	gui32NoDevices++;	/* Return success...*/	return IMG_SUCCESS;}

/*!****************************************************************************** @Function				SYSDEVKM_GetCpuKmAddr******************************************************************************/IMG_RESULT SYSDEVKM_GetCpuKmAddr(	IMG_HANDLE				hSysDevHandle,	SYSDEVKM_eRegionId		eRegionId,	IMG_VOID **				ppvCpuKmAddr,	IMG_UINT32 *			pui32Size){	SYSDEVKM_sDevice *		psDevice = (SYSDEVKM_sDevice *)hSysDevHandle;	IMG_UINT32				ui32Result;		IMG_ASSERT(hSysDevHandle != IMG_NULL);	if (hSysDevHandle == IMG_NULL)	{		return IMG_ERROR_GENERIC_FAILURE;	}	ui32Result = SYSDEVU_GetCpuAddrs(psDevice->ui32DeviceId, eRegionId, ppvCpuKmAddr, IMG_NULL, pui32Size);	IMG_ASSERT(ui32Result == IMG_SUCCESS);	if (ui32Result != IMG_SUCCESS)	{		return ui32Result;	}	return IMG_SUCCESS;}

/*!****************************************************************************** @Function              palloc_fnCompConnect******************************************************************************/static IMG_RESULT palloc_fnCompConnect (    IMG_HANDLE   hAttachHandle,    IMG_VOID **  ppvCompAttachmentData){    PALLOC_sAttachContext *  psAttachContext;    IMG_UINT32               ui32Result;    IMG_CHAR *               pszDeviceName;    /* Allocate attachment context structure...*/    psAttachContext = IMG_MALLOC(sizeof(*psAttachContext));    IMG_ASSERT(psAttachContext != IMG_NULL);    if (psAttachContext == IMG_NULL)    {        return IMG_ERROR_OUT_OF_MEMORY;    }    IMG_MEMSET(psAttachContext, 0, sizeof(*psAttachContext));    /* Ensure the resource manager is initialised...*/    ui32Result = RMAN_Initialise();    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        goto error_rman_init;    }    /* Create a bucket for the resources...*/    ui32Result = RMAN_CreateBucket(&psAttachContext->hResBHandle);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        goto error_rman_bucket;    }    /* Get device information...*/    psAttachContext->hDevHandle = DMANKM_GetDevHandleFromAttach(hAttachHandle);    pszDeviceName = DMANKM_GetDeviceName(psAttachContext->hDevHandle);    ui32Result = SYSDEVU_OpenDevice(pszDeviceName, &psAttachContext->hSysDevHandle);    IMG_ASSERT(ui32Result == IMG_SUCCESS);    if (ui32Result != IMG_SUCCESS)    {        goto error_sysdev_open;    }    /* Return attachment context...*/    *ppvCompAttachmentData = psAttachContext;    /* Return success...*/    return IMG_SUCCESS;    /* Error handling. */error_sysdev_open:    RMAN_DestroyBucket(psAttachContext->hResBHandle);error_rman_bucket:error_rman_init:    IMG_FREE(psAttachContext);    return ui32Result;}