/**
* @brief Stops the Vibro motor
* @param hOdmVibrate [IN] Opaque handle to the device.
* @return NV_TRUE on success and NV_FALSE on error
*/
NvBool
NvOdmVibStop(NvOdmVibDeviceHandle hOdmVibrate)
{
NvU32 SettlingTime;
NV_ASSERT(hOdmVibrate);
if (!hOdmVibrate)
{
return NV_FALSE;
}
#if (defined(CONFIG_7546Y_V10))
NvOdmGpioSetState(hOdmVibrate->vibrate_gpio, hOdmVibrate->vibrate_pin, 0); //Hzj added
NvOdmGpioSetState(hOdmVibrate->vibrate_segpio, hOdmVibrate->vibrate_sepin, 0); //Hzj added
#else
if (hOdmVibrate->hOdmServicePmuDevice != NULL)
{
// Search for the Vdd rail and power Off the module
if (hOdmVibrate->VddId)
{
NvOdmServicesPmuSetVoltage(hOdmVibrate->hOdmServicePmuDevice,
hOdmVibrate->VddId, NVODM_VOLTAGE_OFF, &SettlingTime);
if (SettlingTime)
NvOdmOsWaitUS(SettlingTime);
}
}
#endif
return NV_TRUE;
}
static NvBool SdioOdmWlanPower(NvOdmSdioHandle hOdmSdio, NvBool IsEnable)
{
NvU32 RequestedPeriod, ReturnedPeriod;
NvOdmServicesPwmHandle hOdmPwm = NULL;
if (IsEnable)
{
// Wlan Power On Reset Sequence
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x0);
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hResetPin, 0x0);
NvOdmOsSleepMS(200);
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x1);
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hResetPin, 0x1);
NvOdmOsSleepMS(200);
// Enable 32KHz clock out
hOdmPwm = NvOdmPwmOpen();
if (!hOdmPwm)
{
NvOsDebugPrintf("sdio_odm: NvOdmPwmOpen failed\n");
return NV_FALSE;
}
RequestedPeriod = 0;
NvOdmPwmConfig(hOdmPwm, NvOdmPwmOutputId_Blink,
NvOdmPwmMode_Blink_32KHzClockOutput,
0, &RequestedPeriod, &ReturnedPeriod);
NvOdmPwmClose(hOdmPwm);
}
else
{
// Power Off sequence
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x0);
}
return NV_TRUE;
}
static NvBool EETI_Resume(NvOdmTouchDeviceHandle hDevice) {
EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice;
if (hDevice == NULL) {
return NV_FALSE;
}
#if 0
NvOdmGpioInterruptMask(hTouch->hGpioIntr, NV_TRUE);
NvOdmGpioInterruptUnregister(hTouch->hGpio, hTouch->hPin, hTouch->hGpioIntr);
#endif
NvOdmGpioConfig(hTouch->hGpio, hTouch->hPin, NvOdmGpioPinMode_Output);
/* Send reset pulse to touch HW */
NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 1);
NvOsWaitUS(50);
NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 0);
NvOsSleepMS(50);
NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 1);
NvOdmGpioConfig(hTouch->hGpio, hTouch->hPin, NvOdmGpioPinMode_InputInterruptLow);
#if 0
if (NvOdmGpioInterruptRegister(hTouch->hGpio, &hTouch->hGpioIntr,
hTouch->hPin, NvOdmGpioPinMode_InputInterruptLow, EETI_GpioIsr,
(void*)hTouch, EETI_DEBOUNCE_TIME_MS) == NV_FALSE) {
return NV_FALSE;
}
#endif
return NV_TRUE;
}
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;
}
int mdm_reset(void)
{
unsigned int pin_val = 0;
NvOdmServicesGpioHandle h_gpio;
NvOdmGpioPinHandle h_gpiopin;
NvOdmGpioPinHandle h_uart1_rtspin;
printk("%s \n", __func__);
h_gpio = NvOdmGpioOpen();
if (!h_gpio)
{
printk("%s: NvOdmGpioOpen Error\n", __func__);
goto error_open_gpio_fail;
}
h_gpiopin = NvOdmGpioAcquirePinHandle(h_gpio, 'v' - 'a', 0);
if (!h_gpiopin)
{
printk("%s: Couldn't NvOdmGpioAcquirePinHandle pin\n", __func__);
goto error_open_gpio_pin_acquire_fail;
}
h_uart1_rtspin = NvOdmGpioAcquirePinHandle(h_gpio, 'o' - 'a', 3);
if (!h_uart1_rtspin)
{
printk("%s: Couldn't NvOdmGpioAcquirePinHandle pin\n", __func__);
goto error_open_gpio_pin_acquire_fail;
}
NvOdmGpioSetState( h_gpio, h_uart1_rtspin, 0x1);
NvOdmGpioConfig( h_gpio, h_uart1_rtspin, NvOdmGpioPinMode_Output);
NvOdmGpioGetState( h_gpio, h_uart1_rtspin, &pin_val);
printk("ifx_reset_high - [CP RTS]: pin %d\n", pin_val);
//reset Communication Processor (GPIO_PV0: high -> 1000ms -> low -> 3000ms -> high)
NvOdmGpioSetState( h_gpio, h_gpiopin, 0x1);
NvOdmGpioConfig( h_gpio, h_gpiopin, NvOdmGpioPinMode_Output);
msleep(1000);
NvOdmGpioSetState( h_gpio, h_gpiopin, 0x0);
msleep(3000);
NvOdmGpioSetState( h_gpio, h_gpiopin, 0x1);
NvOdmGpioGetState( h_gpio, h_gpiopin, &pin_val);
printk("ifx_reset_high - [CP RESET]: pin %d\n", pin_val);
NvOdmGpioReleasePinHandle(h_gpio, h_uart1_rtspin);
NvOdmGpioReleasePinHandle(h_gpio, h_gpiopin);
NvOdmGpioClose(h_gpio);
return 0;
error_open_gpio_pin_acquire_fail:
NvOdmGpioClose(h_gpio);
error_open_gpio_fail:
return -ENOSYS;
}
//101106, [email protected], FOTA update [START] int fota_ebl_download(void) { static NvOdmServicesGpioHandle hCprom = NULL; static NvOdmGpioPinHandle hIFX_Reset = NULL; int ret; if(hCprom == NULL) { hCprom = NvOdmGpioOpen(); if (!hCprom) { lprintk(D_MUIC, "%s: NvOdmGpioOpen Error \n", __func__); goto error_open_gpio_fail; } } if(hIFX_Reset == NULL) { hIFX_Reset = NvOdmGpioAcquirePinHandle(hCprom, 'v' - 'a', 0); if (!hIFX_Reset) { lprintk(D_MUIC, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto error_open_gpio_pin_acquire_fail; } } NvOdmGpioConfig(hCprom, hIFX_Reset, NvOdmGpioPinMode_Output); #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_USB_VBUS_EN, DISABLE); #endif NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_AP20_UART_SW, 0x0); NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_IFX_UART_SW, 0x0); //change USB path from AP to CP //Set_MAX14526_CP_USB_Mode(); NvOdmOsSleepMS(5000); //change TEST_GPIO state from low to high (GPIO_PV0) NvOdmGpioSetState(hCprom, hIFX_Reset, 0); NvOdmGpioGetState(hCprom, hIFX_Reset, &ret); lprintk(D_MUIC, "%s: hIFX_Reset is %d \n", __func__, ret); NvOdmOsSleepMS(10); NvOdmGpioSetState(hCprom, hIFX_Reset, 1); NvOdmGpioGetState(hCprom, hIFX_Reset, &ret); lprintk(D_MUIC, "%s: hIFX_Reset is %d \n", __func__, ret); return 0; error_open_gpio_pin_acquire_fail: NvOdmGpioClose(hCprom); error_open_gpio_fail: return -ENOSYS; }
int mdm_rts_low(void)
{
unsigned int pin_val = 0;
NvOdmServicesGpioHandle h_gpio;
NvOdmGpioPinHandle h_uart1_rtspin;
printk("%s \n", __func__);
h_gpio = NvOdmGpioOpen();
if (!h_gpio)
{
printk("%s: NvOdmGpioOpen Error\n", __func__);
goto error_open_gpio_fail;
}
h_uart1_rtspin = NvOdmGpioAcquirePinHandle(h_gpio, 'o' - 'a', 3);
if (!h_uart1_rtspin)
{
printk("%s: Couldn't NvOdmGpioAcquirePinHandle pin\n", __func__);
goto error_open_gpio_pin_acquire_fail;
}
NvOdmGpioSetState( h_gpio, h_uart1_rtspin, 0x1);
NvOdmGpioConfig( h_gpio, h_uart1_rtspin, NvOdmGpioPinMode_Output);
NvOdmGpioGetState( h_gpio, h_uart1_rtspin, &pin_val);
printk("ifx_reset_high - [CP RTS]: pin %d\n", pin_val);
NvOdmGpioReleasePinHandle(h_gpio, h_uart1_rtspin);
NvOdmGpioClose(h_gpio);
return 0;
error_open_gpio_pin_acquire_fail:
NvOdmGpioClose(h_gpio);
error_open_gpio_fail:
return -ENOSYS;
}
int powerkey_resume(struct platform_device *dev)
{
NvU32 pinValue;
unsigned long reg;
#ifdef AP_SUSPEND_STATUS
NvOdmGpioSetState(s_modemCheck.gpioHandle, s_modemCheck.pinHandle, 1);
#endif
reg = readl(pmc_base + PMC_WAKE_STATUS);
if (key_wakeup_ISR == 0)
{
if (reg & WAKEUP_POWERKEY_MASK) {
//clear wakeuppad status
writel(WAKEUP_POWERKEY_MASK, pmc_base + PMC_WAKE_STATUS);
printk("[PWR_KEY] resume func POWERKEY press\n");
input_report_key(s_powerkey.inputDev, KEY_POWER, 1);
input_sync(s_powerkey.inputDev);
NvOdmGpioGetState(s_powerkey.gpioHandle, s_powerkey.pinHandle, &pinValue);
if(pinValue){
printk("[PWR_KEY] resume func POWERKEY release\n");
input_report_key(s_powerkey.inputDev, KEY_POWER, 0);
input_sync(s_powerkey.inputDev);
}
}
key_wakeup_ISR = 1;
}
return 0;
}
static ssize_t als_control_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
NvBool status = NV_FALSE;
int cmd =0, arg=0;
printk(KERN_ERR "als_control_store\n");
sscanf(buf, "%d %d", &cmd, &arg);
switch(cmd)
{
case ALS_PWDOWN:
status = s_hALSHandle.CMDWrite(&s_hALSHandle, CMD_ALS_PWDOWN);
break;
case ALS_PWON:
status = s_hALSHandle.CMDWrite(&s_hALSHandle, CMD_ALS_PWON);
break;
case ALS_RESEPIN_ACTIVE_LOW:
NvOdmGpioSetState(s_hALSHandle.hGpio, s_hALSHandle.s_hResetALSGpioPin, NvRmGpioPinState_Low);
status = NV_TRUE;
break;
case ALS_RESEPIN_DEACTIVE_HIGH:
NvOdmGpioSetState(s_hALSHandle.hGpio, s_hALSHandle.s_hResetALSGpioPin, NvRmGpioPinState_High);
status = NV_TRUE;
break;
case ALS_AUTO_RES_MODE:
status = s_hALSHandle.CMDWrite(&s_hALSHandle, CMD_ALS_AUTO_RES_MODE);
break;
case ALS_HIGH_RES_MODE:
status = s_hALSHandle.CMDWrite(&s_hALSHandle, CMD_ALS_HIGH_RES_MODE);
break;
case ALS_LOW_RES_MODE:
status = s_hALSHandle.CMDWrite(&s_hALSHandle, ALS_LOW_RES_MODE);
break;
case ALS_LUX_UPDATA:
// s_hALSHandle.LUXRead(&s_hALSHandle, &s_lux);
break;
default:
break;
}
printk(KERN_ERR "get cmd = %d\n",cmd);
if (status == NV_FALSE)
printk(KERN_ERR "als_control_store error\n");
return size;
}
void USIF_ctrl(USIF_MODE_TYPE mode)
{
if(mode == USIF_UART)
{
NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_USIF1_SW, 0x1);
lprintk(D_MUIC, "%s: USIF Switch is USIF_UART\n", __func__);
}
else if(mode == USIF_IPC)
{
NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_USIF1_SW, 0x0);
lprintk(D_MUIC, "%s: USIF Switch is USIF_IPC\n", __func__);
}
else
{
lprintk(D_MUIC, "%s: USIF Switch is USIF_NONE\n", __func__);
}
}
NvBool NvOdmVibStop(NvOdmVibDeviceHandle hDevice)
{
NvOdmGpioSetState(ghGpio, ghVibGpioPin, 0x0);
NvOdmGpioConfig(ghGpio, ghVibGpioPin, NvOdmGpioPinMode_Output);
VIBE_TPS658620_I2cWrite8(TPS658620_PWM1_ADDR, 0x00);
return NV_TRUE;
}
static int gps_control_enable(struct gps_control_dev *dev, bool enable)
{
if (dev->enable == enable) {
return 0;;
}
dev->enable = enable;
NvOdmGpioSetState(dev->gpio_handle, dev->pin_handle, enable);
return 0;
}
static NvBool SdioOdmWlanSetPowerOn(NvOdmSdioHandle hOdmSdio, NvBool IsEnable)
{
if (IsEnable)
{
// Wlan Power On Reset Sequence
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x0); //PWD -> Low
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hResetPin, 0x0); //RST -> Low
NvOdmOsWaitUS(2000);
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x1); //PWD -> High
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hResetPin, 0x1); //RST -> High
}
else
{
// Power Off sequence
NvOdmGpioSetState(hOdmSdio->hGpio, hOdmSdio->hPwrPin, 0x0); //PWD -> Low
}
return NV_TRUE;
}
//20100111 vib disable on reboot 2nd [START]
void vib_enable_reboot( NvBool on )
{
if ( vib_set_power_rail( g_vib->vdd_id, on ) != 0 ) {
printk( "[ImmVibeSPI][%s] : Failed to vib_set_power_rail\n", __func__ );
}
NvOdmGpioConfig( g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin, NvOdmGpioPinMode_Output );
NvOdmGpioSetState( g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin, on );
}
NvOdmUsbUlpiHandle NvOdmUsbUlpiOpen(NvU32 Instance)
{
NvOdmUsbUlpi *pDevice = NULL;
NvU32 ClockInstances[MAX_CLOCKS];
NvU32 ClockFrequencies[MAX_CLOCKS];
NvU32 NumClocks;
NvOdmServicesGpioHandle hGpio;
NvOdmGpioPinHandle hResetPin;
NvU32 Port = NVODM_PORT('v');
NvU32 Pin = 1;
pDevice = NvOdmOsAlloc(sizeof(NvOdmUsbUlpi));
if (pDevice == NULL)
return NULL;
if(!NvOdmExternalClockConfig(SMSC3317GUID, NV_FALSE,
ClockInstances, ClockFrequencies, &NumClocks))
{
NvOdmOsDebugPrintf("NvOdmUsbUlpiOpen: NvOdmExternalClockConfig fail\n");
goto ExitUlpiOdm;
}
NvOdmOsSleepMS(10);
// Pull high on RESETB ( 22nd pin of smsc3315)
hGpio = NvOdmGpioOpen();
hResetPin = NvOdmGpioAcquirePinHandle(hGpio, Port, Pin);
// config as out put pin
NvOdmGpioConfig(hGpio,hResetPin, NvOdmGpioPinMode_Output);
// Set low to write high on ULPI_RESETB pin
NvOdmGpioSetState(hGpio, hResetPin, 0x01);
NvOdmGpioSetState(hGpio, hResetPin, 0x0);
NvOdmOsSleepMS(5);
NvOdmGpioSetState(hGpio, hResetPin, 0x01);
pDevice->CurrentGUID = SMSC3317GUID;
return pDevice;
ExitUlpiOdm:
NvOdmOsFree(pDevice);
return NULL;
}
void ms3c_ControlStatus(int status)
{
if( !s_hGpio )
s_hGpio = NvOdmGpioOpen();
if( s_hGpio )
{
//GPIO_PX1
if( !s_hResetGpioPin )
s_hResetGpioPin = NvOdmGpioAcquirePinHandle(s_hGpio,'x'-'a',1);
if( s_hResetGpioPin )
{
//active reset
if( status == STATUS_ACTIVE)
{
printk("==============>Msensor_ACTIVE\r\n");
NvOdmGpioSetState(s_hGpio, s_hResetGpioPin, 0x1);
NvOdmGpioConfig( s_hGpio, s_hResetGpioPin, NvOdmGpioPinMode_Output);
}
else if( status == STATUS_RESET) // reset
{
NvOdmGpioSetState(s_hGpio, s_hResetGpioPin, 0x0);
NvOdmGpioConfig( s_hGpio, s_hResetGpioPin, NvOdmGpioPinMode_Output);
}
else
{
printk("==============>Msensor_SUSPEND\r\n");
NvOdmGpioSetState(s_hGpio, s_hResetGpioPin, 0x0);
NvOdmGpioConfig(s_hGpio, s_hResetGpioPin, NvOdmGpioPinMode_Tristate);
}
}
}
}
void ifx_reset_high(void)
{
unsigned int pin_val = 0;
NvOdmServicesGpioHandle h_gpio;
NvOdmGpioPinHandle h_gpiopin;
printk("%s HIGH\n", __func__);
h_gpio = NvOdmGpioOpen();
h_gpiopin = NvOdmGpioAcquirePinHandle(h_gpio, 'v' - 'a', 0);
NvOdmGpioConfig( h_gpio, h_gpiopin, NvOdmGpioPinMode_Output);
NvOdmGpioSetState( h_gpio, h_gpiopin, 0x1);
NvOdmGpioGetState( h_gpio, h_gpiopin, &pin_val);
printk("ifx_reset_high - [CP RESET]: pin %d\n", pin_val);
NvOdmGpioReleasePinHandle(h_gpio, h_gpiopin);
NvOdmGpioClose(h_gpio);
}
void ifx_power_low(void)
{
unsigned int pin_val = 0;
NvOdmServicesGpioHandle h_gpio;
NvOdmGpioPinHandle h_gpiopin;
printk("%s LOW\n", __func__);
h_gpio = NvOdmGpioOpen();
h_gpiopin = NvOdmGpioAcquirePinHandle(h_gpio, 'v' - 'a', 1);
NvOdmGpioConfig( h_gpio, h_gpiopin, NvOdmGpioPinMode_Output);
NvOdmGpioSetState( h_gpio, h_gpiopin, 0x0);
NvOdmGpioGetState( h_gpio, h_gpiopin, &pin_val);
printk("ifx_power_low - [CP POWER]: pin %d\n", pin_val);
NvOdmGpioReleasePinHandle(h_gpio, h_gpiopin);
NvOdmGpioClose(h_gpio);
}
void NvOdmUsbUlpiClose(NvOdmUsbUlpiHandle hOdmUlpi)
{
if (hOdmUlpi->hResetPin)
{
NvOdmGpioSetState(hOdmUlpi->hGpio, hOdmUlpi->hResetPin, 0x0);
NvOdmGpioReleasePinHandle(hOdmUlpi->hGpio, hOdmUlpi->hResetPin);
hOdmUlpi->hResetPin = NULL;
}
if (hOdmUlpi->hGpio)
{
NvOdmGpioClose(hOdmUlpi->hGpio);
hOdmUlpi->hGpio = NULL;
}
if (hOdmUlpi)
{
NvOdmOsFree(hOdmUlpi);
}
}
NvBool NvOdmVibStart(NvOdmVibDeviceHandle hDevice)
{
NvOdmPeripheralConnectivity const *conn;
NvU64 guid;
/* get the main panel */
guid = VIBRATOR_GUID;
/* get the connectivity info */
conn = NvOdmPeripheralGetGuid(guid);
if(conn == NULL)
{
return NV_FALSE;
}
/* acquire GPIO pins */
ghGpio = NvOdmGpioOpen();
if (ghGpio == NULL)
{
return NV_FALSE;
}
if (ghVibGpioPin == NULL)
{
/* Search for the GPIO pin */
if (conn->AddressList[0].Interface == NvOdmIoModule_Gpio)
{
ghVibGpioPin = NvOdmGpioAcquirePinHandle(ghGpio,
conn->AddressList[0].Instance,
conn->AddressList[0].Address);
}
}
if (ghVibGpioPin == NULL)
{
return NV_FALSE;
}
NvOdmGpioSetState(ghGpio, ghVibGpioPin, 0x1);
NvOdmGpioConfig(ghGpio, ghVibGpioPin, NvOdmGpioPinMode_Output);
VIBE_TPS658620_I2cWrite8(TPS658620_PWM1_ADDR, hDevice->CurrentIndex);
return NV_TRUE;
}
int powerkey_suspend(struct platform_device *dev, pm_message_t state)
{
unsigned long reg;
reg = readl(pmc_base + PMC_WAKE_STATUS);
// Clear power key wakeup pad bit.
if (reg & WAKEUP_POWERKEY_MASK)
{
writel(WAKEUP_POWERKEY_MASK, pmc_base + PMC_WAKE_STATUS);
}
#ifdef AP_SUSPEND_STATUS
NvOdmGpioSetState(s_modemCheck.gpioHandle, s_modemCheck.pinHandle, 0);
#endif
key_wakeup_ISR = 0;
return 0;
}
void muic_initialize_max(TYPE_RESET reset)
{
#if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F)
NvOdmGpioSetState(s_hMuicHandle.hGpio, s_hMuicHandle.h_USB_VBUS_EN, DISABLE);
#endif
// Enable 200K, ADC (0x01=0x12)
Set_MAX14526_ADDR(CTRL1_REG, ID_200_M| ADC_EN_M);
// Enable Interrupts (0x02 = 0x40)
Set_MAX14526_ADDR(CTRL2_REG, INT_EN_M);
//20100526, [email protected], Charging IC Reset [START]
#if defined(CONFIG_STAR_BATTERY_CHARGER)
if ( !reset )
{
lprintk(D_MUIC, "%s: charging_ic_deactive call \n", __func__ );
charging_ic_deactive();
}
#endif /* CONFIG_STAR_BATTERY_CHARGER */
//20100526, [email protected], Charging IC Reset [END]
wake_unlock(&s_hMuicHandle.wlock);
}
static int cpcap_usb_connected_remove(struct platform_device *pdev)
{
struct cpcap_usb_connected_data *data = platform_get_drvdata(pdev);
mdm_ctrl_set_usb_ipc(false);
/* Configure CPCAP-AP20 USB Mux to CPCAP */
NvOdmGpioSetState(data->h_gpio, data->h_pin, 0x0);
NvOdmGpioReleasePinHandle(data->h_gpio, data->h_pin);
NvOdmGpioClose(data->h_gpio);
if((data->accy == CPCAP_ACCY_USB) || (data->accy == CPCAP_ACCY_FACTORY))
android_usb_set_connected(0, data->accy);
#ifdef CONFIG_USB_TEGRA_OTG
tegra_otg_set_mode(2);
#endif
kfree(data);
return 0;
}
static int cpcap_usb_connected_remove(struct platform_device *pdev)
{
/* struct cpcap_usb_connected_data *data = platform_get_drvdata(pdev);*/
struct cpcap_accy_platform_data *pdata = pdev->dev.platform_data;
int nr_gpio;
#ifdef CONFIG_MDM_CTRL
mdm_ctrl_set_usb_ipc(false);
#endif
#if 0
/* Configure CPCAP-AP20 USB Mux to CPCAP */
NvOdmGpioSetState(data->h_gpio, data->h_pin, 0x0);
printk(KERN_INFO "pICS_%s: NvOdmGpioSetState (data->h_gpio, data->h_pin, 0x0)\n",__func__);
NvOdmGpioReleasePinHandle(data->h_gpio, data->h_pin);
printk(KERN_INFO "pICS_%s: NvOdmGpioReleasePinHandle(data->h_gpio, data->h_pin)\n",__func__);
NvOdmGpioClose(data->h_gpio);
printk(KERN_INFO "pICS_%s: NvOdmGpioClose(data->h_gpio)\n",__func__);
#endif
nr_gpio = 174;
gpio_set_value(nr_gpio, 0);
gpio_free(nr_gpio);
/* gpio_data[nr_gpio].val = false;
gpio_data[nr_gpio].alloc = false;*/
tegra_gpio_disable(nr_gpio);
#ifdef CONFIG_USB_MOT_ANDROID
if((pdata->accy == CPCAP_ACCY_USB) || (pdata->accy == CPCAP_ACCY_FACTORY))
android_usb_set_connected(0, pdata->accy);
#endif
tegra_otg_set_mode(2);
/* kfree(data);*/
return 0;
}
static void star_vib_work_func(struct work_struct *work)
{
u32 gpio_state = 0;
#if VIB_DEBUG
printk("vibrator test... value = %d\n", toggle);
#endif
NvOdmGpioConfig( g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin, NvOdmGpioPinMode_Output);
NvOdmGpioSetState( g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin, toggle );
if( toggle == 0 )
toggle++;
else
toggle = 0;
NvOdmGpioGetState(g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin, &gpio_state);
#if VIB_DEBUG
printk("[skhwang] VIB_EN = %d\n", gpio_state);
#endif
NvOdmOsSleepMS(1000);
schedule_delayed_work(&g_vib->delayed_work_vib,150);
}
static int cpcap_usb_connected_probe(struct platform_device *pdev)
{
struct cpcap_usb_connected_data *data;
struct cpcap_accy_platform_data *pdata = pdev->dev.platform_data;
data = kzalloc(sizeof(*data), GFP_KERNEL);
if(!data)
return -ENOMEM;
data->accy = pdata->accy;
/* Configure CPCAP-AP20 USB Mux to AP20 */
data->port = NVODM_PORT('v');
data->pin = 6;
data->h_gpio = NvOdmGpioOpen();
data->h_pin = NvOdmGpioAcquirePinHandle(data->h_gpio, data->port, data->pin);
NvOdmGpioConfig(data->h_gpio, data->h_pin, NvOdmGpioPinMode_Output);
NvOdmGpioSetState(data->h_gpio, data->h_pin, 0x1);
platform_set_drvdata(pdev, data);
/* when the phone is the host do not start the gadget driver */
if((data->accy == CPCAP_ACCY_USB) || (data->accy == CPCAP_ACCY_FACTORY)) {
#ifdef CONFIG_USB_TEGRA_OTG
tegra_otg_set_mode(0);
#endif
android_usb_set_connected(1, data->accy);
}
if(data->accy == CPCAP_ACCY_USB_DEVICE) {
#ifdef CONFIG_USB_TEGRA_OTG
tegra_otg_set_mode(1);
#endif
}
mdm_ctrl_set_usb_ipc(true);
return 0;
}
static int __init powerkey_probe(struct platform_device *pdev)
{
int ret;
NvU32 pin, port;
const NvOdmPeripheralConnectivity *con = NULL;
//20101129, [email protected], idle current issue [START]
//GPIO configuration
s_touchMaker.gpioHandle = NvOdmGpioOpen();
port = 'x'-'a';
pin = 5;
s_touchMaker.pinHandle = NvOdmGpioAcquirePinHandle(s_touchMaker.gpioHandle,
port, pin);
NvOdmGpioConfig(s_touchMaker.gpioHandle, s_touchMaker.pinHandle,
NvOdmGpioPinMode_InputData);
//20101129, [email protected], idle current issue [END]
//20100610, [email protected], sleep status gpio for modem [START]
#ifdef AP_SUSPEND_STATUS
//GPIO configuration
s_modemCheck.gpioHandle = NvOdmGpioOpen();
if (!s_modemCheck.gpioHandle)
{
printk(KERN_ERR "[star modem_chk] NvOdmGpioOpen Error \n");
goto err_open_modem_chk_gpio_fail;
}
port = 'r'-'a';
pin = 0;
s_modemCheck.pinHandle = NvOdmGpioAcquirePinHandle(s_modemCheck.gpioHandle,
port, pin);
if (!s_modemCheck.pinHandle)
{
printk(KERN_ERR "[star modem_chk] NvOdmGpioAcquirePinHandle Error\n");
goto err_modem_chk_gpio_pin_acquire_fail;
}
NvOdmGpioSetState(s_modemCheck.gpioHandle, s_modemCheck.pinHandle, 1);
NvOdmGpioConfig(s_modemCheck.gpioHandle, s_modemCheck.pinHandle,
NvOdmGpioPinMode_Output);
#endif
//20100610, [email protected], sleep status gpio for modem [END]
memset(&s_powerkey, 0x00, sizeof(s_powerkey));
//get query
con = NvOdmPeripheralGetGuid(NV_ODM_GUID('p','o','w','e','r','k','e','y'));
if(!con){
printk(KERN_ERR "[star powerkey] ODM GUID Error \n");
goto err_probe_fail;
}
if ( con->AddressList[0].Interface == NvOdmIoModule_Gpio){
port = con->AddressList[0].Instance;
pin = con->AddressList[0].Address;
}else{
printk(KERN_ERR "[star powerkey] cannot find ODM GUID \n");
goto err_probe_fail;
}
#ifdef POWERKEY_DELAYED_WORKQUEUE
INIT_DELAYED_WORK(&s_powerkey.work, powerkey_handle);
wake_lock_init(&s_powerkey.wlock, WAKE_LOCK_SUSPEND, "powerkey_delay");
#else
INIT_WORK(&s_powerkey.work, powerkey_handle);
#endif
//GPIO configuration
s_powerkey.gpioHandle = NvOdmGpioOpen();
if (!s_powerkey.gpioHandle)
{
printk(KERN_ERR "[star powerkey] NvOdmGpioOpen Error \n");
goto err_open_gpio_fail;
}
s_powerkey.pinHandle = NvOdmGpioAcquirePinHandle(s_powerkey.gpioHandle,
port, pin);
if (!s_powerkey.pinHandle)
{
printk(KERN_ERR "[star powerkey] NvOdmGpioAcquirePinHandle Error\n");
goto err_gpio_pin_acquire_fail;
}
//NvOdmGpioSetState(s_powerkey.gpioHandle, s_powerkey.pinHandle, 0);
NvOdmGpioConfig(s_powerkey.gpioHandle, s_powerkey.pinHandle,
NvOdmGpioPinMode_InputData);
//GPIO interrupt registration
if (NvOdmGpioInterruptRegister(s_powerkey.gpioHandle, &s_powerkey.intHandle,
s_powerkey.pinHandle, NvOdmGpioPinMode_InputInterruptAny,
powerkey_interrupt_handler, (void*)&s_powerkey, 0) == NV_FALSE)
{
printk(KERN_ERR "[star Powerkey] interrupt registeration fail!\n");
goto err_interrupt_register_fail;
}
// input device
s_powerkey.inputDev = input_allocate_device();
if (!s_powerkey.inputDev) {
printk(KERN_ERR "[star Powerkey] input_allocate_device Error!\n");
goto err_input_device_allocation_fail;
}
s_powerkey.inputDev->name = "powerkey";
//s_powerkey.inputDev->id.bustype = BUS_HOST;
s_powerkey.inputDev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR);
set_bit(KEY_POWER, s_powerkey.inputDev->keybit);
ret = input_register_device(s_powerkey.inputDev);
if (ret) {
printk(KERN_ERR "[star powerkey] input_register_device Error\n");
goto err_input_device_register_fail;
}
//20100703, [email protected], PMIC reset [START]
ret = sysfs_create_group(&pdev->dev.kobj, &star_pmic_group);
if (ret) {
printk(KERN_ERR "[star powerkey] sysfs_create_group ERROR\n");
goto err_pmic_sysfs_fail;
}
//20100703, [email protected], PMIC reset [END]
ret = sysfs_create_group(&pdev->dev.kobj, &star_hwsku_group);
if (ret) {
printk(KERN_ERR "[star powerkey] sysfs_create_group ERROR\n");
goto err_hwsku_sysfs_fail;
}
//20101110, [email protected], Function for Warm-boot [START]
ret = sysfs_create_group(&pdev->dev.kobj, &star_reset_group);
if (ret) {
printk(KERN_ERR "[star powerkey] sysfs_create_group ERROR\n");
goto err_reset_sysfs_fail;
}
//20101110, [email protected], Function for Warm-boot [END]
// 20110209 [email protected] disable gpio interrupt during power-off [START]
ret = sysfs_create_group(&pdev->dev.kobj, &star_poweroff_group);
if (ret) {
printk(KERN_ERR "[star powerkey] sysfs_create_group <star_poweroff_group> ERROR\n");
goto err_input_device_register_fail;
}
// 20110209 [email protected] disable gpio interrupt during power-off [END]
return 0;
err_reset_sysfs_fail:
sysfs_remove_group(&pdev->dev.kobj, &star_hwsku_group);
err_hwsku_sysfs_fail:
sysfs_remove_group(&pdev->dev.kobj, &star_pmic_group);
err_pmic_sysfs_fail:
input_unregister_device(s_powerkey.inputDev);
err_input_device_register_fail:
input_free_device(s_powerkey.inputDev);
err_input_device_allocation_fail:
NvOdmGpioInterruptUnregister(s_powerkey.gpioHandle, s_powerkey.pinHandle,
s_powerkey.intHandle);
err_interrupt_register_fail:
NvOdmGpioReleasePinHandle(s_powerkey.gpioHandle, s_powerkey.pinHandle);
err_gpio_pin_acquire_fail:
NvOdmGpioClose(s_powerkey.gpioHandle);
err_open_gpio_fail:
#ifdef POWERKEY_DELAYED_WORKQUEUE
wake_lock_destroy(&s_powerkey.wlock);
#endif
err_probe_fail:
//20100610, [email protected], sleep status gpio for modem [START]
#ifdef AP_SUSPEND_STATUS
NvOdmGpioReleasePinHandle(s_modemCheck.gpioHandle, s_modemCheck.pinHandle);
err_modem_chk_gpio_pin_acquire_fail:
NvOdmGpioClose(s_modemCheck.gpioHandle);
err_open_modem_chk_gpio_fail:
#endif
//20100610, [email protected], sleep status gpio for modem [END]
return -ENOSYS;
}
static int modem_resume(struct platform_device *pdev)
{
NvOdmGpioSetState(s_modemCheck.gpioHandle, s_modemCheck.pinHandle, 1);
return 0;
}
static int modem_suspend(struct platform_device *pdev, pm_message_t state)
{
NvOdmGpioSetState(s_modemCheck.gpioHandle, s_modemCheck.pinHandle, 0);
return 0;
}
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;
}
