NvError NvRmPrivPmuInit(NvRmDeviceHandle hRmDevice)
{
NvError e;
ExecPlatform env;
NvOdmPmuProperty PmuProperty;
NV_ASSERT(hRmDevice);
env = NvRmPrivGetExecPlatform(hRmDevice);
NvOsMemset(&s_Pmu, 0, sizeof(NvRmPmu));
s_PmuSupportedEnv = NV_FALSE;
if (env == ExecPlatform_Soc)
{
// Set supported environment flag
s_PmuSupportedEnv = NV_TRUE;
// Create the PMU mutex, semaphore, interrupt handler thread,
// register PMU interrupt, and get ODM PMU handle
NV_CHECK_ERROR_CLEANUP(NvOsMutexCreate(&s_Pmu.hMutex));
NV_CHECK_ERROR_CLEANUP(NvOsSemaphoreCreate(&s_Pmu.hSemaphore, 0));
if (NvOdmQueryGetPmuProperty(&PmuProperty) && PmuProperty.IrqConnected)
{
if (hRmDevice->ChipId.Id >= 0x20)
NvRmPrivAp20SetPmuIrqPolarity(
hRmDevice, PmuProperty.IrqPolarity);
else
NV_ASSERT(PmuProperty.IrqPolarity ==
NvOdmInterruptPolarity_Low);
{
NvOsInterruptHandler hPmuIsr = PmuIsr;
NvU32 PmuExtIrq = NvRmGetIrqForLogicalInterrupt(
hRmDevice, NVRM_MODULE_ID(NvRmPrivModuleID_PmuExt, 0), 0);
NV_CHECK_ERROR_CLEANUP(NvRmInterruptRegister(hRmDevice, 1,
&PmuExtIrq, &hPmuIsr, &s_Pmu, &s_Pmu.hInterrupt, NV_FALSE));
}
}
if(!NvOdmPmuDeviceOpen(&s_Pmu.hOdmPmu))
{
e = NvError_NotInitialized;
goto fail;
}
NV_CHECK_ERROR_CLEANUP(NvOsThreadCreate(PmuThread, &s_Pmu, &s_Pmu.hThread));
NvRmPrivIoPowerControlInit(hRmDevice);
NvRmPrivCoreVoltageInit(hRmDevice);
}
return NvSuccess;
fail:
NvRmPrivPmuDeinit(hRmDevice);
return e;
}
NvOdmOsSemaphoreHandle NvOdmOsSemaphoreCreate(NvU32 value)
{
NvError err;
NvOsSemaphoreHandle s;
err = NvOsSemaphoreCreate(&s, value);
if( err == NvSuccess )
{
return (NvOdmOsSemaphoreHandle)s;
}
return NULL;
}
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;
}
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;
}
static int nvec_battery_probe(struct nvec_device *pdev)
{
int i, rc;
NvError ErrorStatus = NvSuccess;
NvBool result = NV_FALSE;
batt_dev = kzalloc(sizeof(struct tegra_battery_dev), GFP_KERNEL);
if (!batt_dev) {
pr_err("nvec_battery_probe:NOMEM\n");
return -ENOMEM;
}
ErrorStatus = NvOsMutexCreate(&batt_dev->hBattEventMutex);
if (NvSuccess != ErrorStatus) {
pr_err("NvOsMutexCreate Failed!\n");
goto Cleanup;
}
ErrorStatus = NvOsSemaphoreCreate(&batt_dev->hOdmSemaphore, 0);
if (NvSuccess != ErrorStatus) {
pr_err("NvOsSemaphoreCreate Failed!\n");
goto Cleanup;
}
/*Henry++ adjust thread to be createn at last
batt_dev->exitThread = NV_FALSE;
batt_dev->inSuspend = NV_FALSE;
ErrorStatus = NvOsThreadCreate(NvBatteryEventHandlerThread,
batt_dev,
&(batt_dev->hBattEventThread));
if (NvSuccess != ErrorStatus) {
pr_err("NvOsThreadCreate FAILED\n");
goto Cleanup;
}
*/
//Henry add retry when fail ****
for(i=0;i<BATTERY_RETRY_TIMES;i++){
result = NvOdmBatteryDeviceOpen(&(batt_dev->hOdmBattDev),
(NvOdmOsSemaphoreHandle *)&batt_dev->hOdmSemaphore);
if (!result || !batt_dev->hOdmBattDev) {
pr_err("NvOdmBatteryDeviceOpen FAILED,retry i=%i\n",i);
NvOsWaitUS(10000);
continue;
}
else{
break;
}
}
if(i==BATTERY_RETRY_TIMES){
pr_err("NvOdmBatteryDeviceOpen FAILED\n");
goto Cleanup;
}
//******************************
for (i = 0; i < ARRAY_SIZE(tegra_power_supplies); i++) {
if (power_supply_register(&pdev->dev, &tegra_power_supplies[i]))
pr_err("Failed to register power supply\n");
}
batt_dev->batt_status_poll_period = NVBATTERY_POLLING_INTERVAL;
rc = device_create_file(&pdev->dev, &tegra_battery_attr);
if (rc) {
for (i = 0; i < ARRAY_SIZE(tegra_power_supplies); i++) {
power_supply_unregister(&tegra_power_supplies[i]);
}
pr_err("nvec_battery_probe:device_create_file FAILED");
goto Cleanup;
}
//Henry++ adjust thread to be createn at last
batt_dev->exitThread = NV_FALSE;
batt_dev->inSuspend = NV_FALSE;
ErrorStatus = NvOsThreadCreate(NvBatteryEventHandlerThread,
batt_dev,
&(batt_dev->hBattEventThread));
if (NvSuccess != ErrorStatus) {
pr_err("NvOsThreadCreate FAILED\n");
goto Cleanup;
}
return 0;
Cleanup:
batt_dev->exitThread = NV_TRUE;
if (batt_dev->hOdmSemaphore) {
NvOsSemaphoreSignal(batt_dev->hOdmSemaphore);
NvOsSemaphoreDestroy(batt_dev->hOdmSemaphore);
batt_dev->hOdmSemaphore = NULL;
}
if (batt_dev->hBattEventThread) {
NvOsThreadJoin(batt_dev->hBattEventThread);
}
if (batt_dev->hBattEventMutex) {
NvOsMutexDestroy(batt_dev->hBattEventMutex);
batt_dev->hBattEventMutex = NULL;
}
if (batt_dev->hOdmBattDev) {
NvOdmBatteryDeviceClose(batt_dev->hOdmBattDev);
batt_dev->hOdmBattDev = NULL;
}
kfree(batt_dev);
batt_dev = NULL;
//return -1;
return 0; //henry++ workaround system can't enter suspend
}
NvError tegra_audiofx_createfx(struct tegra_audio_data *audio_context)
{
NvAudioFxMixerHandle m_hMixer =
(NvAudioFxMixerHandle)audio_context->mixer_handle;
FxNotifier *m_FxNotifier = (FxNotifier*)&audio_context->m_FxNotifier;
NvRmDeviceHandle m_hRm = (NvRmDeviceHandle)audio_context->m_hRm;
NvError e = NvSuccess;
NvAudioFxNotifierConnectionDescriptor connectionDesciptor;
NvAudioFxMessage message;
memset(&connectionDesciptor,
0,
sizeof(NvAudioFxNotifierConnectionDescriptor));
memset(&message, 0, sizeof(NvAudioFxMessage));
e = NvOsSemaphoreCreate(&m_FxNotifier->hTransportSemaphore, 0);
if (e != NvSuccess) {
snd_printk(KERN_ERR "NvOsSemaphoreCreate failed!\n");
goto EXIT_WITH_ERROR;
}
m_FxNotifier->hNotifier =
(NvAudioFxNotifierHandle)tegra_transport_mixer_create_object(
m_hMixer,
NvAudioFxNotifierId);
if (!m_FxNotifier->hNotifier) {
snd_printk(KERN_ERR "transport_mixer_create_object failed!\n");
goto EXIT_WITH_ERROR;
}
e = NvRmTransportOpen(m_hRm,
0,
m_FxNotifier->hTransportSemaphore,
&m_FxNotifier->hTransport);
if (e != NvSuccess) {
snd_printk(KERN_ERR "NvRmTransportOpen failed!\n");
goto EXIT_WITH_ERROR;
}
NvRmTransportGetPortName(m_FxNotifier->hTransport,
(NvU8*)&connectionDesciptor.PortName,
sizeof(NvU8) * 16);
e = NvOsThreadCreate(tegra_audiofx_notifier_thread,
audio_context,
&m_FxNotifier->hTransportThread);
if (e != NvSuccess) {
snd_printk(KERN_ERR "NvOsThreadCreate failed!\n");
goto EXIT_WITH_ERROR;
}
e = tegra_transport_set_property(
(NvAudioFxObjectHandle)m_FxNotifier->hNotifier,
NvAudioFxNotifierProperty_Connect,
sizeof(NvAudioFxNotifierConnectionDescriptor),
&connectionDesciptor);
if (e != NvSuccess) {
snd_printk(KERN_ERR "tegra_transport_set_property failed!\n");
goto EXIT_WITH_ERROR;
}
goto EXIT;
EXIT_WITH_ERROR:
tegra_audiofx_destroyfx(audio_context);
EXIT:
return e;
}
NvError tegra_transport_init(NvddkAudioFxFxnTable* xrt_fxns)
{
NvError status = NvSuccess;
xrt_fxns->MixerOpen = tegra_transport_mixer_open;
xrt_fxns->MixerClose = tegra_transport_mixer_close;
xrt_fxns->MixerCreateObject = tegra_transport_mixer_create_object;
xrt_fxns->MixerDestroyObject = tegra_transport_mixer_destroy_object;
xrt_fxns->MixerMapBuffer = tegra_transport_mixer_map_buffer;
xrt_fxns->MixerUnmapBuffer = tegra_transport_mixer_unmap_buffer;
xrt_fxns->StreamAddBuffer = tegra_transport_stream_add_buffer;
xrt_fxns->GetProperty = tegra_transport_get_property;
xrt_fxns->SetProperty = tegra_transport_set_property;
/* Check if the FX Transport is already open.*/
if (atrans) {
spin_lock(&atrans->lock);
atrans->RefCount++;
spin_unlock(&atrans->lock);
goto EXIT;
}
/* Map a shared memory buffer.*/
atrans = (AlsaTransport*)kzalloc(sizeof(AlsaTransport),GFP_KERNEL);
if (!atrans) {
snd_printk(KERN_ERR "AlsaTransportInit kalloc failed! \n");
goto EXIT_WITH_ERROR;
}
spin_lock_init(&atrans->lock);
memset(atrans, 0, sizeof(AlsaTransport));
spin_lock(&atrans->lock);
atrans->RefCount++;
spin_unlock(&atrans->lock);
atrans->hRmDevice = s_hRmGlobal;
status = NvOsSemaphoreCreate(&atrans->hServiceSema, 0);
if (status != NvSuccess) {
snd_printk(KERN_ERR "NvOsSemaphoreCreate failed!\n");
goto EXIT_WITH_ERROR;
}
status = NvRmTransportOpen(atrans->hRmDevice,
"ALSA_TRANSPORT",
atrans->hServiceSema,
&atrans->hRmTransport);
if (status != NvSuccess) {
snd_printk(KERN_ERR "NvRmTransportOpen failed!\n");
goto EXIT_WITH_ERROR;
}
status = NvOsThreadCreate(AlsaTransportServiceThread,
NULL,
&atrans->hServiceThread);
if (status != NvSuccess) {
snd_printk(KERN_ERR "NvOsThreadCreate failed!\n");
goto EXIT_WITH_ERROR;
}
while (!atrans->TransportConnected) {
NvOsThreadYield();
}
goto EXIT;
EXIT_WITH_ERROR:
if (atrans) {
tegra_transport_deinit();
}
EXIT:
return status;
}
NvError
NvDdkUsbPhyOpen(
NvRmDeviceHandle hRm,
NvU32 Instance,
NvDdkUsbPhyHandle *hUsbPhy)
{
NvError e;
NvU32 MaxInstances = 0;
NvDdkUsbPhy *pUsbPhy = NULL;
NvOsMutexHandle UsbPhyMutex = NULL;
NvRmModuleInfo info[MAX_USB_INSTANCES];
NvU32 j;
NV_ASSERT(hRm);
NV_ASSERT(hUsbPhy);
NV_ASSERT(Instance < MAX_USB_INSTANCES);
NV_CHECK_ERROR(NvRmModuleGetModuleInfo( hRm, NvRmModuleID_Usb2Otg, &MaxInstances, NULL ));
if (MaxInstances > MAX_USB_INSTANCES)
{
// Ceil "instances" to MAX_USB_INSTANCES
MaxInstances = MAX_USB_INSTANCES;
}
NV_CHECK_ERROR(NvRmModuleGetModuleInfo( hRm, NvRmModuleID_Usb2Otg, &MaxInstances, info ));
for (j = 0; j < MaxInstances; j++)
{
// Check whether the requested instance is present
if(info[j].Instance == Instance)
break;
}
// No match found return
if (j == MaxInstances)
{
return NvError_ModuleNotPresent;
}
if (!s_UsbPhyMutex)
{
e = NvOsMutexCreate(&UsbPhyMutex);
if (e!=NvSuccess)
return e;
if (NvOsAtomicCompareExchange32(
(NvS32*)&s_UsbPhyMutex, 0, (NvS32)UsbPhyMutex)!=0)
{
NvOsMutexDestroy(UsbPhyMutex);
}
}
NvOsMutexLock(s_UsbPhyMutex);
if (!s_pUsbPhy)
{
s_pUsbPhy = NvOsAlloc(MaxInstances * sizeof(NvDdkUsbPhy));
if (s_pUsbPhy)
NvOsMemset(s_pUsbPhy, 0, MaxInstances * sizeof(NvDdkUsbPhy));
}
NvOsMutexUnlock(s_UsbPhyMutex);
if (!s_pUsbPhy)
return NvError_InsufficientMemory;
NvOsMutexLock(s_UsbPhyMutex);
if (!s_pUtmiPadConfig)
{
s_pUtmiPadConfig = NvOsAlloc(sizeof(NvDdkUsbPhyUtmiPadConfig));
if (s_pUtmiPadConfig)
{
NvRmPhysAddr PhyAddr;
NvOsMemset(s_pUtmiPadConfig, 0, sizeof(NvDdkUsbPhyUtmiPadConfig));
NvRmModuleGetBaseAddress(
hRm,
NVRM_MODULE_ID(NvRmModuleID_Usb2Otg, 0),
&PhyAddr, &s_pUtmiPadConfig->BankSize);
NV_CHECK_ERROR_CLEANUP(
NvRmPhysicalMemMap(
PhyAddr, s_pUtmiPadConfig->BankSize, NVOS_MEM_READ_WRITE,
NvOsMemAttribute_Uncached, (void **)&s_pUtmiPadConfig->pVirAdr));
}
}
NvOsMutexUnlock(s_UsbPhyMutex);
if (!s_pUtmiPadConfig)
return NvError_InsufficientMemory;
pUsbPhy = &s_pUsbPhy[Instance];
NvOsMutexLock(s_UsbPhyMutex);
if (!pUsbPhy->RefCount)
{
NvRmPhysAddr PhysAddr;
NvOsMutexHandle ThreadSafetyMutex = NULL;
NvOsMemset(pUsbPhy, 0, sizeof(NvDdkUsbPhy));
pUsbPhy->Instance = Instance;
pUsbPhy->hRmDevice = hRm;
pUsbPhy->RefCount = 1;
pUsbPhy->IsPhyPoweredUp = NV_FALSE;
pUsbPhy->pUtmiPadConfig = s_pUtmiPadConfig;
pUsbPhy->pProperty = NvOdmQueryGetUsbProperty(
NvOdmIoModule_Usb, pUsbPhy->Instance);
pUsbPhy->TurnOffPowerRail = UsbPhyTurnOffPowerRail(MaxInstances);
NV_CHECK_ERROR_CLEANUP(NvOsMutexCreate(&ThreadSafetyMutex));
if (NvOsAtomicCompareExchange32(
(NvS32*)&pUsbPhy->ThreadSafetyMutex, 0,
(NvS32)ThreadSafetyMutex)!=0)
{
NvOsMutexDestroy(ThreadSafetyMutex);
}
NvRmModuleGetBaseAddress(
pUsbPhy->hRmDevice,
NVRM_MODULE_ID(NvRmModuleID_Usb2Otg, pUsbPhy->Instance),
&PhysAddr, &pUsbPhy->UsbBankSize);
NV_CHECK_ERROR_CLEANUP(
NvRmPhysicalMemMap(
PhysAddr, pUsbPhy->UsbBankSize, NVOS_MEM_READ_WRITE,
NvOsMemAttribute_Uncached, (void **)&pUsbPhy->UsbVirAdr));
NvRmModuleGetBaseAddress(
pUsbPhy->hRmDevice,
NVRM_MODULE_ID(NvRmModuleID_Misc, 0),
&PhysAddr, &pUsbPhy->MiscBankSize);
NV_CHECK_ERROR_CLEANUP(
NvRmPhysicalMemMap(
PhysAddr, pUsbPhy->MiscBankSize, NVOS_MEM_READ_WRITE,
NvOsMemAttribute_Uncached, (void **)&pUsbPhy->MiscVirAdr));
if ( ( pUsbPhy->pProperty->UsbInterfaceType ==
NvOdmUsbInterfaceType_UlpiNullPhy) ||
( pUsbPhy->pProperty->UsbInterfaceType ==
NvOdmUsbInterfaceType_UlpiExternalPhy))
{
if (NvRmSetModuleTristate(
pUsbPhy->hRmDevice,
NVRM_MODULE_ID(NvRmModuleID_Usb2Otg, pUsbPhy->Instance),
NV_FALSE) != NvSuccess )
return NvError_NotSupported;
}
// Register with Power Manager
NV_CHECK_ERROR_CLEANUP(
NvOsSemaphoreCreate(&pUsbPhy->hPwrEventSem, 0));
pUsbPhy->RmPowerClientId = NVRM_POWER_CLIENT_TAG('U','S','B','p');
NV_CHECK_ERROR_CLEANUP(
NvRmPowerRegister(pUsbPhy->hRmDevice,
pUsbPhy->hPwrEventSem, &pUsbPhy->RmPowerClientId));
// Open the H/W interface
UsbPhyOpenHwInterface(pUsbPhy);
// Initialize the USB Phy
NV_CHECK_ERROR_CLEANUP(UsbPhyInitialize(pUsbPhy));
}
else
{
pUsbPhy->RefCount++;
}
*hUsbPhy = pUsbPhy;
NvOsMutexUnlock(s_UsbPhyMutex);
return NvSuccess;
fail:
NvDdkUsbPhyClose(pUsbPhy);
NvOsMutexUnlock(s_UsbPhyMutex);
return e;
}
static int nvec_battery_probe(struct nvec_device *pdev)
{
int i, rc;
NvError ErrorStatus = NvSuccess;
NvBool result = NV_FALSE;
batt_dev = kzalloc(sizeof(struct tegra_battery_dev), GFP_KERNEL);
if (!batt_dev) {
pr_err("nvec_battery_probe:NOMEM\n");
return -ENOMEM;
}
ErrorStatus = NvOsSemaphoreCreate(&batt_dev->hOdmSemaphore, 0);
if (NvSuccess != ErrorStatus) {
pr_err("NvOsSemaphoreCreate Failed!\n");
goto Cleanup;
}
batt_dev->exitThread = NV_FALSE;
ErrorStatus = NvOsThreadCreate(NvBatteryEventHandlerThread,
batt_dev,
&(batt_dev->hBattEventThread));
if (NvSuccess != ErrorStatus) {
pr_err("NvOsThreadCreate FAILED\n");
goto Cleanup;
}
result = NvOdmBatteryDeviceOpen(&(batt_dev->hOdmBattDev),
(NvOdmOsSemaphoreHandle *)&batt_dev->hOdmSemaphore,
&(batt_dev->ec_version)); //Daniel 20100823, put ec version to fs.
if (!result || !batt_dev->hOdmBattDev) {
pr_err("NvOdmBatteryDeviceOpen FAILED\n");
goto Cleanup;
}
for (i = 0; i < ARRAY_SIZE(tegra_power_supplies); i++) {
if (power_supply_register(&pdev->dev, &tegra_power_supplies[i]))
pr_err("Failed to register power supply\n");
}
batt_dev->batt_status_poll_period = NVBATTERY_POLLING_INTERVAL_MILLISECS;
setup_timer(&(batt_dev->battery_poll_timer), tegra_battery_poll_timer_func, 0);
mod_timer(&(batt_dev->battery_poll_timer),
jiffies + msecs_to_jiffies(batt_dev->batt_status_poll_period));
rc = device_create_file(&pdev->dev, &tegra_battery_attr);
rc = device_create_file(&pdev->dev, &tegra_battery_version); //Daniel 20100823, put ec version to fs
if (rc) {
for (i = 0; i < ARRAY_SIZE(tegra_power_supplies); i++) {
power_supply_unregister(&tegra_power_supplies[i]);
}
del_timer_sync(&(batt_dev->battery_poll_timer));
pr_err("nvec_battery_probe:device_create_file FAILED");
goto Cleanup;
}
return 0;
Cleanup:
batt_dev->exitThread = NV_TRUE;
if (batt_dev->hOdmSemaphore) {
NvOsSemaphoreSignal(batt_dev->hOdmSemaphore);
NvOsSemaphoreDestroy(batt_dev->hOdmSemaphore);
batt_dev->hOdmSemaphore = NULL;
}
if (batt_dev->hBattEventThread) {
NvOsThreadJoin(batt_dev->hBattEventThread);
}
if (batt_dev->hOdmBattDev) {
NvOdmBatteryDeviceClose(batt_dev->hOdmBattDev);
batt_dev->hOdmBattDev = NULL;
}
kfree(batt_dev);
batt_dev = NULL;
return -1;
}