Пример #1
0
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              dmankm_DisconnectComps

 ******************************************************************************/
static IMG_RESULT dmankm_DisconnectComps(DMANKM_sConnContext * psConnContext) 
{
	DMANKM_sAttachContext * psAttachContext;
	IMG_UINT32 ui32Result;

	psAttachContext = (DMANKM_sAttachContext *) LST_first(
			&psConnContext->sAttachList);
	while (psAttachContext != IMG_NULL ) {
		/* If there is a disconnect function...*/
		if (psAttachContext->sCompAttach.pfnCompDisconnect != IMG_NULL ) {
			/* Call it...*/
			ui32Result = psAttachContext->sCompAttach.pfnCompDisconnect(
					psAttachContext, psAttachContext->pvCompAttachmentData);
			if (ui32Result != IMG_SUCCESS) {
                IMG_ASSERT(ui32Result == IMG_SUCCESS);
				return ui32Result;
			}
		}

		/* Remove, free the name and control block...*/
		LST_remove(&psConnContext->sAttachList, psAttachContext);
		RMAN_DestroyBucket(psAttachContext->hResBHandle);
		RMAN_FreeResource(psAttachContext->hResHandle);
		IMG_FREE(psAttachContext->pszCompName);
		IMG_FREE(psAttachContext);
		psAttachContext = (DMANKM_sAttachContext *) LST_first(
				&psConnContext->sAttachList);
	}

	/* Return success...*/
	return IMG_SUCCESS;
}
/*!
 ******************************************************************************

 @Function				DMANKM_UnRegisterDevice

 ******************************************************************************/
IMG_RESULT DMANKM_UnRegisterDevice(IMG_CHAR * pszDeviceName) 
{
	DMANKM_sDevContext *devContext;
	DMANKM_sConnContext *devConnection;
	IMG_RESULT ui32Result;

	devContext = (DMANKM_sDevContext *) LST_first(&gsDevList);
	while (devContext != IMG_NULL ) {
		if (!strcmp(devContext->pszDeviceName, pszDeviceName)) {
			devConnection = (DMANKM_sConnContext *) LST_first(
					&devContext->sConnList);
			while (devConnection != IMG_NULL ) {
				/* If this is the init connection....*/
				if (devConnection->bInitConn) {
					devConnection = (DMANKM_sConnContext *) LST_next(
							&devContext->sConnList);
				} else {
					/* Lock the device...*/
					DMANKM_LockDeviceContext(devContext);

					/* Call on to the kernel function...*/
					ui32Result = DMANKM_CloseDevice(devContext, devConnection,
							DMAN_DCONN_ABORT);
					IMG_ASSERT(ui32Result == IMG_SUCCESS);

					// NOTE: We do not unlock the device as this will be done by
					//	     DMANKM_DevDisconnectComplete().
					//					/* Unlock the device...*/
					//					DMANKM_UnlockDeviceContext(hDevHandle);

					/* Move to next connection...*/
					devConnection = (DMANKM_sConnContext *) LST_first(
							&devContext->sConnList);
				}
			}

			SYSOSKM_DestroyMutex(devContext->hMutexHandle);

			/* Remove entries in debug file system */
#ifdef IMG_KERNEL_MODULE
			//if (devContext->psDgRoot) {
			//	debugfs_remove_recursive(devContext->psDgRoot);
			//}
#endif
			LST_remove(&gsDevList, devContext);

			IMG_FREE(devContext->pszDeviceName);
			IMG_FREE(devContext);

			return IMG_SUCCESS;
		}
		devContext = LST_next(devContext);
	}
	return IMG_ERROR_GENERIC_FAILURE;
}
Пример #4
0
/*!
******************************************************************************

 @Function              RESOURCE_ListRemove

******************************************************************************/
IMG_RESULT
RESOURCE_ListRemove(
    LST_T     *  psList,
    IMG_VOID  *  pvItem
)
{
    RESOURCE_sListElem    * psListElem = IMG_NULL;
    IMG_UINT32              ui32Result;

    /* Check input params. */
    IMG_ASSERT(IMG_NULL != psList);
    IMG_ASSERT(IMG_NULL != pvItem);
    if (psList == IMG_NULL ||
        pvItem == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error;
    }

    /* Find the specified item in the list. */
    psListElem = LST_first(psList);
    while (psListElem)
    {
        if (psListElem->pvItem == pvItem)
        {
            if (*psListElem->pui32RefCount != 0)
            {
                REPORT(REPORT_MODULE_RESOURCE, REPORT_WARNING,
                    "Element removed from list whilst still in use");
            }

            /* Remove the item from the list. */
            LST_remove(psList, psListElem);

            /* Free the stream unit queue element. */
            IMG_FREE(psListElem);
            psListElem = IMG_NULL;
            return IMG_SUCCESS;
        }

        psListElem = LST_next(psListElem);
    }

    DEBUG_REPORT(REPORT_MODULE_RESOURCE,
        "Item could not be located to remove from RESOURCE list");

    return IMG_ERROR_COULD_NOT_OBTAIN_RESOURCE;

error:
    return ui32Result;
}
Пример #5
0
/*!
******************************************************************************

 @Function                POOL_ResAlloc

******************************************************************************/
IMG_RESULT POOL_ResAlloc(
    IMG_HANDLE  hPoolHandle,
    IMG_HANDLE  hPoolResHandle
)
{
    POOL_sResPool *   psResPool  = hPoolHandle;
    POOL_sResource *  psResource = hPoolResHandle;
    IMG_UINT32              ui32Result;

    IMG_ASSERT(gInitialised);
    IMG_ASSERT(psResPool != IMG_NULL);
    IMG_ASSERT(hPoolResHandle != IMG_NULL);

    if (!gInitialised ||
        psResPool == IMG_NULL ||
        hPoolResHandle == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error_nolock;
    }

    /* Lock the pool...*/
    SYSOSKM_LockMutex(psResPool->hMutexHandle);

    /* Remove resource from free list...*/
    LST_remove(&psResPool->sFreeResList, psResource);

    /* Add to active list...*/
    LST_add(&psResPool->sActResList, psResource);
    psResource->ui32RefCnt++;

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

    /* Return IMG_SUCCESS...*/
    return IMG_SUCCESS;

error_nolock:
    return ui32Result;
}
/*!
 ******************************************************************************

 @Function				DMANKM_RegisterDevice

 ******************************************************************************/
IMG_RESULT DMANKM_RegisterDevice(IMG_CHAR * pszDeviceName,
		DMANKM_pfnDevRegister pfnDevRegister) 
{
	DMANKM_sDevContext * psDevContext;
	IMG_UINT32 ui32Result;

	/* If the device context list is not initialised...*/
	if (!gbDevListInitialised) {
		/* Initialise the device context list...*/
		LST_init(&gsDevList);

		gbDevListInitialised = IMG_TRUE;
	}

	/* Locate the device - ensure it's not registered twice...*/
	ui32Result = DMANKM_LocateDevice(pszDeviceName,
			(IMG_HANDLE *) &psDevContext);
	if (ui32Result != IMG_ERROR_DEVICE_NOT_FOUND) {
        IMG_ASSERT(ui32Result == IMG_ERROR_DEVICE_NOT_FOUND);
		return IMG_ERROR_GENERIC_FAILURE;
	}

	/* Allocate a device context structure...*/
	psDevContext = IMG_MALLOC(sizeof(*psDevContext));
	if (psDevContext == IMG_NULL ) 
    {
        IMG_ASSERT(psDevContext != IMG_NULL);
		return IMG_ERROR_OUT_OF_MEMORY;
	}

	IMG_MEMSET(psDevContext, 0, sizeof(*psDevContext));

	/* Setup the device context...*/
	psDevContext->ui32DeviceId = gui32NextDeviceID;
	gui32NextDeviceID++;
	psDevContext->pszDeviceName = IMG_STRDUP(pszDeviceName);
	if (psDevContext->pszDeviceName == IMG_NULL ) 
    {
        IMG_ASSERT(psDevContext->pszDeviceName != IMG_NULL);
		ui32Result = IMG_ERROR_OUT_OF_MEMORY;
		goto error_dev_name;
	}
	psDevContext->pfnDevRegister = pfnDevRegister;
	psDevContext->ui8ApmPpmFlags = 0;
	ui32Result = SYSOSKM_CreateMutex(&psDevContext->hMutexHandle);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_create_mutex;
	}
	LST_init(&psDevContext->sConnList);

	/* Disable interrupts...*/
	SYSOSKM_DisableInt();

	/* Add device to list...*/
	LST_add(&gsDevList, psDevContext);

	/* Re-enable interrupts...*/
	SYSOSKM_EnableInt();

	/* If initialised...*/
	if (gDmanKmInitialised) {
		/* Call device registration function...*/
		ui32Result = psDevContext->pfnDevRegister(&psDevContext->sDevRegister);
		IMG_ASSERT(ui32Result == IMG_SUCCESS);
		if (ui32Result != IMG_SUCCESS) {
			goto error_dev_register;
		}

		/* Set default if required...*/
		if (psDevContext->sDevRegister.ui32ConnFlags == 0) {
			psDevContext->sDevRegister.ui32ConnFlags = DMAN_CFLAG_EXCLUSIVE;
		}
	}

	/* Return success...*/
	return IMG_SUCCESS;

	/* Error handling. */
	error_dev_register: SYSOSKM_DisableInt();
	LST_remove(&gsDevList, psDevContext);
	SYSOSKM_EnableInt();
	SYSOSKM_DestroyMutex(psDevContext->hMutexHandle);
	error_create_mutex:
	IMG_FREE(psDevContext->pszDeviceName);
	error_dev_name:
	IMG_FREE(psDevContext);

	return ui32Result;
}
/*!
 ******************************************************************************

 @Function				DMANKM_OpenDevice

 ******************************************************************************/
IMG_RESULT DMANKM_OpenDevice(IMG_HANDLE hDevHandle, DMAN_eOpenMode eOpenMode,
		IMG_HANDLE * phConnHandle, IMG_UINT32 * pui32ConnId) 
{
	DMANKM_sDevContext * psDevContext = (DMANKM_sDevContext *) hDevHandle;
	DMANKM_sConnContext * psConnContext;
	DMANKM_sConnContext * psInitConnContext = IMG_NULL;
	IMG_UINT32 ui32Result;
	IMG_HANDLE hProcessId;

	/* Check mode. */
	if ((eOpenMode != DMAN_OMODE_EXCLUSIVE)
			&& (eOpenMode != DMAN_OMODE_SHARED)) {
		IMG_ASSERT(IMG_FALSE);
		return IMG_ERROR_INVALID_PARAMETERS;
	}

	/* Loop over the device connections to see if this process already has a connection...*/
	hProcessId = SYSOSKM_GetProcessId();
	psConnContext = (DMANKM_sConnContext *) LST_first(&psDevContext->sConnList);
	while (psConnContext != IMG_NULL ) {
		/* If process already has a connection. */
		if (psConnContext->hProcessId == hProcessId) {
			/* Update the open count...*/
			psConnContext->ui32OpenCnt++;

			/* Return the connection handle and/or id...*/
			if (phConnHandle != IMG_NULL ) {
				*phConnHandle = psConnContext;
			}
			if (pui32ConnId != IMG_NULL ) {
				*pui32ConnId = psConnContext->ui32ConnId;
			}

			/* Return success...*/
			return IMG_SUCCESS;
		}

		/* Look at next connection. */
		psConnContext = (DMANKM_sConnContext *) LST_next(psConnContext);
	}

	/* See if we have a connection exclusive access required or only exclusive access available. */
	psConnContext = (DMANKM_sConnContext *) LST_first(&psDevContext->sConnList);
	if ((psConnContext != IMG_NULL )&&
	( (eOpenMode == DMAN_OMODE_EXCLUSIVE) ||
			(psConnContext->psDevContext->sDevRegister.ui32ConnFlags == DMAN_CFLAG_EXCLUSIVE) )
	){
	IMG_ASSERT(IMG_FALSE);
	return IMG_ERROR_DEVICE_UNAVAILABLE;
}

	/* Allocate connection context...*/
	psConnContext = IMG_MALLOC(sizeof(*psConnContext));
	if (psConnContext == IMG_NULL ) 
    {
        IMG_ASSERT(psConnContext != IMG_NULL);
		return IMG_ERROR_OUT_OF_MEMORY;
	}
	IMG_MEMSET(psConnContext, 0, sizeof(*psConnContext));

	/* Initialise list of resource allocator...*/
	LST_init(&psConnContext->sAttachList);

	/* Setup connection context...*/
	psConnContext->psDevContext = psDevContext;
	psConnContext->ui32OpenCnt = 1;
	psConnContext->hProcessId = hProcessId;

	/* Update the count of connections...*/
	psDevContext->ui32ConnCnt++;

	/* If this is the first connection...*/
	if (psDevContext->ui32ConnCnt == 1) {
		/* Create resource bucket for connections and attachments...*/
		RMAN_Initialise();
		ui32Result = RMAN_CreateBucket(&psDevContext->hResBHandle);
		IMG_ASSERT(ui32Result == IMG_SUCCESS);
		if (ui32Result != IMG_SUCCESS) {
			goto error_create_bucket;
		}
	}

	/* Add to list of connections...*/
	LST_add(&psDevContext->sConnList, psConnContext);
	ui32Result = RMAN_RegisterResource(psDevContext->hResBHandle,
			DMAN_CONN_TYPE_ID, IMG_NULL, psConnContext,
			&psConnContext->hResHandle, &psConnContext->ui32ConnId);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_register_resource;
	}

	/* Register with the Process Manager in case the process dies...*/
	ui32Result = PMAN_Initialise();
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_pman_init;
	}
	PMAN_RegisterProcessLostCb(dmankm_fnProcessLostCb, psConnContext,
			&psConnContext->hProcLostCbHandle);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_pman_register_cb;
	}

	/* If this the first connection and initialise function...*/
	if ((psDevContext->ui32ConnCnt == 1)
			&& (psDevContext->sDevRegister.pfnDevInit != IMG_NULL )) {
		/* Allocate implicit connection context...*/
		psInitConnContext = IMG_MALLOC(sizeof(*psInitConnContext));
		if (psInitConnContext == IMG_NULL ) 
        {
            IMG_ASSERT(psInitConnContext != IMG_NULL);
			ui32Result = IMG_ERROR_OUT_OF_MEMORY;
			goto error_init_conn_ctx;
		}
		IMG_MEMSET(psInitConnContext, 0, sizeof(*psInitConnContext));

		/* Associated this connection with the device and process...*/
		psInitConnContext->psDevContext = psDevContext;
		psInitConnContext->ui32OpenCnt = 1;
		psInitConnContext->hProcessId = hProcessId;

		/* Mark this as the init connection...*/
		psInitConnContext->bInitConn = IMG_TRUE;

		/* Add implicit to list of connections...*/
		LST_add(&psDevContext->sConnList, psInitConnContext);
		ui32Result = RMAN_RegisterResource(psDevContext->hResBHandle,
				DMAN_CONN_TYPE_ID, IMG_NULL, psInitConnContext,
				&psInitConnContext->hResHandle, &psInitConnContext->ui32ConnId);
		IMG_ASSERT(ui32Result == IMG_SUCCESS);
		if (ui32Result != IMG_SUCCESS) {
			goto error_register_resource_init_ctx;
		}

		IMG_ASSERT(
				(psDevContext->sDevRegister.ui32ConnFlags == DMAN_CFLAG_EXCLUSIVE) || (psDevContext->sDevRegister.ui32ConnFlags == DMAN_CFLAG_SHARED));

		/* If it's not a pseudo device...  */
		if ((psDevContext->sDevRegister.ui32DevFlags & DMAN_DFLAG_PSEUDO_DEVICE)
				== 0) {
			/* Open the device...*/
			ui32Result = SYSDEVU_OpenDevice(psDevContext->pszDeviceName,
					&psDevContext->hSysDevHandle);
			IMG_ASSERT(ui32Result == IMG_SUCCESS);
			if (ui32Result != IMG_SUCCESS) {
				goto error_open_device;
			}

			/* Power the device on.  */
			SYSDEVU_SetPowerState(psDevContext->hSysDevHandle,
					SYSOSKM_POWERSTATE_S0, IMG_FALSE);
		}

		ui32Result = psDevContext->sDevRegister.pfnDevInit(psDevContext,
				psInitConnContext, &psDevContext->pvDevInstanceData);
		if (ui32Result != IMG_SUCCESS) {
			REPORT(REPORT_MODULE_DMAN, REPORT_ERR, "dev init failed (%d)",
				ui32Result);
			goto error_dev_init;
		}

		/* If there is a Device Kernel mode HISR...*/
		if (psDevContext->sDevRegister.pfnDevKmHisr != IMG_NULL ) {
			IMG_ASSERT(psDevContext->sDevRegister.pfnDevKmLisr != IMG_NULL);
			ui32Result = SYSOSKM_CreateKmHisr(&dmankm_fnDevKmHisr, psDevContext,
					&psDevContext->hHISRHandle);
			IMG_ASSERT(ui32Result == IMG_SUCCESS);
			if (ui32Result != IMG_SUCCESS) {
				goto error_create_km_hisr;
			}
		}

		/* If there is a Device Kernel mode LISR...*/
		if (psDevContext->sDevRegister.pfnDevKmLisr != IMG_NULL ) {
			/* Register the LISR wrapper...*/
			SYSDEVU_RegisterDevKmLisr(psDevContext->hSysDevHandle,
					&dmankm_fnDevKmLisr, psDevContext);
		}
	}

	/* If connect/open function...*/
	if (psDevContext->sDevRegister.pfnDevConnect != IMG_NULL ) {
		ui32Result = psDevContext->sDevRegister.pfnDevConnect(psConnContext,
				psDevContext->pvDevInstanceData,
				&psConnContext->pvDevConnectionData);
		IMG_ASSERT(
				ui32Result == IMG_SUCCESS || ui32Result == IMG_ERROR_INTERRUPTED);
		if (ui32Result != IMG_SUCCESS && ui32Result != IMG_ERROR_INTERRUPTED) {
			goto error_dev_connect;
		}
	}

	/* Return the connection handle and/or id...*/
	if (phConnHandle != IMG_NULL ) {
		*phConnHandle = psConnContext;
	}
	if (pui32ConnId != IMG_NULL ) {
		*pui32ConnId = psConnContext->ui32ConnId;
	}

	/* Return success...*/
	return ui32Result;

	/* Error handling. */
error_dev_connect:
	/* If this not the first connection or there's no initialise function...*/
	if ((1 != psDevContext->ui32ConnCnt)
			|| (IMG_NULL == psDevContext->sDevRegister.pfnDevInit)) {
		/* ...skip de-initialisation of this part. */
		goto error_init_conn_ctx;
	}

	if (IMG_NULL != psDevContext->sDevRegister.pfnDevKmHisr) {
		SYSOSKM_DestroyKmHisr(psDevContext->hHISRHandle);
	}

error_create_km_hisr:
	if (IMG_NULL
			!= psDevContext->sDevRegister.pfnDevDeinit) {
		psDevContext->sDevRegister.pfnDevDeinit(psDevContext, psInitConnContext,
				psDevContext->pvDevInstanceData);
	}

error_dev_init:
	if ((psDevContext->sDevRegister.ui32DevFlags
			& DMAN_DFLAG_PSEUDO_DEVICE) == 0) {
		SYSDEVU_CloseDevice(psDevContext->hSysDevHandle);
	}

error_open_device:
	RMAN_FreeResource(psInitConnContext->hResHandle);

error_register_resource_init_ctx:
	LST_remove(&psDevContext->sConnList, psInitConnContext);
	IMG_FREE(psInitConnContext);

error_init_conn_ctx:
	PMAN_RemoveProcessLostCb(psConnContext->hProcLostCbHandle);
	/* release per-process resources in PMAN, allocated inside
	   PMAN_RegisterProcessLostCb. We have to use device disconnect,
	   although the device wasn't actually initialised, because no
	   other function is exposed by PMAN */
	PMAN_DevDisconnectComplete(hProcessId);

error_pman_register_cb:
error_pman_init:
	RMAN_FreeResource(psConnContext->hResHandle);

error_register_resource:
	LST_remove(&psDevContext->sConnList,psConnContext);
	if (1 == psDevContext->ui32ConnCnt) {
		RMAN_DestroyBucket(psDevContext->hResBHandle);
	}

error_create_bucket:
	psDevContext->ui32ConnCnt--;
	IMG_FREE(psConnContext);

	return ui32Result;
}
/*!
 ******************************************************************************

 @Function				DMANKM_AttachComponent

 ******************************************************************************/
IMG_RESULT DMANKM_AttachComponent(IMG_HANDLE hConnHandle,
		IMG_CHAR * pszCompName, DMANKM_pfnCompAttach pfnCompAttach,
		IMG_HANDLE * phAttachHandle, IMG_UINT32 * pui32AttachId) 
{
	DMANKM_sConnContext * psConnContext = (DMANKM_sConnContext *) hConnHandle;
	IMG_BOOL bFound;
	DMANKM_sAttachContext * psAttachContext;
	IMG_UINT32 ui32Result;

	IMG_ASSERT(gDmanKmInitialised);

	/* See if this component is already register with this connection...*/
	bFound = dman_LocateComponentKM(pszCompName, psConnContext,
			&psAttachContext);
	if (bFound) {
		/* Cross check name and attach function should be the same...*/
		IMG_ASSERT(psAttachContext->pfnCompAttach == pfnCompAttach);

		/* Return the attachment handle and/or id...*/
		if (phAttachHandle != IMG_NULL ) {
			*phAttachHandle = psAttachContext;
		}
		if (pui32AttachId != IMG_NULL ) {
			*pui32AttachId = psAttachContext->ui32AttachId;
		}

		return IMG_SUCCESS;
	}

	/* Allocate a attachment context structure...*/
	psAttachContext = IMG_MALLOC(sizeof(*psAttachContext));
	if (psAttachContext == IMG_NULL ) 
    {
        IMG_ASSERT(psAttachContext != IMG_NULL);
		return IMG_ERROR_OUT_OF_MEMORY;
	}
	IMG_MEMSET(psAttachContext, 0, sizeof(*psAttachContext));

	/* Copy the component name etc...*/
	psAttachContext->pszCompName = IMG_STRDUP(pszCompName);
	if (psAttachContext->pszCompName == IMG_NULL ) 
    {
        IMG_ASSERT(psAttachContext->pszCompName != IMG_NULL);
		ui32Result = IMG_ERROR_OUT_OF_MEMORY;
		goto error_comp_name;
	}
	psAttachContext->pfnCompAttach = pfnCompAttach;
	psAttachContext->psConnContext = psConnContext;
	ui32Result = RMAN_CreateBucket(&psAttachContext->hResBHandle);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_create_bucket;
	}

	/* Add to the attachment component list...*/
	LST_add(&psConnContext->sAttachList, psAttachContext);
	ui32Result = RMAN_RegisterResource(psConnContext->psDevContext->hResBHandle,
			DMAN_ATTACH_TYPE_ID, IMG_NULL, psAttachContext,
			&psAttachContext->hResHandle, &psAttachContext->ui32AttachId);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_register_resource;
	}

	/* Call components attach function...*/
	ui32Result = pfnCompAttach(psAttachContext, &psAttachContext->sCompAttach);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		goto error_comp_attach;
	}

	/* If connect/open function...*/
	if (psAttachContext->sCompAttach.pfnCompConnect != IMG_NULL ) {
		ui32Result = psAttachContext->sCompAttach.pfnCompConnect(
				psAttachContext, &psAttachContext->pvCompAttachmentData);
		IMG_ASSERT(ui32Result == IMG_SUCCESS);
		if (ui32Result != IMG_SUCCESS) {
			goto error_comp_connect;
		}
	}

	/* Return the attachment handle and/or id...*/
	if (phAttachHandle != IMG_NULL ) {
		*phAttachHandle = psAttachContext;
	}
	if (pui32AttachId != IMG_NULL ) {
		*pui32AttachId = psAttachContext->ui32AttachId;
	}

	/* Return success...*/
	return IMG_SUCCESS;

	/* Error handling. */
	error_comp_connect: error_comp_attach: RMAN_FreeResource(
			psAttachContext->hResHandle);
	error_register_resource: LST_remove(&psConnContext->sAttachList,
			psAttachContext);
	RMAN_DestroyBucket(psAttachContext->hResBHandle);
	error_create_bucket:
	IMG_FREE(psAttachContext->pszCompName);
	error_comp_name:
	IMG_FREE(psAttachContext);

	return ui32Result;
}
/*!
 ******************************************************************************

 @Function				DMANKM_DevDisconnectComplete

 ******************************************************************************/
IMG_RESULT DMANKM_DevDisconnectComplete(IMG_HANDLE hConnHandle) 
{
	IMG_UINT32 ui32Result;
	DMANKM_sConnContext * psConnContext = hConnHandle;
	DMANKM_sConnContext * psInitConnContext;
	DMANKM_sDevContext * psDevContext = psConnContext->psDevContext;
	IMG_HANDLE hProcessId;

	/* Disconnect components attached to this connection...*/
	ui32Result = dmankm_DisconnectComps(psConnContext);
	IMG_ASSERT(ui32Result == IMG_SUCCESS);
	if (ui32Result != IMG_SUCCESS) {
		return ui32Result;
	}

	/* Save the process id...*/
	hProcessId = psConnContext->hProcessId;

	/* Remove and free this connection...*/
	LST_remove(&psDevContext->sConnList, psConnContext);
	RMAN_FreeResource(psConnContext->hResHandle);
	IMG_FREE(psConnContext);

	/* Update the connection count...*/
	psDevContext->ui32ConnCnt--;

	/* If connection count 0...*/
	if (psDevContext->ui32ConnCnt == 0) {
		/* Deinitailise the device....*/
		psInitConnContext = (DMANKM_sConnContext *) LST_first(
				&psDevContext->sConnList);
        if(psInitConnContext == NULL)
        {
            IMG_ASSERT(psInitConnContext != IMG_NULL);
            return IMG_ERROR_GENERIC_FAILURE;
        }
        else
        {
            IMG_ASSERT(psInitConnContext->bInitConn);
        }

		/* Deregister the LISR...*/
		if (psDevContext->sDevRegister.pfnDevKmLisr != IMG_NULL ) {
			SYSDEVU_RemoveDevKmLisr(psDevContext->hSysDevHandle);
		}

		/* Deregister the HISR...*/
		if (psDevContext->sDevRegister.pfnDevKmHisr != IMG_NULL ) {
			if (psDevContext->hHISRHandle) {
				IMG_HANDLE HISRHandle = psDevContext->hHISRHandle;
				psDevContext->hHISRHandle = IMG_NULL;
				SYSOSKM_DestroyKmHisr(HISRHandle);
			}
		}

		/* If we have a deinitialise function...*/
		if (psDevContext->sDevRegister.pfnDevDeinit != IMG_NULL ) {
			psDevContext->sDevRegister.pfnDevDeinit(psDevContext,
					psInitConnContext, psDevContext->pvDevInstanceData);
		}

		if ((psDevContext->sDevRegister.ui32DevFlags & DMAN_DFLAG_PSEUDO_DEVICE)
				== 0) {
			/* Power the device off.  */
			SYSDEVU_SetPowerState(psDevContext->hSysDevHandle,
					SYSOSKM_POWERSTATE_S5, IMG_FALSE);
		}

		/* Disconnect components attached to the implicit connection...*/
		ui32Result = dmankm_DisconnectComps(psInitConnContext);
		IMG_ASSERT(ui32Result == IMG_SUCCESS);
		if (ui32Result != IMG_SUCCESS) {
			return ui32Result;
		}

		/* Remove and free the implicit connection...*/
		LST_remove(&psDevContext->sConnList, psInitConnContext);
		RMAN_FreeResource(psInitConnContext->hResHandle);
		IMG_FREE(psInitConnContext);

		/* Destroy the resource bucket used for connections and attachments...*/
		RMAN_DestroyBucket(psDevContext->hResBHandle);
		psDevContext->hResBHandle = IMG_NULL;

		/* If we opened the device with SYSDEVKM...*/
		if (psDevContext->hSysDevHandle != IMG_NULL ) {
			/* Close it...*/
			SYSDEVU_CloseDevice(psDevContext->hSysDevHandle);
			psDevContext->hSysDevHandle = IMG_NULL;
		}
	}

	/* Let the Process Manager know the connection has been broken...*/
	PMAN_DevDisconnectComplete(hProcessId);

	/* Unlock the device...*/
	DMANKM_UnlockDeviceContext(psDevContext);

	/* Return success...*/
	return IMG_SUCCESS;
}
Пример #10
0
/*!
******************************************************************************

 @Function                POOL_ResClone

******************************************************************************/
IMG_RESULT POOL_ResClone(
    IMG_HANDLE    hPoolResHandle,
    IMG_HANDLE *  phClonePoolResHandle,
    IMG_VOID **   ppvParam
)
{
    POOL_sResource *  psResource = hPoolResHandle;
    POOL_sResPool *   psResPool;
    POOL_sResource *  psOrigResource = psResource;
    POOL_sResource *  psCloneResource;
    IMG_UINT32        ui32Result;

    IMG_ASSERT(gInitialised);
    IMG_ASSERT(psResource != IMG_NULL);

    if (!gInitialised ||
        psResource == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error_nolock;
    }

    /* Allocate a resource structure...*/
    psCloneResource = IMG_MALLOC(sizeof(*psCloneResource));
    IMG_ASSERT(psCloneResource != IMG_NULL);
    if (psCloneResource == IMG_NULL)
    {
        return IMG_ERROR_OUT_OF_MEMORY;
    }
    IMG_MEMSET(psCloneResource, 0, sizeof(*psCloneResource));

    psResPool = psResource->psResPool;
    IMG_ASSERT(psResPool != IMG_NULL);
    if(psResPool == IMG_NULL)
    {
        return IMG_ERROR_FATAL;
    }

    /* Lock the pool...*/
    SYSOSKM_LockMutex(psResPool->hMutexHandle);

    /* Set resource id...*/
    ui32Result = IDGEN_AllocId(psResPool->hIdGenHandle, (IMG_HANDLE)psCloneResource, &psCloneResource->ui32ResId);
    IMG_ASSERT(ui32Result == IMG_SUCCESS);
    if (ui32Result != IMG_SUCCESS)
    {
        goto error_alloc_id;
    }

    /* If this is a clone, set the original...*/
    if (psResource->bIsClone)
    {
        psOrigResource = psResource->psOrigResource;
    }
    IMG_ASSERT(psOrigResource->ui32RefCnt > 0);

    /* Setup the cloned resource...*/
    psCloneResource->bIsClone       = IMG_TRUE;
    psCloneResource->psResPool      = psResPool;
    psCloneResource->psOrigResource = psOrigResource;

    /* Add to clone list...*/
    LST_add(&psOrigResource->sCloneResList, psCloneResource);
    psOrigResource->ui32RefCnt++;

    /* If ppvParam is not IMG_NULL...*/
    if (ppvParam !=IMG_NULL)
    {
        /* If the size of the original vParam is 0...*/
        if (psOrigResource->ui32SizevParam == 0)
        {
            *ppvParam = IMG_NULL;
        }
        else
        {
            /* Allocate memory for a copy of the original vParam...*/
            *ppvParam = IMG_MALLOC(psOrigResource->ui32SizevParam);
            IMG_ASSERT(*ppvParam != IMG_NULL);
            if (*ppvParam == IMG_NULL)
            {
                ui32Result = IMG_ERROR_OUT_OF_MEMORY;
                goto error_copy_param;
            }
            IMG_MEMCPY(*ppvParam, psOrigResource->pvParam, psOrigResource->ui32SizevParam);
        }
    }

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

    /* Return the cloned resource...*/
    *phClonePoolResHandle = psCloneResource;

    /* Return IMG_SUCCESS...*/
    return IMG_SUCCESS;

    /* Error handling. */
error_copy_param:
    LST_remove(&psOrigResource->sCloneResList, psCloneResource);
    psOrigResource->ui32RefCnt--;
error_alloc_id:
    IMG_FREE(psCloneResource);

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

error_nolock:
    return ui32Result;
}
Пример #11
0
/*!
******************************************************************************

 @Function                POOL_ResFree

******************************************************************************/
IMG_RESULT POOL_ResFree(
    IMG_HANDLE  hPoolResHandle
)
{
    POOL_sResource *  psResource = hPoolResHandle;
    POOL_sResPool *   psResPool;
    POOL_sResource *  psOrigResource;
    IMG_UINT32        ui32Result;

    IMG_ASSERT(gInitialised);
    IMG_ASSERT(psResource != IMG_NULL);

    if (!gInitialised ||
        psResource == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error_nolock;
    }

    psResPool = psResource->psResPool;

    /* Lock the pool...*/
    SYSOSKM_LockMutex(psResPool->hMutexHandle);

    /* If this is a clone...*/
    if (psResource->bIsClone)
    {
        /* Get access to the original...*/
        psOrigResource = psResource->psOrigResource;
        IMG_ASSERT(psOrigResource != IMG_NULL);
        IMG_ASSERT(!psOrigResource->bIsClone);

        /* Remove from the clone list...*/
        LST_remove(&psOrigResource->sCloneResList, psResource);

        /* Free resource id...*/
        ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId);
        IMG_ASSERT(ui32Result == IMG_SUCCESS);
        if (ui32Result != IMG_SUCCESS)
        {
            /* Unlock the pool...*/
            SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

            return ui32Result;
        }

        /* If we created a copy of the resources pvParam then free it...*/
        if (psResource->pvParam != IMG_NULL)
        {
            IMG_FREE(psResource->pvParam );
        }
        /* Free the clone resource structure...*/
        IMG_FREE(psResource);

        /* Set resource to be "freed" to the original...*/
        psResource = psOrigResource;
    }

    /* Update the reference count...*/
    IMG_ASSERT(psResource->ui32RefCnt != 0);
    psResource->ui32RefCnt--;

    /* If there are still outstanding references...*/
    if (psResource->ui32RefCnt != 0)
    {
        /* Unlock the pool...*/
        SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

        /* Return IMG_SUCCESS...*/
        return IMG_SUCCESS;
    }

    /* Remove the resource from the active list...*/
    LST_remove(&psResPool->sActResList, psResource);

    /* If free callback set...*/
    if (psResPool->pfnFree != IMG_NULL)
    {
        /* Add to active list...*/
        LST_add(&psResPool->sActResList, psResource);
        psResource->ui32RefCnt++;
    }
    else
    {
        /* Add to free list...*/
        LST_add(&psResPool->sFreeResList, psResource);
    }

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

    /* If free callback set...*/
    if (psResPool->pfnFree != IMG_NULL)
    {
        /* Call the free callback...*/
        psResPool->pfnFree(psResource->ui32ResId, psResource->pvParam);
    }

    /* Return IMG_SUCCESS...*/
    return IMG_SUCCESS;

error_nolock:
    return ui32Result;
}
Пример #12
0
/*!
******************************************************************************

 @Function                POOL_ResDestroy

******************************************************************************/
IMG_RESULT POOL_ResDestroy(
    IMG_HANDLE  hPoolResHandle,
    IMG_BOOL    bForce
)
{
    POOL_sResource *  psResource = hPoolResHandle;
    POOL_sResPool *   psResPool;
    POOL_sResource *  psOrigResource;
    POOL_sResource *  psCloneResource;
    IMG_UINT32        ui32Result;

    IMG_ASSERT(gInitialised);
    IMG_ASSERT(psResource != IMG_NULL);

    if (!gInitialised ||
        psResource == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error_nolock;
    }

    psResPool = psResource->psResPool;

    /* Lock the pool...*/
    SYSOSKM_LockMutex(psResPool->hMutexHandle);

    /* If this is a clone...*/
    if (psResource->bIsClone)
    {
        IMG_ASSERT(0);        // We need to check this works.

        /* Get access to the original...*/
        psOrigResource = psResource->psOrigResource;
        IMG_ASSERT(psOrigResource != IMG_NULL);
        if (psOrigResource == IMG_NULL)
        {
            ui32Result = IMG_ERROR_UNEXPECTED_STATE;
            goto error;
        }
		
        IMG_ASSERT(!psOrigResource->bIsClone);
        if (psOrigResource->bIsClone)
        {
            ui32Result = IMG_ERROR_UNEXPECTED_STATE;
            goto error;
        }

        /* Remove from the clone list...*/
        LST_remove(&psOrigResource->sCloneResList, psResource);

        /* Free resource id...*/
        ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId);
        IMG_ASSERT(ui32Result == IMG_SUCCESS);
        if (ui32Result != IMG_SUCCESS)
        {
            /* Unlock the pool...*/
            SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

            return ui32Result;
        }

        /* If we created a copy of the resources pvParam then free it...*/
        if (psResource->pvParam != IMG_NULL)
        {
            IMG_FREE(psResource->pvParam );
        }
        /* Free the clone resource structure...*/
        IMG_FREE(psResource);

        /* Set resource to be "freed" to the original...*/
        psResource = psOrigResource;
    }

    /* If there are still outstanding references...*/
    if ( (!bForce) && (psResource->ui32RefCnt != 0) )
    {
        IMG_ASSERT(0);      // We may need to mark the resource and destroy it when
                            // there are no outstanding references
        /* Unlock the pool...*/
        SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

        /* Return IMG_SUCCESS...*/
        return IMG_SUCCESS;
    }

    /* Check clone list is empty...*/
    psCloneResource = LST_first(&psResource->sCloneResList);
    IMG_ASSERT(psCloneResource == IMG_NULL);

    /* Has the resource outstanding references...*/
    if (psResource->ui32RefCnt != 0)
    {
        /* Remove the resource from the active list...*/
        LST_remove(&psResPool->sActResList, psResource);
    }
    else
    {
        /* Remove the resource from the free list...*/
        LST_remove(&psResPool->sFreeResList, psResource);
    }

    /* Free resource id...*/
    ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId);
    IMG_ASSERT(ui32Result == IMG_SUCCESS);
    if (ui32Result != IMG_SUCCESS)
    {
        /* Unlock the pool...*/
        SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

        return ui32Result;
    }

    /* Call the resource destructor...*/
    psResource->pfnDestructor(psResource->pvParam);
    IMG_FREE(psResource);

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

    /* Return IMG_SUCCESS...*/
    return IMG_SUCCESS;

error:
	SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

error_nolock:
    return ui32Result;
}
Пример #13
0
/*!
******************************************************************************

 @Function                POOL_PoolDestroy

******************************************************************************/
IMG_RESULT POOL_PoolDestroy(
    IMG_HANDLE  hPoolHandle
)
{
    POOL_sResPool *   psResPool = hPoolHandle;
    POOL_sResource *  psResource;
    POOL_sResource *  psCloneResource;
    IMG_UINT32        ui32Result;

    IMG_ASSERT(gInitialised);
    IMG_ASSERT(psResPool != IMG_NULL);

    if (!gInitialised ||
        psResPool == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error_nolock;
    }

    /* Lock the pool...*/
    SYSOSKM_LockMutex(psResPool->hMutexHandle);

    /* Disable interrupts.  */
    SYSOSKM_DisableInt();

    /* Remove the pool from the active list...*/
    LST_remove(&gsPoolList, psResPool);

    /* Enable interrupts.  */
    SYSOSKM_EnableInt();

    /* Destroy any resources in the free list...*/
    psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList);
    while (psResource != IMG_NULL)
    {
        psResource->pfnDestructor(psResource->pvParam);
        IMG_FREE(psResource);

        psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList);
    }

    /* Destroy any resources in the active list...*/
    psResource = (POOL_sResource *)LST_removeHead(&psResPool->sActResList);
    while (psResource != IMG_NULL)
    {
        psCloneResource = (POOL_sResource *)LST_removeHead(&psResource->sCloneResList);
        while (psCloneResource != IMG_NULL)
        {
            /* If we created a copy of the resources pvParam then free it...*/
            if (psCloneResource->pvParam != IMG_NULL)
            {
                IMG_FREE(psCloneResource->pvParam );
            }
            IMG_FREE(psCloneResource);
            psCloneResource = (POOL_sResource *)LST_removeHead(&psResource->sCloneResList);
        }

        /* Call the resource destructor...*/
        psResource->pfnDestructor(psResource->pvParam);
        IMG_FREE(psResource);

        psResource = (POOL_sResource *)LST_removeHead(&psResPool->sActResList);
    }

    /* Destroy the context for the Id generator...*/
    if (psResPool->hIdGenHandle != IMG_NULL)
    {
        ui32Result = IDGEN_DestroyContext(psResPool->hIdGenHandle);
        IMG_ASSERT(ui32Result == IMG_SUCCESS);
    }

    /* Unlock the pool...*/
    SYSOSKM_UnlockMutex(psResPool->hMutexHandle);

    /* Destroy mutex...*/
    SYSOSKM_DestroyMutex(psResPool->hMutexHandle);

    /* Free the pool structure */
    IMG_FREE(psResPool);
    
	return IMG_SUCCESS;

error_nolock:
    return ui32Result;
}
Пример #14
0
/*!
******************************************************************************

 @Function              RESOURCE_ListReplace

******************************************************************************/
IMG_RESULT
RESOURCE_ListReplace(
    LST_T                 * psList,
    IMG_VOID              * pvItem,
    IMG_UINT32              ui32Id,
    IMG_UINT32            * pui32RefCount,
    RESOURCE_pfnFreeItem    pfnFreeItem,
    IMG_VOID              * pvFreeCbParam
)
{
    RESOURCE_sListElem    * psListElem = IMG_NULL;
    IMG_UINT32              ui32Result;

    /* Check input params. */
    IMG_ASSERT(IMG_NULL != psList);
    IMG_ASSERT(IMG_NULL != pvItem);
    if (psList == IMG_NULL ||
        pvItem == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error;
    }

    /* Determine whether this sequence header is already in the list. */
    psListElem = LST_first(psList);
    while (psListElem)
    {
        if (psListElem->ui32Id == ui32Id)
        {
            /* Free old version. */
            RESOURCE_ItemReturn(psListElem->pui32RefCount);
            if (*psListElem->pui32RefCount == 0)
            {
                if (pfnFreeItem)
                {
                    pfnFreeItem(psListElem->pvItem, pvFreeCbParam);
                }
                else
                {
                    IMG_FREE(psListElem->pvItem);
                }
                psListElem->pvItem = IMG_NULL;
            }

            LST_remove(psList, psListElem);
            break;
        }

        psListElem = LST_next(psListElem);
    }

    if (psListElem == IMG_NULL)
    {
        /* Allocate the sequence header list element structure. */
        VDEC_MALLOC(psListElem);
        if (IMG_NULL == psListElem)
        {
            REPORT(REPORT_MODULE_RESOURCE, REPORT_ERR,
                "Failed to allocate memory for RESOURCE list element");
            return IMG_ERROR_OUT_OF_MEMORY;
        }
    }
    VDEC_BZERO(psListElem);

    /* Setup the sequence header list element. */
    RESOURCE_ItemUse(pui32RefCount);

    psListElem->pvItem = pvItem;
    psListElem->ui32Id = ui32Id;
    psListElem->pui32RefCount = pui32RefCount;

    /* Add the sequence header list element to the sequence header list. */
    LST_add(psList, (IMG_VOID *)psListElem);

    return IMG_SUCCESS;

error:
    return ui32Result;
}
Пример #15
0
/*!
******************************************************************************

 @Function              RESOURCE_ListRemoveNextAvail

******************************************************************************/
IMG_RESULT
RESOURCE_ListRemoveNextAvail(
    LST_T                 * psList,
    RESOURCE_pfnFreeItem    pfnFreeItem,
    IMG_VOID              * pvFreeCbParam
)
{
    RESOURCE_sListElem *  psListElem = IMG_NULL;
    IMG_UINT32 ui32Result = IMG_ERROR_COULD_NOT_OBTAIN_RESOURCE;

    /* Check input params. */
    IMG_ASSERT(IMG_NULL != psList);
    if (psList == IMG_NULL)
    {
        ui32Result = IMG_ERROR_INVALID_PARAMETERS;
        goto error;
    }

    /* Find the next unused item in the list. */
    psListElem = LST_first(psList);
    while (psListElem)
    {
        if (RESOURCE_ItemIsAvailable(psListElem->pui32RefCount))
        {
            /* Return and free. */
            RESOURCE_ItemReturn(psListElem->pui32RefCount);

            if (psListElem->pui32RefCount == IMG_NULL ||
                *psListElem->pui32RefCount == 0)
            {
                if (pfnFreeItem)
                {
                    pfnFreeItem(psListElem->pvItem, pvFreeCbParam);
                }
                else
                {
                    IMG_FREE(psListElem->pvItem);
                }
                psListElem->pvItem = IMG_NULL;
            }

            /* Get the next element from the list. */
            LST_remove(psList, psListElem);

            /* Free the buffer list element. */
            IMG_FREE(psListElem);
            psListElem = IMG_NULL;

            ui32Result = IMG_SUCCESS;
            break;
        }

        psListElem = LST_next(psListElem);
    }

    if (ui32Result == IMG_ERROR_COULD_NOT_OBTAIN_RESOURCE)
    {
        DEBUG_REPORT(REPORT_MODULE_RESOURCE,
            "Failed to locate an available RESOURCE element to remove");
    }

error:
    return ui32Result;
}