NvError
NvEcOpen(NvEcHandle *phEc,
NvU32 InstanceId)
{
NvEc *hEc = NULL;
NvU32 i;
NvEcPrivState *ec = &g_ec;
NvOsMutexHandle mutex = NULL;
NvError e = NvSuccess;
NV_ASSERT( phEc );
if ( NULL == ec->mutex )
{
e = NvOsMutexCreate(&mutex);
if (NvSuccess != e)
return e;
if (0 != NvOsAtomicCompareExchange32((NvS32*)&ec->mutex, 0,
(NvS32)mutex) )
NvOsMutexDestroy( mutex );
}
NvOsMutexLock(ec->mutex);
if ( !s_refcount )
{
mutex = ec->mutex;
NvOsMemset( ec, 0, sizeof(NvEcPrivState) );
ec->mutex = mutex;
NV_CHECK_ERROR_CLEANUP( NvOsMutexCreate( &ec->requestMutex ));
NV_CHECK_ERROR_CLEANUP( NvOsMutexCreate( &ec->responseMutex ));
NV_CHECK_ERROR_CLEANUP( NvOsMutexCreate( &ec->eventMutex ));
NV_CHECK_ERROR_CLEANUP( NvOsSemaphoreCreate( &ec->sema, 0));
NV_CHECK_ERROR_CLEANUP( NvOsSemaphoreCreate( &ec->LowPowerEntrySema, 0));
NV_CHECK_ERROR_CLEANUP( NvOsSemaphoreCreate( &ec->LowPowerExitSema, 0));
NV_CHECK_ERROR_CLEANUP( NvEcTransportOpen( &ec->transport, InstanceId,
ec->sema, 0 ) );
}
// Set this flag as TRUE to indicate power is enabled
ec->powerState = NV_TRUE;
// create private handle for internal communications between NvEc driver
// and EC
if ( !s_refcount )
{
ec->hEc = NvOsAlloc( sizeof(NvEc) );
if ( NULL == ec->hEc )
goto clean;
// reserve the zero tag for internal use by the nvec driver; this ensures
// that the driver always has a requestor tag available and can therefore
// always talk to the EC
ec->tagAllocated[0] = NV_TRUE;
ec->hEc->ec = ec;
ec->hEc->tag = 0;
NV_CHECK_ERROR_CLEANUP(NvOsSemaphoreCreate(&ec->hPingSema, 0));
// perform startup operations before mutex is unlocked
NV_CHECK_ERROR_CLEANUP( NvEcPrivInitHook(ec->hEc) );
// start thread to send "pings" - no-op commands to keep EC "alive"
NV_CHECK_ERROR_CLEANUP(NvOsThreadCreate(
(NvOsThreadFunction)NvEcPrivPingThread, ec, &ec->hPingThread));
}
hEc = NvOsAlloc( sizeof(NvEc) );
if ( NULL == hEc )
goto clean;
NvOsMemset(hEc, 0x00, sizeof(NvEc));
hEc->ec = ec;
hEc->tag = NVEC_REQUESTOR_TAG_INVALID;
for ( i = 0; i < NVEC_MAX_REQUESTOR_TAG; i++ )
{
if ( !ec->tagAllocated[i] )
{
ec->tagAllocated[i] = NV_TRUE;
hEc->tag = i;
break;
}
}
if ( NVEC_REQUESTOR_TAG_INVALID == hEc->tag )
goto clean; // run out of tag, clean it up!
*phEc = hEc;
s_refcount++;
NvOsMutexUnlock( ec->mutex );
ec->IsEcActive = NV_FALSE;
return NvSuccess;
clean:
NvOsFree( hEc );
NvOsMutexUnlock( ec->mutex );
return NvError_InsufficientMemory;
fail:
if (!s_refcount)
{
ec->exitPingThread = NV_TRUE;
if (ec->hPingSema)
NvOsSemaphoreSignal( ec->hPingSema );
NvOsThreadJoin( ec->hPingThread );
NvOsSemaphoreDestroy(ec->hPingSema);
ec->exitThread = NV_TRUE;
if (ec->sema)
NvOsSemaphoreSignal( ec->sema );
NvOsThreadJoin( ec->thread );
NvOsFree( ec->hEc );
if ( ec->transport )
NvEcTransportClose( ec->transport );
NvOsMutexDestroy( ec->requestMutex );
NvOsMutexDestroy( ec->responseMutex );
NvOsMutexDestroy( ec->eventMutex );
NvOsSemaphoreDestroy( ec->sema );
NvOsSemaphoreDestroy( ec->LowPowerEntrySema );
NvOsSemaphoreDestroy( ec->LowPowerExitSema );
if ( ec->mutex )
{
NvOsMutexUnlock( ec->mutex );
// Destroying of this mutex here is not safe, if another thread is
// waiting on this mutex, it can cause issues. We shold have
// serialized Init/DeInit calls for creating and destroying this mutex.
NvOsMutexDestroy( ec->mutex );
NvOsMemset( ec, 0, sizeof(NvEcPrivState) );
ec->mutex = NULL;
}
}
return NvError_NotInitialized;
}
void
NvEcClose(NvEcHandle hEc)
{
NvEcPrivState *ec;
NvBool destroy = NV_FALSE;
if ( NULL == hEc )
return;
NV_ASSERT( s_refcount );
ec = hEc->ec;
NvOsMutexLock( ec->mutex );
// FIXME: handle client still with outstanding event types
if ( !--s_refcount )
{
NvEcPrivDeinitHook(ec->hEc);
NV_ASSERT( NULL == ec->eventReg[hEc->tag].regBegin &&
NULL == ec->eventReg[hEc->tag].regEnd );
NV_ASSERT( NULL == ec->requestBegin && NULL == ec->requestEnd );
NV_ASSERT( NULL == ec->responseBegin && NULL == ec->responseEnd );
ec->exitPingThread = NV_TRUE;
NvOsSemaphoreSignal( ec->hPingSema );
NvOsThreadJoin( ec->hPingThread );
ec->exitThread = NV_TRUE;
NvOsSemaphoreSignal( ec->sema );
NvOsThreadJoin( ec->thread );
NvEcTransportClose( ec->transport );
NvOsMutexDestroy( ec->requestMutex );
NvOsMutexDestroy( ec->responseMutex );
NvOsMutexDestroy( ec->eventMutex );
NvOsSemaphoreDestroy( ec->sema );
NvOsSemaphoreDestroy( ec->hPingSema );
NvOsSemaphoreDestroy( ec->LowPowerEntrySema );
NvOsSemaphoreDestroy( ec->LowPowerExitSema );
destroy = NV_TRUE;
NvOsFree( ec->eventNodes );
NvOsFree( ec->hEc );
}
// Set this flag as FALSE to indicate power is disabled
ec->powerState = NV_FALSE;
NV_ASSERT( hEc->tag < NVEC_MAX_REQUESTOR_TAG );
ec->tagAllocated[hEc->tag] = NV_FALSE; // to be recycled
NvOsFree( hEc );
NvOsMutexUnlock( ec->mutex );
if ( destroy )
{
NvOsMutexDestroy( ec->mutex );
NvOsMemset( ec, 0, sizeof(NvEcPrivState) );
ec->mutex = NULL;
}
}
void
NvEcClose(NvEcHandle hEc)
{
NvEcPrivState *ec;
NvBool destroy = NV_FALSE;
if ( NULL == hEc )
return;
NV_ASSERT( s_refcount );
ec = hEc->ec;
NvOsMutexLock( ec->mutex );
// FIXME: handle client still with outstanding event types
if ( !--s_refcount )
{
NvEcPrivDeinitHook(ec->hEc);
NV_ASSERT( NULL == ec->eventReg[hEc->tag].regBegin &&
NULL == ec->eventReg[hEc->tag].regEnd );
NV_ASSERT( NULL == ec->requestBegin && NULL == ec->requestEnd );
NV_ASSERT( NULL == ec->responseBegin && NULL == ec->responseEnd );
#ifndef CONFIG_TEGRA_ODM_BETELGEUSE
ec->exitPingThread = NV_TRUE;
NvOsSemaphoreSignal( ec->hPingSema );
NvOsThreadJoin( ec->hPingThread );
#endif
ec->exitThread = NV_TRUE;
NvOsSemaphoreSignal( ec->sema );
NvOsThreadJoin( ec->thread );
NvEcTransportClose( ec->transport );
NvOsMutexDestroy( ec->requestMutex );
NvOsMutexDestroy( ec->responseMutex );
NvOsMutexDestroy( ec->eventMutex );
NvOsSemaphoreDestroy( ec->sema );
#ifndef CONFIG_TEGRA_ODM_BETELGEUSE
NvOsSemaphoreDestroy( ec->hPingSema );
#endif
NvOsSemaphoreDestroy( ec->LowPowerEntrySema );
NvOsSemaphoreDestroy( ec->LowPowerExitSema );
destroy = NV_TRUE;
NvOsFree( ec->eventNodes );
NvOsFree( ec->hEc );
}
// Set this flag as FALSE to indicate power is disabled
//Daniel 20100723, if we change power state to NV_FALSE, we won't be able to suspend/poweroff it.
//Is there any side effect ?????
//ec->powerState = NV_FALSE;
NV_ASSERT( hEc->tag < NVEC_MAX_REQUESTOR_TAG );
ec->tagAllocated[hEc->tag] = NV_FALSE; // to be recycled
NvOsFree( hEc );
NvOsMutexUnlock( ec->mutex );
if ( destroy )
{
NvOsMutexDestroy( ec->mutex );
NvOsMemset( ec, 0, sizeof(NvEcPrivState) );
ec->mutex = NULL;
}
}
