NvBool NvOdmSdioSuspend(NvOdmSdioHandle hOdmSdio)
{
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
NvBool Status = NV_TRUE;
if (!hOdmSdio->PoweredOn)
{
NV_DRIVER_TRACE(("SDIO%d already suspended", hOdmSdio->Instance));
return NV_TRUE;
}
NV_DRIVER_TRACE(("Suspend SDIO%d", hOdmSdio->Instance));
NvOdmSetPowerOnSdio(hOdmSdio, NV_FALSE);
pConnectivity = hOdmSdio->pConnectivity;
if (pConnectivity->Guid == WLAN_GUID)
{
// Turn off power
Status = SdioOdmWlanSetPowerOn(hOdmSdio, NV_FALSE);
}
hOdmSdio->PoweredOn = NV_FALSE;
return Status;
}
NvOdmUsbUlpiHandle NvOdmUsbUlpiOpen(NvU32 Instance)
{
NvOdmUsbUlpi*pDevice = NULL;
NvU32 ClockInstances[MAX_CLOCKS];
NvU32 ClockFrequencies[MAX_CLOCKS];
NvU32 NumClocks;
pDevice = NvOdmOsAlloc(sizeof(NvOdmUsbUlpi));
if(pDevice == NULL)
return NULL;
if(!NvOdmExternalClockConfig(SMSC3317GUID, NV_FALSE, ClockInstances,
ClockFrequencies, &NumClocks))
{
NV_DRIVER_TRACE (("ERROR NvOdmUsbUlpiOpen: "
"NvOdmExternalClockConfig fail\n"));
goto ExitUlpiOdm;
}
NvOdmOsSleepMS(10);
if (!s_hGpio)
s_hGpio = NvOdmGpioOpen();
if (!s_hGpio)
{
NV_DRIVER_TRACE (("ERROR NvOdmUsbUlpiOpen: "
"Not able to open gpio handle\n"));
goto ExitUlpiOdm;
}
if (!s_hResetPin)
s_hResetPin = NvOdmGpioAcquirePinHandle(s_hGpio, ULPI_RESET_PORT,
ULPI_RESET_PIN);
if (!s_hResetPin)
{
NvOdmGpioClose(s_hGpio);
s_hGpio = NULL;
NV_DRIVER_TRACE (("ERROR NvOdmGpioAcquirePinHandle: "
"Not able to Acq pinhandle\n"));
goto ExitUlpiOdm;
}
// Pull high on RESETB ( 22nd pin of smsc3315)
// config as out put pin
NvOdmGpioConfig(s_hGpio,s_hResetPin, NvOdmGpioPinMode_Output);
// Set low to write high on ULPI_RESETB pin
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x01);
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x0);
NvOdmOsSleepMS(5);
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x01);
pDevice->CurrentGUID = SMSC3317GUID;
return pDevice;
ExitUlpiOdm:
NvOdmOsFree(pDevice);
return NULL;
}
NvBool NvOdmSdioResume(NvOdmSdioHandle hOdmSdio)
{
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
NvBool Status = NV_TRUE;
if (hOdmSdio->PoweredOn)
{
NV_DRIVER_TRACE(("SDIO%d already resumed", hOdmSdio->Instance));
return NV_TRUE;
}
NvOdmSetPowerOnSdio(hOdmSdio, NV_TRUE);
pConnectivity = hOdmSdio->pConnectivity;
if (pConnectivity->Guid == WLAN_GUID)
{
// Turn on power
Status = SdioOdmWlanSetPowerOn(hOdmSdio, NV_TRUE);
}
NV_DRIVER_TRACE(("Resume SDIO%d", hOdmSdio->Instance));
hOdmSdio->PoweredOn = NV_TRUE;
return Status;
}
void NvOdmSdioClose(NvOdmSdioHandle hOdmSdio)
{
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
NV_DRIVER_TRACE(("Close SDIO%d", hOdmSdio->Instance));
pConnectivity = hOdmSdio->pConnectivity;
if (pConnectivity->Guid == WLAN_GUID)
{
// Call Turn off power when close is Called
(void)SdioOdmWlanSetPowerOn(hOdmSdio, NV_FALSE);
//NvOdmGpioReleasePinHandle(hOdmSdio->hGpio, hOdmSdio->hPwrPin); //Sam ---
NvOdmGpioReleasePinHandle(hOdmSdio->hGpio, hOdmSdio->hResetPin);
NvOdmGpioClose(hOdmSdio->hGpio);
}
NvOdmSetPowerOnSdio(hOdmSdio, NV_FALSE);
if (hOdmSdio->hPmu != NULL)
{
NvOdmServicesPmuClose(hOdmSdio->hPmu);
}
NvOdmOsFree(hOdmSdio);
hOdmSdio = NULL;
}
NvOdmSdioHandle NvOdmSdioOpen(NvU32 Instance)
{
static NvOdmSdio *pDevice = NULL;
NvOdmServicesGpioHandle hGpioTemp = NULL;
NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[2];
const NvU32 *pOdmConfigs;
NvU32 NumOdmConfigs;
NvBool Status = NV_TRUE;
NvU32 DutyCycle;
NvU32 gRequestedFreqHzOrPeriod;
NvU32 ReturnedFreq;
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
};
searchVals[0] = NvOdmIoModule_Sdio;
searchVals[1] = Instance;
NvOdmQueryPinMux(NvOdmIoModule_Sdio, &pOdmConfigs, &NumOdmConfigs);
if (Instance >= NumOdmConfigs )
return NULL;
if( pOdmConfigs[Instance] == 0 )
return NULL;
NumOfGuids = NvOdmPeripheralEnumerate(
searchAttrs,
searchVals,
2,
&guid,
NumOfGuids);
// Get the peripheral connectivity information
pConnectivity = (NvOdmPeripheralConnectivity *)NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
return NULL;
pDevice = NvOdmOsAlloc(sizeof(NvOdmSdio));
pDevice->hPmu = NULL;
if(pDevice == NULL)
return (pDevice);
if (pDevice->hPmu == NULL)
{
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (NULL);
}
}
pDevice->pConnectivity = pConnectivity;
NvOdmSetPowerOnSdio(pDevice, NV_TRUE);
if (pConnectivity->Guid == WLAN_GUID)
{
// Getting the OdmGpio Handle
hGpioTemp = NvOdmGpioOpen();
if (hGpioTemp == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
// Search for the Vdd rail and set the proper volage to the rail.
/*
if (pConnectivity->AddressList[1].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Power Pin
pDevice->hPwrPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[1].Instance,
pConnectivity->AddressList[1].Address);
}
*/// Sam ---
if (pConnectivity->AddressList[2].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Reset Pin
pDevice->hResetPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[2].Instance,
pConnectivity->AddressList[2].Address);
}
// Setting the ON/OFF pin to output mode.
//NvOdmGpioConfig(hGpioTemp, pDevice->hPwrPin, NvOdmGpioPinMode_Output);// Sam ---
NvOdmGpioConfig(hGpioTemp, pDevice->hResetPin, NvOdmGpioPinMode_Output);
// Setting the Output Pin to Low
//NvOdmGpioSetState(hGpioTemp, pDevice->hPwrPin, 0x0); //Sam ---
NvOdmGpioSetState(hGpioTemp, pDevice->hResetPin, 0x0);
pDevice->hGpio = hGpioTemp;
s_hOdmPwm = NvOdmPwmOpen();
gRequestedFreqHzOrPeriod = 32000; //32KHz
DutyCycle = 3211264;
NvOdmPwmConfig(s_hOdmPwm, NvOdmPwmOutputId_Blink, NvOdmPwmMode_Blink_32KHzClockOutput,
DutyCycle, &gRequestedFreqHzOrPeriod, &ReturnedFreq);
Status = SdioOdmWlanSetPowerOn(pDevice, NV_TRUE);
if (Status != NV_TRUE)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
}
pDevice->PoweredOn = NV_TRUE;
pDevice->Instance = Instance;
NV_DRIVER_TRACE(("Open SDIO%d", Instance));
return pDevice;
}
NvOdmSdioHandle NvOdmSdioOpen(NvU32 Instance)
{
static NvOdmSdio *pDevice = NULL;
NvOdmServicesGpioHandle hGpioTemp = NULL;
NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[4];
const NvU32 *pOdmConfigs;
NvU32 NumOdmConfigs;
NvBool Status = NV_TRUE;
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_PeripheralClass,
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
NvOdmPeripheralSearch_Address,
};
NvOdmBoardInfo BoardInfo;
NvBool status = NV_FALSE;
searchVals[0] = NvOdmPeripheralClass_Other;
searchVals[1] = NvOdmIoModule_Sdio;
searchVals[2] = Instance;
NvOdmQueryPinMux(NvOdmIoModule_Sdio, &pOdmConfigs, &NumOdmConfigs);
if ((Instance == 0) && (pOdmConfigs[0] == NvOdmSdioPinMap_Config1))
{
// sdio is connected to sdio2 slot.
searchVals[3] = NvOdmSdioDiscoveryAddress_1;
}
else
{
// sdio is connected to wifi module.
searchVals[3] = NvOdmSdioDiscoveryAddress_0;
}
NumOfGuids = NvOdmPeripheralEnumerate(searchAttrs,
searchVals,
4,
&guid,
NumOfGuids);
// Get the peripheral connectivity information
pConnectivity = (NvOdmPeripheralConnectivity *)NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
return NULL;
pDevice = NvOdmOsAlloc(sizeof(NvOdmSdio));
if(pDevice == NULL)
return (pDevice);
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (NULL);
}
if (pConnectivity->Guid == WLAN_GUID)
{
// WARNING: This function *cannot* be called before RmOpen().
status = NvOdmPeripheralGetBoardInfo((BOARD_ID_E951), &BoardInfo);
if (NV_TRUE != status)
{
// whistler should have E951 Module, if it is not presnt return NULL Handle.
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmOsFree(pDevice);
pDevice = NULL;
NvOdmOsDebugPrintf(("No E951 Detected"));
return (pDevice);
}
}
pDevice->pConnectivity = pConnectivity;
NvOdmSetPowerOnSdio(pDevice, NV_TRUE);
if (pConnectivity->Guid == WLAN_GUID)
{
// Getting the OdmGpio Handle
hGpioTemp = NvOdmGpioOpen();
if (hGpioTemp == NULL)
{
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
// Search for the Vdd rail and set the proper volage to the rail.
if (pConnectivity->AddressList[1].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Power Pin
pDevice->hPwrPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[1].Instance,
pConnectivity->AddressList[1].Address);
}
if (pConnectivity->AddressList[2].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Reset Pin
pDevice->hResetPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[2].Instance,
pConnectivity->AddressList[2].Address);
}
// Setting the ON/OFF pin to output mode.
NvOdmGpioConfig(hGpioTemp, pDevice->hPwrPin, NvOdmGpioPinMode_Output);
NvOdmGpioConfig(hGpioTemp, pDevice->hResetPin, NvOdmGpioPinMode_Output);
// Setting the Output Pin to Low
NvOdmGpioSetState(hGpioTemp, pDevice->hPwrPin, 0x0);
NvOdmGpioSetState(hGpioTemp, pDevice->hResetPin, 0x0);
pDevice->hGpio = hGpioTemp;
Status = SdioOdmWlanSetPowerOn(pDevice, NV_TRUE);
if (Status != NV_TRUE)
{
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmGpioReleasePinHandle(pDevice->hGpio, pDevice->hPwrPin);
NvOdmGpioReleasePinHandle(pDevice->hGpio, pDevice->hResetPin);
NvOdmGpioClose(pDevice->hGpio);
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
}
pDevice->PoweredOn = NV_TRUE;
pDevice->Instance = Instance;
NV_DRIVER_TRACE(("Open SDIO%d", Instance));
return pDevice;
}
void mmc_rescan(struct work_struct *work)
{
struct mmc_host *host =
container_of(work, struct mmc_host, detect.work);
u32 ocr;
int err;
int extend_wakelock = 0;
#ifdef MMC_PATCH_2
unsigned int attached = 0;
#endif
NV_DRIVER_TRACE(("mmc_rescan\n"));
mmc_bus_get(host);
/* if there is a card registered, check whether it is still present */
if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)
{
host->bus_ops->detect(host);
}
/* If the card was removed the bus will be marked
* as dead - extend the wakelock so userspace
* can respond */
if (host->bus_dead)
{
extend_wakelock = 1;
}
NV_DRIVER_TRACE(("mmc_rescan extend_wakelock=%d\n",extend_wakelock));
mmc_bus_put(host);
mmc_bus_get(host);
/* if there still is a card present, stop here */
if (host->bus_ops != NULL) {
mmc_bus_put(host);
goto out;
}
/* detect a newly inserted card */
/*
* Only we can add a new handler, so it's safe to
* release the lock here.
*/
mmc_bus_put(host);
if (host->ops->get_cd && host->ops->get_cd(host) == 0)
goto out;
mmc_claim_host(host);
mmc_power_up(host);
mmc_go_idle(host);
mmc_send_if_cond(host, host->ocr_avail);
/*
* First we search for SDIO...
*/
err = mmc_send_io_op_cond(host, 0, &ocr);
if (!err) {
if (mmc_attach_sdio(host, ocr))
#ifdef MMC_PATCH_2
{
#endif
mmc_power_off(host);
#ifdef MMC_PATCH_2
} else {
attached = 1;
}
#endif
extend_wakelock = 1;
goto out;
}
NV_DRIVER_TRACE(("mmc_rescan 7\n"));
/*
* ...then normal SD...
*/
err = mmc_send_app_op_cond(host, 0, &ocr);
if (!err) {
if (mmc_attach_sd(host, ocr))
#ifdef MMC_PATCH_2
{
#endif
mmc_power_off(host);
#ifdef MMC_PATCH_2
} else {
attached = 1;
}
#endif
extend_wakelock = 1;
goto out;
}
/*
* ...and finally MMC.
*/
err = mmc_send_op_cond(host, 0, &ocr);
if (!err) {
if (mmc_attach_mmc(host, ocr))
#ifdef MMC_PATCH_2
{
#endif
mmc_power_off(host);
#ifdef MMC_PATCH_2
} else {
attached = 1;
}
#endif
extend_wakelock = 1;
goto out;
}
mmc_release_host(host);
mmc_power_off(host);
out:
NV_DRIVER_TRACE(("mmc_rescan out\n"));
if (extend_wakelock)
wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ / 2);
else
wake_unlock(&mmc_delayed_work_wake_lock);
if (host->caps & MMC_CAP_NEEDS_POLL)
queue_delayed_work(workqueue, &host->detect, HZ);
#ifdef MMC_PATCH_2
/* Create a one-shot timer work, work after 1 second */
if(!strcmp(mmc_hostname(host), "mmc1")) {
printk("Try to add timer for %s ---------------- \n", mmc_hostname(host));
if(timer_inited){
init_timer(&detect_timer);
detect_timer.data = (unsigned long)host;
detect_timer.function = sdhci_tegra_card_detect;
detect_timer.expires = jiffies + HZ;
add_timer(&detect_timer);
timer_inited = 1;
} else {
if(!timer_pending(&detect_timer)) {
return;
} else {
add_timer(&detect_timer);
}
}
}
#endif
}
NvOdmUsbUlpiHandle NvOdmUsbUlpiOpen(NvU32 Instance)
{
NvOdmUsbUlpi*pDevice = NULL;
NvU32 ClockInstances[MAX_CLOCKS];
NvU32 ClockFrequencies[MAX_CLOCKS];
NvU32 NumClocks;
#if defined(CONFIG_TEGRA_ODM_BETELGEUSE)
/* paul */
NvOdmInterruptHandler IntrHandler = (NvOdmInterruptHandler)UsbCurLimitGpioInterruptHandler;
/* end */
#endif
pDevice = NvOdmOsAlloc(sizeof(NvOdmUsbUlpi));
if(pDevice == NULL)
return NULL;
if(!NvOdmExternalClockConfig(SMSC3317GUID, NV_FALSE, ClockInstances,
ClockFrequencies, &NumClocks))
{
NV_DRIVER_TRACE (("ERROR NvOdmUsbUlpiOpen: "
"NvOdmExternalClockConfig fail\n"));
goto ExitUlpiOdm;
}
NvOdmOsSleepMS(10);
if (!s_hGpio)
s_hGpio = NvOdmGpioOpen();
if (!s_hGpio)
{
NV_DRIVER_TRACE (("ERROR NvOdmUsbUlpiOpen: "
"Not able to open gpio handle\n"));
goto ExitUlpiOdm;
}
if (!s_hResetPin)
s_hResetPin = NvOdmGpioAcquirePinHandle(s_hGpio, ULPI_RESET_PORT,
ULPI_RESET_PIN);
if (!s_hResetPin)
{
NvOdmGpioClose(s_hGpio);
s_hGpio = NULL;
NV_DRIVER_TRACE (("ERROR NvOdmGpioAcquirePinHandle: "
"Not able to Acq pinhandle\n"));
goto ExitUlpiOdm;
}
#if defined(CONFIG_TEGRA_ODM_BETELGEUSE)
if (!s_hOvrrCurPin)
s_hOvrrCurPin = NvOdmGpioAcquirePinHandle(s_hGpio, ULPI_OVRCURR_PORT,
ULPI_OVRCURR_PIN);
if (!s_hOvrrCurPin)
{
NvOdmGpioClose(s_hGpio);
s_hGpio = NULL;
NV_DRIVER_TRACE (("ERROR NvOdmGpioAcquirePinHandle: "
"Not able to Acq pinhandle\n"));
goto ExitUlpiOdm;
}
NvOdmGpioConfig(s_hGpio,s_hOvrrCurPin, NvOdmGpioPinMode_InputData);
#endif
// Pull high on RESETB ( 22nd pin of smsc3315)
// config as out put pin
NvOdmGpioConfig(s_hGpio,s_hResetPin, NvOdmGpioPinMode_Output);
// Set low to write high on ULPI_RESETB pin
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x01);
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x0);
NvOdmOsSleepMS(5);
NvOdmGpioSetState(s_hGpio, s_hResetPin, 0x01);
#if defined(BUG_CONFIG_TEGRA_ODM_BETELGEUSE)
/* paul merge smith begin */
/* create mutex for usb over current detect */
NvOsMutexCreate(&usbCurrLimit_lock);
#if 0
/* create /proc/usbCurrLimitInfo for user space read */ /* S_IRUGO */
create_proc_read_entry("usbCurrLimitInfo", S_IRWXUGO, NULL, tegra_usbCurrLimit_read_proc, NULL);
#else
procfile_init();
#endif
/* register interrupt handler for GPIO_PU3 status */
if (NvOdmGpioInterruptRegister(s_hGpio, &IntrHandle,
s_hOvrrCurPin, NvOdmGpioPinMode_InputInterruptLow,
IntrHandler, (void *)NULL, 0) == NV_FALSE)
{
NV_DRIVER_TRACE (("ERROR NvOdmGpioInterruptRegister: "
"Not able to register intr hdlr for s_hCurLimitPin\n"));
}
/* paul merge smith end */
#endif
pDevice->CurrentGUID = SMSC3317GUID;
return pDevice;
ExitUlpiOdm:
NvOdmOsFree(pDevice);
return NULL;
}
