static void FreePowerClient(NvRmPowerClient* pPowerClient)
{
ModuleVoltageReq* pVoltageReq = NULL;
ModuleClockReq* pClockReq = NULL;
// Just return if null-pointer
if (pPowerClient == NULL)
return;
// Free memory occupied by voltage requests
while (pPowerClient->pVoltageReqHead != NULL)
{
pVoltageReq = pPowerClient->pVoltageReqHead;
pPowerClient->pVoltageReqHead = pVoltageReq->pNext;
NvOsFree(pVoltageReq);
}
// Free memory occupied by clock requests
while (pPowerClient->pClockReqHead != NULL)
{
pClockReq = pPowerClient->pClockReqHead;
pPowerClient->pClockReqHead = pClockReq->pNext;
NvOsFree(pClockReq);
}
// Free memory occupied by starvation hints array
NvOsFree(pPowerClient->pStarvationHints);
// Free power management event semaphore handle
NvOsSemaphoreDestroy(pPowerClient->hEventSemaphore);
// Free memory occupied by the client record
NvOsFree(pPowerClient);
}
void NvRmPrivPowerDeinit(NvRmDeviceHandle hRmDeviceHandle)
{
NvU32 i;
NvRmPowerRegistry* pRegistry = &s_PowerRegistry;
NV_ASSERT(hRmDeviceHandle);
// TODO: expand after clock API is completed
// Free busy hint lists for DFS clock domains
for (i = 0; i < NvRmDfsClockId_Num; i++)
{
while (s_BusyReqHeads[i].pNext != NULL)
{
BusyHintReq* pBusyHintReq = s_BusyReqHeads[i].pNext;
s_BusyReqHeads[i].pNext = pBusyHintReq->pNext;
BusyReqFree(pBusyHintReq);
}
}
// Free RM power registry memory
for (i = 0; i < pRegistry->UsedIndexRange; i++)
{
FreePowerClient(pRegistry->pPowerClients[i]);
}
NvOsFree(pRegistry->pPowerClients);
pRegistry->pPowerClients = NULL;
pRegistry->AvailableEntries = 0;
pRegistry->UsedIndexRange = 0;
// Destroy RM registry mutex and free RM/OAL interface resources
NvRmPrivOalIntfDeinit(hRmDeviceHandle);
NvOsMutexDestroy(s_hPowerClientMutex);
s_hPowerClientMutex = NULL;
}
void FreeKeyList(void)
{
Key *pTemp = s_pKeyList;
while (s_pKeyList != &s_InitialKeyList)
{
pTemp = s_pKeyList->pNextKey ;
NvOsFree(s_pKeyList);
s_pKeyList = pTemp;
}
}
static void BusyReqFree(BusyHintReq* pBusyHintReq)
{
if ((pBusyHintReq >= &s_BusyReqPool[0]) &&
(pBusyHintReq < &s_BusyReqPool[NVRM_BUSYREQ_POOL_SIZE]))
{
NV_ASSERT(s_FreeBusyReqPoolSize < NVRM_BUSYREQ_POOL_SIZE);
s_pFreeBusyReqPool[s_FreeBusyReqPoolSize++] = pBusyHintReq;
return;
}
NvOsFree(pBusyHintReq);
}
void NvRmPrivGetCpuIdInfo(NvU32 *id,NvU32 *family,NvU32 *major,NvU32 *minor,NvU32 *sku)
{
#define TAG "GetCpuIdInfo: "
NvRmDeviceHandle rm;
rm=(NvRmDeviceHandle)NvOsAlloc(sizeof(NvRmDevice));
if(rm==NULL)
{
NvOsDebugPrintf(TAG "NvOsAlloc rm fail!\n");
return;
}
NvRmPrivReadChipId(rm);
#if 0
typedef enum
{
NvRmChipFamily_Gpu = 0,
NvRmChipFamily_Handheld = 1,
NvRmChipFamily_BrChips = 2,
NvRmChipFamily_Crush = 3,
NvRmChipFamily_Mcp = 4,
NvRmChipFamily_Ck = 5,
NvRmChipFamily_Vaio = 6,
NvRmChipFamily_HandheldSoc = 7,
NvRmChipFamily_Force32 = 0x7FFFFFFF,
} NvRmChipFamily;
#endif
if(id!=NULL) *id=rm->ChipId.Id;
if(family!=NULL) *family=rm->ChipId.Family;
if(major!=NULL) *major=rm->ChipId.Family;
if(minor!=NULL) *minor=rm->ChipId.Minor;
if(sku!=NULL) *sku=rm->ChipId.SKU;
/*if(id!=NULL&&family!=NULL&&major!=NULL&&minor!=NULL&&sku!=NULL)
NvOsDebugPrintf( "second Chip Id: 0x%x Family:0x%x Major: 0x%x Minor: 0x%x "
"SKU: 0x%x\n", *id,*family, *major, *minor, *sku );*/
NvOsFree(rm);
}
void NvRmPwmClose(NvRmPwmHandle hPwm)
{
NvU32 i;
if (!hPwm)
return;
NV_ASSERT(hPwm->RefCount);
NvOsMutexLock(s_hPwmMutex);
hPwm->RefCount--;
if (hPwm->RefCount == 0)
{
// Unmap the pwm register virtual address space
for (i = 0; i < NvRmPwmOutputId_Num-2; i++)
{
NvRmPhysicalMemUnmap((void*)s_hPwm->VirtualAddress[i],
s_hPwm->PwmBankSize);
}
// Unmap the pmc register virtual address space
NvRmPhysicalMemUnmap(
(void*)s_hPwm->VirtualAddress[NvRmPwmOutputId_Num-2],
s_hPwm->PmcBankSize);
if (s_IsPwmFirstConfig)
{
// Disable power
PwmPowerConfigure(hPwm, NV_FALSE);
// Unregister with RM power
NvRmPowerUnRegister(hPwm->RmDeviceHandle, s_PwmPowerID);
// Tri-state the pin-mux pins
NV_ASSERT_SUCCESS(NvRmSetModuleTristate(hPwm->RmDeviceHandle,
NVRM_MODULE_ID(NvRmModuleID_Pwm, 0), NV_TRUE));
s_IsPwmFirstConfig = NV_FALSE;
}
NvOsFree(s_hPwm);
s_hPwm = NULL;
}
NvOsMutexUnlock(s_hPwmMutex);
}
NvError
NvEcUnregisterForEvents(
NvEcEventRegistrationHandle hEcEventRegistration)
{
NvEcPrivState *ec;
NvU32 tag;
NvU32 tagMask;
NvError e = NvSuccess;
NvEcEventRegistration *p = NULL, *reg = NULL;
NvEcEventNode *eventNode, *t;
NvU32 i;
if( NULL == hEcEventRegistration )
return NvError_BadParameter;
ec = hEcEventRegistration->hEc->ec;
tag = hEcEventRegistration->hEc->tag;
tagMask = (1UL << tag);
NvOsMutexLock( ec->eventMutex );
NVEC_REMOVE_FROM_Q( ec->eventReg[tag].reg, hEcEventRegistration, reg, p );
if ( !reg )
{
e = NvError_BadParameter; // can't find the handle
goto fail;
}
eventNode = ec->eventReadyBegin;
while ( eventNode )
{
// pre advance eventNode since current one could be removed
t = eventNode;
eventNode = eventNode->next;
if ( (reg->eventBitmap & (1UL << t->event.EventType)) &&
(t->tagBitmap & tagMask) )
{
t->tagBitmap &= ~tagMask;
if ( !t->tagBitmap )
{
NvEcPrivRemoveEventFromReady( ec, t );
}
}
}
// remove global references to this registration
i = 0;
while( reg->eventBitmap )
{
NV_ASSERT(i < NvEcEventType_Num);
if ( reg->eventBitmap & 1 )
{
ec->eventTagBitmap[i] &= ~tagMask;
ec->eventMap[tag][i] = NULL;
}
reg->eventBitmap = reg->eventBitmap >> 1;
i++;
}
NvOsSemaphoreDestroy( reg->sema );
NvOsFree( hEcEventRegistration );
fail:
NvOsMutexUnlock( ec->eventMutex );
return e;
}
NvError
NvEcRegisterForEvents(
NvEcHandle hEc,
NvEcEventRegistrationHandle *phEcEventRegistration,
NvOsSemaphoreHandle hSema,
NvU32 NumEventTypes,
NvEcEventType *pEventTypes,
NvU32 NumEventPackets,
NvU32 EventPacketSize)
{
NvEcPrivState *ec = hEc->ec;
NvEcEventRegistration *h = NULL;
NvOsSemaphoreHandle hSemaClone = NULL;
NvError e = NvSuccess;
NvU32 val, i, tag = hEc->tag;
NvU32 tagMask = (1UL << tag);
if ( !hSema || !pEventTypes )
return NvError_BadParameter;
if ( !NumEventTypes || (NumEventTypes > NvEcEventType_Num) )
return NvError_InvalidSize; // FIXME: is this sufficient?
NV_ASSERT( phEcEventRegistration );
NvOsMutexLock( ec->mutex );
if ( !ec->thread )
NvEcPrivThreadCreate( ec );
// Allocate common pool of internal event nodes bufferring if not already
if ( !ec->eventNodes )
{
val = NVEC_NUM_EVENT_PACKETS_DEFAULT;
if ( NumEventPackets > val )
val = NumEventPackets;
ec->eventNodes = NvOsAlloc(val * sizeof(NvEcEventNode));
if ( NULL == ec->eventNodes )
{
NvOsMutexUnlock( ec->mutex );
return NvError_InsufficientMemory;
}
NvOsMemset( ec->eventNodes, 0, (val * sizeof(NvEcEventNode)) );
for( i = 0; i < val - 1; i++ )
ec->eventNodes[i].next = &ec->eventNodes[i+1];
ec->eventFreeBegin = ec->eventNodes;
ec->eventFreeEnd = ec->eventNodes + val - 1;
}
NvOsMutexUnlock( ec->mutex );
NV_CHECK_ERROR( NvOsSemaphoreClone( hSema, &hSemaClone ) );
NvOsMutexLock( ec->eventMutex );
// Quick pre-check for for AlreadyAllocated case
for ( i = 0; i < NumEventTypes; i++ )
{
val = pEventTypes[i];
if ( val >= NvEcEventType_Num )
e = NvError_BadParameter;
else if ( ec->eventMap[tag][val] )
e = NvError_AlreadyAllocated;
if ( NvSuccess != e )
goto fail;
}
h = NvOsAlloc( sizeof(NvEcEventRegistration));
if ( NULL == h )
{
e = NvError_InsufficientMemory;
goto fail;
}
NvOsMemset( h, 0, sizeof(NvEcEventRegistration) );
NVEC_ENQ( ec->eventReg[tag].reg, h );
// Fill up new registration handle
NV_ASSERT( NvEcEventType_Num <= 32 ); // eventBitmap only works if <= 32
for ( i = 0; i < NumEventTypes; i++ )
{
val = pEventTypes[i];
h->eventBitmap |= (1 << val);
ec->eventMap[tag][val] = h;
ec->eventTagBitmap[val] |= tagMask;
}
h->numEventTypes = NumEventTypes;
h->sema = hSemaClone;
h->hEc = hEc;
h->numEventPacketsHint = NumEventPackets;
h->eventPacketSizeHint = EventPacketSize; // ignored hints for now
NvOsMutexUnlock( ec->eventMutex );
*phEcEventRegistration = h;
return e;
fail:
NvOsSemaphoreDestroy( hSemaClone );
NvOsMutexUnlock( ec->eventMutex );
NvOsFree( h );
return e;
}
NvError
NvEcSendRequest(
NvEcHandle hEc,
NvEcRequest *pRequest,
NvEcResponse *pResponse,
NvU32 RequestSize,
NvU32 ResponseSize)
{
NvEcPrivState *ec;
NvError e = NvSuccess;
NvEcRequestNode *requestNode = NULL;
NvEcResponseNode *responseNode = NULL;
NvOsSemaphoreHandle requestSema = NULL;
NvOsSemaphoreHandle responseSema = NULL;
NV_ASSERT( pRequest );
NV_ASSERT( hEc );
if ( (RequestSize > sizeof(NvEcRequest)) ||
(ResponseSize > sizeof(NvEcResponse)) )
return NvError_InvalidSize;
ec = hEc->ec;
requestNode = NvOsAlloc(sizeof(NvEcRequestNode));
if ( NULL == requestNode )
{
e = NvError_InsufficientMemory;
goto fail;
}
NV_CHECK_ERROR_CLEANUP( NvOsSemaphoreCreate( &requestSema, 0 ) );
if ( pResponse )
{
responseNode = NvOsAlloc(sizeof(NvEcResponseNode));
if ( NULL == responseNode )
{
e = NvError_InsufficientMemory;
goto fail;
}
NV_CHECK_ERROR_CLEANUP( NvOsSemaphoreCreate( &responseSema, 0 ) );
}
ec->IsEcActive = NV_TRUE;
// request end-queue. Timeout set to infinite until request sent.
NvOsMemset( requestNode, 0, sizeof(NvEcRequestNode) );
pRequest->RequestorTag = hEc->tag; // assigned tag here
DISP_MESSAGE(("NvEcSendRequest:pRequest->RequestorTag=0x%x\n", pRequest->RequestorTag));
NvOsMemcpy(&requestNode->request, pRequest, RequestSize);
requestNode->tag = hEc->tag;
DISP_MESSAGE(("NvEcSendRequest:requestNode->tag=0x%x\n", requestNode->tag));
requestNode->sema = requestSema;
requestNode->timeout = NV_WAIT_INFINITE;
requestNode->completed = NV_FALSE;
requestNode->size = RequestSize;
NvOsMutexLock( ec->requestMutex );
NVEC_ENQ( ec->request, requestNode );
DISP_MESSAGE(("\r\nSendReq ec->requestBegin=0x%x", ec->requestBegin));
NvOsMutexUnlock( ec->requestMutex );
// response en-queue. Timeout set to infinite until request completes.
if ( pResponse )
{
NvOsMemset( responseNode, 0, sizeof(NvEcResponseNode) );
requestNode->responseNode = responseNode; // association between
responseNode->requestNode = requestNode; // request & response
responseNode->sema = responseSema;
responseNode->timeout = NV_WAIT_INFINITE;
responseNode->tag = hEc->tag;
DISP_MESSAGE(("NvEcSendRequest:responseNode->tag=0x%x\n", responseNode->tag));
responseNode->size = ResponseSize;
NvOsMutexLock( ec->responseMutex );
NVEC_ENQ( ec->response, responseNode );
DISP_MESSAGE(("\r\nSendReq ec->responseBegin=0x%x", ec->responseBegin));
NvOsMutexUnlock( ec->responseMutex );
}
NvOsMutexLock( ec->mutex );
if ( !ec->thread )
NvEcPrivThreadCreate( ec );
NvOsMutexUnlock( ec->mutex );
// Trigger EcPrivThread
NvOsSemaphoreSignal( ec->sema );
DISP_MESSAGE(("\r\nSendReq requestNode=0x%x, requestNode->responseNode=0x%x",
requestNode, requestNode->responseNode));
// Wait on Request returns
NvOsSemaphoreWait( requestSema );
DISP_MESSAGE(("\r\nSendReq Out of req sema"));
e = requestNode->status;
if ( NvSuccess != e )
{
NvEcResponseNode *t = NULL, *p = NULL;
// de-queue responseNode too !!!!
NvOsMutexLock( ec->responseMutex );
NVEC_REMOVE_FROM_Q( ec->response, responseNode, t, p );
DISP_MESSAGE(("\r\nSendReq responseBegin=0x%x", ec->responseBegin));
NvOsMutexUnlock( ec->responseMutex );
goto fail;
}
if ( pResponse )
{
// Wait on Response returns
NvOsSemaphoreWait( responseSema );
DISP_MESSAGE(("\r\nSendReq Out of resp sema"));
NV_CHECK_ERROR_CLEANUP( responseNode->status );
NvOsMemcpy(pResponse, &responseNode->response, ResponseSize);
}
// if successful, nodes should be de-queue already but not freed yet
fail:
NvOsSemaphoreDestroy( requestSema );
NvOsSemaphoreDestroy( responseSema );
DISP_MESSAGE(("\r\nSendReq Freeing requestNode=0x%x, responseNode=0x%x",
requestNode, responseNode));
NvOsFree( requestNode );
NvOsFree( responseNode );
return e;
}
long nvrm_unlocked_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
NvError err;
NvOsIoctlParams p;
NvU32 size;
NvU32 small_buf[8];
void *ptr = 0;
long e;
NvBool bAlloc = NV_FALSE;
struct nvrm_file_priv *priv = file->private_data;
switch( cmd ) {
case NvRmIoctls_Generic:
{
NvDispatchCtx dctx;
dctx.Rt = s_RtHandle;
dctx.Client = priv->rt_client;
dctx.PackageIdx = 0;
err = NvOsCopyIn( &p, (void *)arg, sizeof(p) );
if( err != NvSuccess )
{
printk( "NvRmIoctls_Generic: copy in failed\n" );
goto fail;
}
//printk( "NvRmIoctls_Generic: %d %d %d\n", p.InBufferSize,
// p.InOutBufferSize, p.OutBufferSize );
size = p.InBufferSize + p.InOutBufferSize + p.OutBufferSize;
if( size <= sizeof(small_buf) )
{
ptr = small_buf;
}
else
{
ptr = NvOsAlloc( size );
if( !ptr )
{
printk( "NvRmIoctls_Generic: alloc failure (%d bytes)\n",
size );
goto fail;
}
bAlloc = NV_TRUE;
}
err = NvOsCopyIn( ptr, p.pBuffer, p.InBufferSize +
p.InOutBufferSize );
if( err != NvSuccess )
{
printk( "NvRmIoctls_Generic: copy in failure\n" );
goto fail;
}
if (priv->su) {
err = NvRm_Dispatch( ptr, p.InBufferSize + p.InOutBufferSize,
((NvU8 *)ptr) + p.InBufferSize, p.InOutBufferSize +
p.OutBufferSize, &dctx );
} else {
err = NvRm_Dispatch_Others( ptr, p.InBufferSize + p.InOutBufferSize,
((NvU8 *)ptr) + p.InBufferSize, p.InOutBufferSize +
p.OutBufferSize, &dctx );
}
if( err != NvSuccess )
{
printk( "NvRmIoctls_Generic: dispatch failure\n" );
goto fail;
}
if( p.InOutBufferSize || p.OutBufferSize )
{
err = NvOsCopyOut( ((NvU8 *)((NvOsIoctlParams *)arg)->pBuffer)
+ p.InBufferSize,
((NvU8 *)ptr) + p.InBufferSize,
p.InOutBufferSize + p.OutBufferSize );
if( err != NvSuccess )
{
printk( "NvRmIoctls_Generic: copy out failure\n" );
goto fail;
}
}
break;
}
case NvRmIoctls_NvRmGraphics:
printk( "NvRmIoctls_NvRmGraphics: not supported\n" );
goto fail;
case NvRmIoctls_NvRmFbControl:
printk( "NvRmIoctls_NvRmFbControl: deprecated \n" );
break;
case NvRmIoctls_NvRmMemRead:
case NvRmIoctls_NvRmMemWrite:
case NvRmIoctls_NvRmMemReadStrided:
case NvRmIoctls_NvRmGetCarveoutInfo:
case NvRmIoctls_NvRmMemWriteStrided:
goto fail;
case NvRmIoctls_NvRmMemMapIntoCallerPtr:
// FIXME: implement?
printk( "NvRmIoctls_NvRmMemMapIntoCallerPtr: not supported\n" );
goto fail;
case NvRmIoctls_NvRmBootDone:
return tegra_start_dvfsd();
case NvRmIoctls_NvRmGetClientId:
err = NvOsCopyIn(&p, (void*)arg, sizeof(p));
if (err != NvSuccess)
{
NvOsDebugPrintf("NvRmIoctls_NvRmGetClientId: copy in failed\n");
goto fail;
}
NV_ASSERT(p.InBufferSize == 0);
NV_ASSERT(p.OutBufferSize == sizeof(NvRtClientHandle));
NV_ASSERT(p.InOutBufferSize == 0);
if (NvOsCopyOut(p.pBuffer,
&priv->rt_client,
sizeof(NvRtClientHandle)) != NvSuccess)
{
NvOsDebugPrintf("Failed to copy client id\n");
goto fail;
}
break;
case NvRmIoctls_NvRmClientAttach:
{
NvRtClientHandle Client;
err = NvOsCopyIn(&p, (void*)arg, sizeof(p));
if (err != NvSuccess)
{
NvOsDebugPrintf("NvRmIoctls_NvRmClientAttach: copy in failed\n");
goto fail;
}
NV_ASSERT(p.InBufferSize == sizeof(NvRtClientHandle));
NV_ASSERT(p.OutBufferSize == 0);
NV_ASSERT(p.InOutBufferSize == 0);
if (NvOsCopyIn((void*)&Client,
p.pBuffer,
sizeof(NvRtClientHandle)) != NvSuccess)
{
NvOsDebugPrintf("Failed to copy client id\n");
goto fail;
}
NV_ASSERT(Client || !"Bad client");
if (Client == priv->rt_client)
{
// The daemon is attaching to itself, no need to add refcount
break;
}
if (NvRtAddClientRef(s_RtHandle, Client) != NvSuccess)
{
NvOsDebugPrintf("Client ref add unsuccessful\n");
goto fail;
}
break;
}
case NvRmIoctls_NvRmClientDetach:
{
NvRtClientHandle Client;
err = NvOsCopyIn(&p, (void*)arg, sizeof(p));
if (err != NvSuccess)
{
NvOsDebugPrintf("NvRmIoctls_NvRmClientAttach: copy in failed\n");
goto fail;
}
NV_ASSERT(p.InBufferSize == sizeof(NvRtClientHandle));
NV_ASSERT(p.OutBufferSize == 0);
NV_ASSERT(p.InOutBufferSize == 0);
if (NvOsCopyIn((void*)&Client,
p.pBuffer,
sizeof(NvRtClientHandle)) != NvSuccess)
{
NvOsDebugPrintf("Failed to copy client id\n");
goto fail;
}
NV_ASSERT(Client || !"Bad client");
if (Client == priv->rt_client)
{
// The daemon is detaching from itself, no need to dec refcount
break;
}
client_detach(Client);
break;
}
// FIXME: power ioctls?
default:
printk( "unknown ioctl code\n" );
goto fail;
}
e = 0;
goto clean;
fail:
e = -EINVAL;
clean:
if( bAlloc )
{
NvOsFree( ptr );
}
return e;
}
NvError
NvRmPowerRegister(
NvRmDeviceHandle hRmDeviceHandle,
NvOsSemaphoreHandle hEventSemaphore,
NvU32* pClientId)
{
NvU32 FreeIndex;
NvError error;
NvOsSemaphoreHandle hSema = NULL;
NvRmPowerClient* pNewClient = NULL;
NvRmPowerRegistry* pRegistry = &s_PowerRegistry;
NV_ASSERT(hRmDeviceHandle);
NV_ASSERT(pClientId);
// If non-zero semaphore handle is passed, duplicate it to be avialable
// after the call. Abort registration if non-zero handle is invalid
if (hEventSemaphore != NULL)
{
error = NvOsSemaphoreClone(hEventSemaphore, &hSema);
if (error != NvSuccess)
{
NV_ASSERT(!" Power Register Semaphore Clone error. ");
}
}
NvOsMutexLock(s_hPowerClientMutex);
// Find free registry entry for the new client
for (FreeIndex = 0; FreeIndex < pRegistry->UsedIndexRange; FreeIndex++)
{
if (pRegistry->pPowerClients[FreeIndex] == NULL)
break;
}
if (FreeIndex == pRegistry->AvailableEntries)
{
// If all avilable entries are used, re-size registry array
NvU32 entries = pRegistry->AvailableEntries +
NVRM_POWER_REGISTRY_DELTA;
size_t s = sizeof(*pRegistry->pPowerClients) * (size_t)entries;
NvRmPowerClient** p = NvOsRealloc(pRegistry->pPowerClients, s);
if (p == NULL)
{
NvU32 old_size;
/* fall back to NvOsAlloc */
p = NvOsAlloc( s );
if( p == NULL )
{
goto failed;
}
/* copy the old data, free, etc, */
old_size = sizeof(*pRegistry->pPowerClients) *
pRegistry->AvailableEntries;
NvOsMemcpy( p, pRegistry->pPowerClients, old_size );
NvOsFree( pRegistry->pPowerClients );
}
pRegistry->pPowerClients = p;
pRegistry->AvailableEntries = entries;
}
if (FreeIndex == pRegistry->UsedIndexRange)
{
// If reached used index range boundary, advance it
pRegistry->UsedIndexRange++;
}
// Allocate and store new client record pointer in registry (null-pointer
// marks registry entry as free, so it's OK to store it before error check)
pNewClient = NvOsAlloc(sizeof(*pNewClient));
pRegistry->pPowerClients[FreeIndex] = pNewClient;
if (pNewClient == NULL)
{
goto failed;
}
// Fill in new client entry
pNewClient->hEventSemaphore = hSema;
pNewClient->Event = NvRmPowerEvent_NoEvent;
pNewClient->pVoltageReqHead = NULL;
pNewClient->pClockReqHead = NULL;
pNewClient->pStarvationHints = NULL;
pNewClient->tag = *pClientId;
/*
* Combine index with client pointer into registration ID returned to the
* client. This will make it a little bit more difficult for not-registered
* clients to guess/re-use IDs
*/
pNewClient->id = NVRM_POWER_INDEX2ID(FreeIndex, (NvU32)pClientId);
*pClientId = pNewClient->id;
NvOsMutexUnlock(s_hPowerClientMutex);
return NvSuccess;
failed:
NvOsFree(pNewClient);
NvOsSemaphoreDestroy(hSema);
NvOsMutexUnlock(s_hPowerClientMutex);
return NvError_InsufficientMemory;
}
long nvec_unlocked_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
NvError err;
NvOsIoctlParams p;
NvU32 size;
NvU32 small_buf[8];
void *ptr = 0;
long e;
NvBool bAlloc = NV_FALSE;
switch( cmd ) {
case NvECKernelIoctls_Generic:
{
NvDispatchCtx dctx;
dctx.Rt = s_RtHandle;
dctx.Client = (NvRtClientHandle)file->private_data;
dctx.PackageIdx = 0;
err = NvOsCopyIn(&p, (void *)arg, sizeof(p));
if (err != NvSuccess) {
printk("NvECKernelIoctls_Generic: copy in failed\n");
goto fail;
}
size = p.InBufferSize + p.InOutBufferSize + p.OutBufferSize;
if (size <= sizeof(small_buf)) {
ptr = small_buf;
} else {
ptr = NvOsAlloc(size);
if (!ptr) {
printk("NvECKernelIoctls_Generic: alloc err\n");
goto fail;
}
bAlloc = NV_TRUE;
}
err = NvOsCopyIn(ptr, p.pBuffer, p.InBufferSize +
p.InOutBufferSize);
if (err != NvSuccess) {
printk("NvECKernelIoctls_Generic: copy in failure\n");
goto fail;
}
err = NvECPackage_Dispatch(ptr,
p.InBufferSize + p.InOutBufferSize,
((NvU8 *)ptr) + p.InBufferSize, p.InOutBufferSize +
p.OutBufferSize, &dctx);
if (err != NvSuccess) {
printk("NvECKernelIoctls_Generic: dispatch failure\n");
goto fail;
}
if (p.InOutBufferSize || p.OutBufferSize) {
err = NvOsCopyOut(
((NvU8 *)((NvOsIoctlParams *)arg)->pBuffer) +
p.InBufferSize,
((NvU8 *)ptr) + p.InBufferSize,
p.InOutBufferSize + p.OutBufferSize);
if (err != NvSuccess) {
printk("NvECKernelIoctls_Generic: copyout err\n");
goto fail;
}
}
break;
}
default:
printk("unknown ioctl code\n");
goto fail;
}
e = 0;
goto clean;
fail:
e = -EINVAL;
clean:
if (bAlloc)
NvOsFree(ptr);
return e;
}
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;
}
}
NvError
NvRmPwmOpen(
NvRmDeviceHandle hDevice,
NvRmPwmHandle *phPwm)
{
NvError status = NvSuccess;
NvU32 PwmPhysAddr = 0, i = 0, PmcPhysAddr = 0;
NvRmModuleCapability caps[4];
NvRmModuleCapability *pCap = NULL;
NV_ASSERT(hDevice);
NV_ASSERT(phPwm);
NvOsMutexLock(s_hPwmMutex);
if (s_hPwm)
{
s_hPwm->RefCount++;
goto exit;
}
// Allcoate the memory for the pwm handle
s_hPwm = NvOsAlloc(sizeof(NvRmPwm));
if (!s_hPwm)
{
status = NvError_InsufficientMemory;
goto fail;
}
NvOsMemset(s_hPwm, 0, sizeof(NvRmPwm));
// Set the pwm handle parameters
s_hPwm->RmDeviceHandle = hDevice;
// Get the pwm physical and virtual base address
NvRmModuleGetBaseAddress(hDevice,
NVRM_MODULE_ID(NvRmModuleID_Pwm, 0),
&PwmPhysAddr, &(s_hPwm->PwmBankSize));
s_hPwm->PwmBankSize = PWM_BANK_SIZE;
for (i = 0; i < NvRmPwmOutputId_Num-2; i++)
{
status = NvRmPhysicalMemMap(
PwmPhysAddr + i*s_hPwm->PwmBankSize,
s_hPwm->PwmBankSize,
NVOS_MEM_READ_WRITE,
NvOsMemAttribute_Uncached,
(void**)&s_hPwm->VirtualAddress[i]);
if (status != NvSuccess)
{
NvOsFree(s_hPwm);
goto fail;
}
}
// Get the pmc physical and virtual base address
NvRmModuleGetBaseAddress(hDevice,
NVRM_MODULE_ID(NvRmModuleID_Pmif, 0),
&PmcPhysAddr, &(s_hPwm->PmcBankSize));
s_hPwm->PmcBankSize = PMC_BANK_SIZE;
status = NvRmPhysicalMemMap(
PmcPhysAddr,
s_hPwm->PmcBankSize,
NVOS_MEM_READ_WRITE,
NvOsMemAttribute_Uncached,
(void**)&s_hPwm->VirtualAddress[NvRmPwmOutputId_Num-2]);
if (status != NvSuccess)
{
NvOsFree(s_hPwm);
goto fail;
}
caps[0].MajorVersion = 1;
caps[0].MinorVersion = 0;
caps[0].EcoLevel = 0;
caps[0].Capability = &caps[0];
caps[1].MajorVersion = 1;
caps[1].MinorVersion = 1;
caps[1].EcoLevel = 0;
caps[1].Capability = &caps[1];
caps[2].MajorVersion = 1;
caps[2].MinorVersion = 2;
caps[2].EcoLevel = 0;
caps[2].Capability = &caps[2];
caps[3].MajorVersion = 2;
caps[3].MinorVersion = 0;
caps[3].EcoLevel = 0;
caps[3].Capability = &caps[3];
NV_ASSERT_SUCCESS(NvRmModuleGetCapabilities(
hDevice,
NvRmModuleID_Pwm,
caps,
sizeof(caps)/sizeof(caps[0]),
(void**)&pCap));
if ((pCap->MajorVersion > 1) ||
((pCap->MajorVersion == 1) && (pCap->MinorVersion > 0)))
s_IsFreqDividerSupported = NV_TRUE;
s_hPwm->RefCount++;
exit:
*phPwm = s_hPwm;
NvOsMutexUnlock(s_hPwmMutex);
return NvSuccess;
fail:
NvOsMutexUnlock(s_hPwmMutex);
return status;
}
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 NvOdmOsFree(void *ptr)
{
NvOsFree( ptr );
}
