static int h2w_switch_remove(struct platform_device *pdev) { struct h2w_switch_dev *hsdev; hsdev = (struct h2w_switch_dev *)platform_get_drvdata(pdev); #ifdef CONFIG_SWITCH_DOCK_H2W #if !TIMER_DEALER NvOdmGpioInterruptUnregister(hsdev->gpio, hsdev->dock_hp_det_pin, hsdev->dock_hp_det_irq); #endif #endif #if !TIMER_DEALER NvOdmGpioInterruptUnregister(hsdev->gpio, hsdev->hp_det_pin, hsdev->hp_det_irq); #endif destroy_workqueue(hsdev->workqueue); switch_dev_unregister(&hsdev->sdev); #ifdef CONFIG_SWITCH_DOCK_H2W NvOdmGpioReleasePinHandle(hsdev->gpio, hsdev->dock_hp_det_pin); #endif NvOdmGpioReleasePinHandle(hsdev->gpio, hsdev->hp_det_pin); NvOdmGpioClose(hsdev->gpio); kfree(hsdev); return 0; }
static int powerkey_remove(struct platform_device *pdev) { //20100703, [email protected], PMIC reset [START] sysfs_remove_group(&pdev->dev.kobj, &star_pmic_group); sysfs_remove_group(&pdev->dev.kobj, &star_hwsku_group); sysfs_remove_group(&pdev->dev.kobj, &star_reset_group); //20101110, [email protected], Function for Warm-boot //20100703, [email protected], PMIC reset [END] //20100610, [email protected], sleep status gpio for modem [START] #ifdef AP_SUSPEND_STATUS NvOdmGpioReleasePinHandle(s_modemCheck.gpioHandle, s_modemCheck.pinHandle); NvOdmGpioClose(s_modemCheck.gpioHandle); #endif //20100610, [email protected], sleep status gpio for modem [END] input_unregister_device(s_powerkey.inputDev); input_free_device(s_powerkey.inputDev); NvOdmGpioInterruptUnregister(s_powerkey.gpioHandle, s_powerkey.pinHandle, s_powerkey.intHandle); NvOdmGpioReleasePinHandle(s_powerkey.gpioHandle, s_powerkey.pinHandle); NvOdmGpioClose(s_powerkey.gpioHandle); #ifdef POWERKEY_DELAYED_WORKQUEUE wake_lock_destroy(&s_powerkey.wlock); #endif return 0; }
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; }
void Synaptics_OneTouch_Close (NvOdmOneTouchDeviceHandle hDevice) { Synaptics_OneTouch_Device* hTouch = (Synaptics_OneTouch_Device*)hDevice; NVODMTOUCH_PRINTF(("[Touch Driver] Synaptics_OneTouch_Close\n")); if (!hTouch) return; // 20101120 [email protected] power off when Onetouch close #if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F) Synaptics_OneTouch_PowerOnOff(&hTouch->OdmOneTouch, NV_FALSE); #endif if (hTouch->hGpio) { if (hTouch->hPin) { if (hTouch->hGpioIntr) NvOdmGpioInterruptUnregister(hTouch->hGpio, hTouch->hPin, hTouch->hGpioIntr); NvOdmGpioReleasePinHandle(hTouch->hGpio, hTouch->hPin); } NvOdmGpioClose(hTouch->hGpio); } if (hTouch->hOdmI2c) NvOdmI2cClose(hTouch->hOdmI2c); NvOdmOsFree(hTouch); }
void NvOdmAccelClose(NvOdmAccelHandle hDevice) { if(NULL != hDevice) { if(NULL != hDevice->SemaphoreForINT && NULL != hDevice->hGpioINT && NULL != hDevice->hPinINT && NULL != hDevice->hGpioInterrupt) { NvOdmGpioInterruptUnregister(hDevice->hGpioINT, hDevice->hPinINT, hDevice->hGpioInterrupt); NvOdmOsSemaphoreDestroy(hDevice->SemaphoreForINT); NvOdmGpioReleasePinHandle(hDevice->hGpioINT, hDevice->hPinINT); NvOdmGpioClose(hDevice->hGpioINT); } NvAccelerometerI2CClose(hDevice->hOdmI2C); // Power off accelermeter NvAccelerometerSetPowerRail(hDevice->hPmu, hDevice->VddId, NV_FALSE); if (hDevice->hPmu) { //NvAccelerometerSetPowerOn(0); NvOdmServicesPmuClose(hDevice->hPmu); } return; } }
void NvOdmGyroAccelClose(NvOdmGyroAccelHandle hDevice) { if (NULL != hDevice) { if (NULL != hDevice->SemaphoreForINT && NULL != hDevice->hGpioINT && NULL != hDevice->hPinINT && NULL != hDevice->hGpioInterrupt) { NvOdmGpioInterruptUnregister(hDevice->hGpioINT, hDevice->hPinINT, hDevice->hGpioInterrupt); NvOdmOsSemaphoreDestroy(hDevice->SemaphoreForINT); NvOdmGpioReleasePinHandle(hDevice->hGpioINT, hDevice->hPinINT); NvOdmGpioClose(hDevice->hGpioINT); } NvGyroAccelI2CClose(hDevice->hOdmI2C); #if 1 printk(" ## MPU3050 : [%s:%d] \n",__FUNCTION__, __LINE__) ; #endif // Power off accelermeter NvGyroAccelSetPowerRail(hDevice->hPmu, hDevice->VddId, NV_FALSE); if (hDevice->hPmu) { //NvGyroAccelSetPowerOn(0); NvOdmServicesPmuClose(hDevice->hPmu); } return; } }
static void vib_close( ) { NvU32 RequestedPeriod,ReturnedPeriod; NvU32 DutyCycle; if ( g_vib != NULL ) { NvOdmServicesPmuClose( g_vib->h_vib_pmu ); g_vib->h_vib_pmu = NULL; g_vib->vdd_id = 0; NvOdmGpioReleasePinHandle( g_vib->h_vib_gpio, g_vib->h_vib_gpio_pin ); NvOdmGpioClose( g_vib->h_vib_gpio ); if ( g_vib->hOdmPwm!= NULL ) { RequestedPeriod = 90000; // 49000; DutyCycle = 0x00320000; // 0x00630000; NvOdmPwmConfig( g_vib->hOdmPwm, NvOdmPwmOutputId_PWM3, NvOdmPwmMode_Disable, DutyCycle, &RequestedPeriod, &ReturnedPeriod ); } kfree( g_vib ); g_vib = NULL; } }
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; }
static int headsetdet_remove(struct platform_device *pdev) { lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headsetdet_remove() : headset detection ended..!!\n"); //20100421 [email protected] [LGE] struct headset_switch_data *switch_data = platform_get_drvdata(pdev); //20101125, [email protected], hookkey press is skipped When wakeup from LP1 [START] //wake_lock_destroy(&hook_det_lock); //20101125, [email protected], hookkey press is skipped When wakeup from LP1 [END] if (headset_h_pmu) NvOdmServicesPmuClose(headset_h_pmu); cancel_work_sync(&switch_data->work); cancel_delayed_work_sync(&switch_data->delayed_work); //P990_IFX_GB_PORTING_LGSI_START //FIDO - GB Porting [09/08/2011] - Start #if 1 //defined (STAR_OPERATOR_FIDO) wake_lock_destroy(&headset_wake_lock); //20110425 [email protected] headset wake lock timeout #endif //FIDO - GB Porting [09/08/2011] - End //P990_IFX_GB_PORTING_LGSI_END /*====================== nVidia GPIO Control(S) =======================*/ NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection, s_hHeadsetHandle.hheadsetInterrupt); NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection, s_hHeadsetHandle.hhookInterrupt); //20100421 [email protected] for Hookkey [LGE] NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection); NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection); //20100421 [email protected] for Hookkey [LGE] NvOdmGpioClose(s_hHeadsetHandle.hGpio); /*====================== nVidia GPIO Control(E) =======================*/ switch_dev_unregister(&switch_data->sdev); input_unregister_device(switch_data->ip_dev); //20100421 [email protected] for Hookkey [LGE] kfree(switch_data); return 0; }
static int h2w_switch_remove(struct platform_device *pdev) { struct h2w_switch_dev *hsdev; hsdev = (struct h2w_switch_dev *)platform_get_drvdata(pdev); NvOdmGpioInterruptUnregister(hsdev->gpio, hsdev->hp_det_pin, hsdev->hp_det_irq); NvOdmGpioReleasePinHandle(hsdev->gpio, hsdev->hp_det_pin); if (hsdev->have_dock_hp) { NvOdmGpioInterruptUnregister(hsdev->gpio, hsdev->dock_hp_det_pin, hsdev->dock_hp_det_irq); NvOdmGpioReleasePinHandle(hsdev->gpio, hsdev->dock_hp_det_pin); } NvOdmGpioClose(hsdev->gpio); destroy_workqueue(hsdev->workqueue); switch_dev_unregister(&hsdev->sdev); kfree(hsdev); return 0; }
void NvOdmSdioClose(NvOdmSdioHandle hOdmSdio) { if (hOdmSdio->pConnectivity->Guid == WLAN_GUID) { // Call Turn off power when close is Called (void)SdioOdmWlanPower(hOdmSdio, NV_FALSE); NvOdmGpioReleasePinHandle(hOdmSdio->hGpio, hOdmSdio->hPwrPin); NvOdmGpioReleasePinHandle(hOdmSdio->hGpio, hOdmSdio->hResetPin); NvOdmGpioClose(hOdmSdio->hGpio); } NvOdmSetPowerOnSdio(hOdmSdio, NV_FALSE); if (hOdmSdio->hPmu != NULL) { NvOdmServicesPmuClose(hOdmSdio->hPmu); } NvOdmOsFree(hOdmSdio); hOdmSdio = NULL; }
static int muic_remove(struct platform_device *pdev) { NvOdmGpioInterruptUnregister(s_hMuicHandle.hGpio, s_hMuicHandle.h_INT_N_MUIC, s_hMuicHandle.hGpioInterrupt); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_INT_N_MUIC); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_AP20_UART_SW); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_IFX_UART_SW); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_USIF1_SW); #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F) NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_USB_VBUS_EN); #endif NvOdmGpioClose(s_hMuicHandle.hGpio); #ifndef _MUIC_GPIO_I2C_ NvOdmI2cClose(s_hMuicHandle.hOdmI2c); #endif wake_lock_destroy(&s_hMuicHandle.wlock); remove_star_muic_proc_file(); return 0; }
static int __devexit Msensor_remove(struct platform_device *pdev) { //printk("==============>Msensor_remove\r\n"); ms3c_ControlStatus(STATUS_SUSPEND); if( s_hResetGpioPin ) NvOdmGpioReleasePinHandle(s_hGpio, s_hResetGpioPin); if( s_hGpio ) NvOdmGpioClose(s_hGpio); return 0; }
static int headsetdet_remove(struct platform_device *pdev) { lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headsetdet_remove() : headset detection ended..!!\n"); //20100421 [LGE] struct headset_switch_data *switch_data = platform_get_drvdata(pdev); //20101125, , hookkey press is skipped When wakeup from LP1 [START] //wake_lock_destroy(&hook_det_lock); //20101125, , hookkey press is skipped When wakeup from LP1 [END] if (headset_h_pmu) NvOdmServicesPmuClose(headset_h_pmu); cancel_work_sync(&switch_data->work); cancel_delayed_work_sync(&switch_data->delayed_work); /*====================== nVidia GPIO Control(S) =======================*/ NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection, s_hHeadsetHandle.hheadsetInterrupt); NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection, s_hHeadsetHandle.hhookInterrupt); //20100421 for Hookkey [LGE] NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection); NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection); //20100421 for Hookkey [LGE] NvOdmGpioClose(s_hHeadsetHandle.hGpio); /*====================== nVidia GPIO Control(E) =======================*/ switch_dev_unregister(&switch_data->sdev); input_unregister_device(switch_data->ip_dev); //20100421 for Hookkey [LGE] kfree(switch_data); return 0; }
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); NvOdmGpioReleasePinHandle(hOdmSdio->hGpio, hOdmSdio->hResetPin); NvOdmGpioClose(hOdmSdio->hGpio); } NvOdmSetPowerOnSdio(hOdmSdio, NV_FALSE); if (hOdmSdio->hPmu != NULL) { NvOdmServicesPmuClose(hOdmSdio->hPmu); } NvOdmOsFree(hOdmSdio); hOdmSdio = NULL; }
static int proximity_remove(struct platform_device *pdev) { struct device *dev = &pdev->dev; star_proxi_disable(&s_proximity); sysfs_remove_group(&dev->kobj, &star_proxi_group); input_unregister_device(s_proximity.input_dev); NvOdmGpioInterruptUnregister(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, s_proximity.proxi_out_intr); NvOdmGpioReleasePinHandle(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin); NvOdmGpioClose(s_proximity.proxi_out_gpio); NvOdmI2cClose(s_proximity.gen2_i2c); return 0; }
static void Adt7461FreePrivData(ADT7461PrivData* pPrivData) { if (pPrivData) { if (pPrivData->hGpioIntr) { NvOdmGpioInterruptUnregister( pPrivData->hGpio, pPrivData->hGpioPin, pPrivData->hGpioIntr); } NvOdmI2cClose(pPrivData->hOdmI2C); NvOdmGpioReleasePinHandle(pPrivData->hGpio, pPrivData->hGpioPin); NvOdmGpioClose(pPrivData->hGpio); NvOdmServicesPmuClose(pPrivData->hOdmPmuSevice); NvOdmOsFree(pPrivData); } }
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); } }
void NvOdmUsbUlpiClose(NvOdmUsbUlpiHandle hOdmUlpi) { if (hOdmUlpi) { NvOdmOsFree(hOdmUlpi); } if (s_hResetPin) { NvOdmGpioReleasePinHandle(s_hGpio, s_hResetPin); s_hResetPin = NULL; } if (s_hGpio) { NvOdmGpioClose(s_hGpio); s_hGpio = NULL; } }
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); }
static int gps_control_remove(struct platform_device *pdev) { struct gps_control_dev *gps_control; gps_control = (struct gps_control_dev *)platform_get_drvdata(pdev); if (gps_control != NULL) { NvOdmGpioReleasePinHandle(gps_control->gpio_handle, gps_control->pin_handle); gps_control->pin_handle = 0; NvOdmGpioClose(gps_control->gpio_handle); gps_control->gpio_handle = 0; if (gps_control->input_dev) { input_unregister_device(gps_control->input_dev); input_free_device(gps_control->input_dev); gps_control->input_dev = 0; } } return 0; }
void EETI_Close (NvOdmTouchDeviceHandle hDevice) { EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice; if (!hTouch) return; if (hTouch->hGpio) { if (hTouch->hPin) { if (hTouch->hGpioIntr) NvOdmGpioInterruptUnregister(hTouch->hGpio, hTouch->hPin, hTouch->hGpioIntr); NvOdmGpioReleasePinHandle(hTouch->hGpio, hTouch->hPin); } NvOdmGpioClose(hTouch->hGpio); } if (hTouch->hOdmI2c) NvOdmI2cClose(hTouch->hOdmI2c); NvOdmOsFree(hTouch); }
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 int __devexit headset_switch_remove(struct platform_device *pdev) { struct gpio_switch_data *switch_data = platform_get_drvdata(pdev); cancel_work_sync(&switch_data->work); //remove interrupt NvOdmGpioInterruptUnregister( s_hGpio, s_hHeadphoneGpioPin, s_hGpioIntr_Headphone); NvOdmGpioReleasePinHandle(s_hGpio, s_hHeadphoneGpioPin); s_hHeadphoneGpioPin = NULL; //remove thread //terminate thread g_DetectThread_exit = 1; if ( g_hDetectEventSema ) NvOdmOsSemaphoreSignal( g_hDetectEventSema ); if( !g_hDetectThread ) NvOdmOsThreadJoin( g_hDetectThread ); g_hDetectThread = NULL; if ( g_hDetectEventSema ) { NvOdmOsSemaphoreDestroy( g_hDetectEventSema ); g_hDetectEventSema = 0; } switch_dev_unregister(&switch_data->sdev); kfree(switch_data); return 0; }
static int headsetdet_remove(struct platform_device *pdev) { #if 0 printk(KERN_ERR "##(Headset_det.c)## headsetdet_remove() : headset detection ended..!!\n"); //20100421 [email protected] [LGE] struct headset_switch_data *switch_data = platform_get_drvdata(pdev); cancel_work_sync(&switch_data->work); cancel_delayed_work_sync(&switch_data->delayed_work); /*====================== nVidia GPIO Control(S) =======================*/ NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection, s_hHeadsetHandle.hGpioInterrupt); //NvOdmGpioInterruptUnregister(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection, s_hHeadsetHandle.hGpioInterrupt); //20100421 [email protected] for Hookkey [LGE] NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection); //NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection); //20100421 [email protected] for Hookkey [LGE] NvOdmGpioClose(s_hHeadsetHandle.hGpio); /*====================== nVidia GPIO Control(E) =======================*/ switch_dev_unregister(&switch_data->sdev); //input_unregister_device(switch_data->ip_dev); //20100421 [email protected] for Hookkey [LGE] kfree(switch_data); #endif 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 __init proximity_probe(struct platform_device *pdev) { int i, ret = 0; NvU32 I2cInstance = 0; const NvOdmPeripheralConnectivity *pConnectivity = NULL; NvU32 port = 0, pin = 0; struct device *dev = &pdev->dev; unsigned int pinvalue; atomic_set(&proxi_status, 1); pConnectivity = NvOdmPeripheralGetGuid(PROXIMITY_GUID); for (i = 0; i < pConnectivity->NumAddress; i++) { switch (pConnectivity->AddressList[i].Interface) { case NvOdmIoModule_I2c: s_proximity.i2c_address = (pConnectivity->AddressList[i].Address << 1); I2cInstance = pConnectivity->AddressList[i].Instance; break; case NvOdmIoModule_Gpio: port = pConnectivity->AddressList[i].Instance; pin = pConnectivity->AddressList[i].Address; break; case NvOdmIoModule_Vdd: s_proximity.vddId = pConnectivity->AddressList[i].Address; break; default: break; } } s_proximity.MVO = 0; #if defined(CONFIG_MACH_STAR_MDM_C) port = 'r' - 'a';//'a' - 'a'; pin = 2;//0; #elif defined (CONFIG_MACH_STAR_REV_F) || defined (CONFIG_MACH_STAR_TMUS) port = 'w'-'a'; pin = 2; #else #error PROXI_OUT PIN not assigned #endif lprintk(D_PROXI, "[star Proximity] start!!!--------------------------------------------------------------------------\n"); s_proximity.proxi_out_gpio = NvOdmGpioOpen(); if (!s_proximity.proxi_out_gpio) { lprintk(D_PROXI, "[star Proximity] gpio open fail!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); ret = -ENOSYS; goto err_open_gpio_fail; } s_proximity.proxi_out_gpio_pin = NvOdmGpioAcquirePinHandle(s_proximity.proxi_out_gpio, port, pin); if (!s_proximity.proxi_out_gpio_pin) { lprintk(D_PROXI, "[star Proximity] gpio pin acquire fail!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); ret = -ENOSYS; goto err_open_gpio_pin_acquire_fail; } // NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1); // NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputData); #if 1 INIT_WORK(&s_proximity.work, star_proxi_workqueue_func); s_proximity.gen2_i2c = NvOdmI2cPinMuxOpen(NvOdmIoModule_I2c, 1, NvOdmI2cPinMap_Config2); if (!s_proximity.gen2_i2c) { lprintk(D_PROXI, "[star Proximity] i2c open fail!\n"); ret = -ENOSYS; goto err_open_i2c_handle_fail; } s_proximity.use_int_mode = true; #if 0 NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_Output); NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1); NvOdmOsWaitUS(100000);//100ms NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue); printk("interrupt pin level = %d\n----------------", pinvalue ); NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0); NvOdmOsWaitUS(100000);//100ms NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue); printk("interrupt pin level = %d\n----------------", pinvalue ); NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1); NvOdmOsWaitUS(100000);//100ms NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue); printk("interrupt pin level = %d\n----------------", pinvalue ); NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0); NvOdmOsWaitUS(100000);//100ms NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue); printk("interrupt pin level = %d\n----------------", pinvalue ); NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1); NvOdmOsWaitUS(100000);//100ms NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue); printk("interrupt pin level = %d\n----------------", pinvalue ); #endif #if 0 while(1) { NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1); NvOdmOsWaitUS(100000);//100ms NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0); NvOdmOsWaitUS(100000);//100ms } #endif NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputData); if (s_proximity.use_int_mode == true) { if (NvOdmGpioInterruptRegister(s_proximity.proxi_out_gpio, &s_proximity.proxi_out_intr, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputInterruptLow, star_proxi_interrupt_handler, (void*)&s_proximity, 0) == NV_FALSE) { lprintk(D_PROXI, "[star Proximity] interrupt register fail!\n"); ret = -ENOSYS; goto err_open_irq_handle_fail; } } else { if (NvOdmGpioInterruptRegister(s_proximity.proxi_out_gpio, &s_proximity.proxi_out_intr, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputInterruptFallingEdge, star_proxi_sleep_handler, (void*)&s_proximity, 0) == NV_FALSE) { lprintk(D_PROXI, "[star Proximity] interrupt register fail!\n"); ret = -ENOSYS; goto err_open_irq_handle_fail; } hrtimer_init(&s_proximity.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); s_proximity.timer.function = star_proxi_timer_func; s_proximity.delay = PROXI_DEFAULT_DELAY_NS; } NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_TRUE); s_proximity.input_dev = input_allocate_device(); if (!s_proximity.input_dev) { lprintk(D_PROXI, "[star Proximity] input device alloc fail!\n"); ret = -ENOMEM; goto err_alloc_input_device_fail; } set_bit(EV_KEY, s_proximity.input_dev->evbit); set_bit(KEY_POWER, s_proximity.input_dev->keybit); set_bit(EV_ABS, s_proximity.input_dev->evbit); input_set_abs_params(s_proximity.input_dev, ABS_DISTANCE, 0, 1, 0, 0); s_proximity.input_dev->name = "proximity"; ret = input_register_device(s_proximity.input_dev); if (ret) { lprintk(D_PROXI, "[star Proximity] input device register fail!\n"); ret = -ENOMEM; goto err_alloc_input_device_fail; } if ((ret = sysfs_create_group(&dev->kobj, &star_proxi_group))) { lprintk(D_PROXI, "[star Proximity] sysfs_create_group fail!\n"); ret = -ENOMEM; goto err_sysfs_group_fail; } // star_proxi_power_onoff(&s_proximity, true); return 0; err_sysfs_group_fail: input_unregister_device(s_proximity.input_dev); err_alloc_input_device_fail: NvOdmGpioInterruptUnregister(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, s_proximity.proxi_out_intr); err_open_irq_handle_fail: NvOdmI2cClose(s_proximity.gen2_i2c); err_open_i2c_handle_fail: NvOdmGpioReleasePinHandle(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin); err_open_gpio_pin_acquire_fail: NvOdmGpioClose(s_proximity.proxi_out_gpio); err_open_gpio_fail: return ret; #endif }
static int __init muic_probe(struct platform_device *pdev) { int i, j, ret; #ifdef _MUIC_GPIO_I2C_ int ret_val; #else NvU32 I2cInstance = 0; #endif #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F) NvU32 pin[5], port[5]; #else NvU32 pin[4], port[4]; #endif const NvOdmPeripheralConnectivity *pConnectivity = NULL; printk(KERN_INFO "muic_probe\n"); pConnectivity = NvOdmPeripheralGetGuid(MUIC_GUID); for (i = 0, j = 0 ; i < pConnectivity->NumAddress; i++) { switch (pConnectivity->AddressList[i].Interface) { #ifndef _MUIC_GPIO_I2C_ case NvOdmIoModule_I2c: s_hMuicHandle.DeviceAddr = (pConnectivity->AddressList[i].Address << 1); I2cInstance = pConnectivity->AddressList[i].Instance; break; #endif case NvOdmIoModule_Gpio: port[j] = pConnectivity->AddressList[i].Instance; pin[j] = pConnectivity->AddressList[i].Address; j++; break; default: break; } } s_hMuicHandle.hGpio = NvOdmGpioOpen(); if (!s_hMuicHandle.hGpio) { lprintk(D_MUIC, "%s: NvOdmGpioOpen Error \n", __func__); goto err_open_gpio_fail; } s_hMuicHandle.h_INT_N_MUIC = NvOdmGpioAcquirePinHandle(s_hMuicHandle.hGpio, port[0], pin[0]); if (!s_hMuicHandle.h_INT_N_MUIC) { lprintk(D_MUIC, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } s_hMuicHandle.h_AP20_UART_SW = NvOdmGpioAcquirePinHandle(s_hMuicHandle.hGpio, port[1], pin[1]); if (!s_hMuicHandle.h_AP20_UART_SW) { lprintk(D_MUIC, "%s:Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } s_hMuicHandle.h_IFX_UART_SW = NvOdmGpioAcquirePinHandle(s_hMuicHandle.hGpio, port[2], pin[2]); if (!s_hMuicHandle.h_IFX_UART_SW) { lprintk(D_MUIC, "%s:Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } s_hMuicHandle.h_USIF1_SW = NvOdmGpioAcquirePinHandle(s_hMuicHandle.hGpio, port[3], pin[3]); if (!s_hMuicHandle.h_USIF1_SW) { lprintk(D_MUIC, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F) s_hMuicHandle.h_USB_VBUS_EN = NvOdmGpioAcquirePinHandle(s_hMuicHandle.hGpio, port[4], pin[4]); if (!s_hMuicHandle.h_USB_VBUS_EN) { lprintk(D_MUIC, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } #endif NvOdmGpioConfig(s_hMuicHandle.hGpio, s_hMuicHandle.h_INT_N_MUIC, NvOdmGpioPinMode_InputData); NvOdmGpioConfig(s_hMuicHandle.hGpio, s_hMuicHandle.h_AP20_UART_SW, NvOdmGpioPinMode_Output); NvOdmGpioConfig(s_hMuicHandle.hGpio, s_hMuicHandle.h_IFX_UART_SW, NvOdmGpioPinMode_Output); NvOdmGpioConfig(s_hMuicHandle.hGpio, s_hMuicHandle.h_USIF1_SW, NvOdmGpioPinMode_Output); #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F) NvOdmGpioConfig(s_hMuicHandle.hGpio, s_hMuicHandle.h_USB_VBUS_EN, NvOdmGpioPinMode_Output); #endif #ifdef _MUIC_GPIO_I2C_ ret_val = MUIC_Gpio_i2c_init(&s_hMuicHandle); if (ret_val < 0) { lprintk(D_MUIC, "%s: MUIC_Gpio_i2c_init Error \n", __func__); goto err_open_i2c_handle; } #else s_hMuicHandle.hOdmI2c = NvOdmI2cOpen(NvOdmIoModule_I2c, I2cInstance); if (!s_hMuicHandle.hOdmI2c) { lprintk(D_MUIC, "%s: NvOdmI2cOpen Error \n", __func__); goto err_open_i2c_handle; } #endif wake_lock_init(&s_hMuicHandle.wlock, WAKE_LOCK_SUSPEND, "muic_active"); //20101117, [email protected], for autorun [START] #ifdef CONFIG_USB_SUPPORT_LGE_ANDROID_AUTORUN s_hMuicHandle.sdev_autorun.name = DRIVER_NAME_FOR_AUTORUN; s_hMuicHandle.sdev_autorun.print_name = print_switch_name_for_autorun; s_hMuicHandle.sdev_autorun.print_state = print_switch_state_for_autorun; ret = switch_dev_register(&s_hMuicHandle.sdev_autorun); if (ret) { goto err_sdev_unregister; } #endif //20101117, [email protected], for autorun [END] INIT_DELAYED_WORK(&muic_wq, muic_wq_func); if (NvOdmGpioInterruptRegister(s_hMuicHandle.hGpio, &s_hMuicHandle.hGpioInterrupt, s_hMuicHandle.h_INT_N_MUIC, NvOdmGpioPinMode_InputInterruptFallingEdge , muic_interrupt_handler, (void*)&s_hMuicHandle, 0) == NV_FALSE) { lprintk(D_MUIC, KERN_ERR "%s: cannot register interrupt.\n", __func__); goto err_get_interrupt_handler; } create_star_muic_proc_file(); current_device = DEVICE_NONE; muic_initialize_max(RESET); //20100915, [email protected], move to late_initcall [START] #if 0 NvOdmOsSleepMS(400) ; MAX14526_Device_Detection(); #endif //20100915, [email protected], move to late_initcall [STOP] return 0; err_get_interrupt_handler: #ifndef _MUIC_GPIO_I2C_ NvOdmI2cClose(s_hMuicHandle.hOdmI2c); #endif //20101117, [email protected], for autorun [START] #ifdef CONFIG_USB_SUPPORT_LGE_ANDROID_AUTORUN err_sdev_unregister: switch_dev_unregister(&s_hMuicHandle.sdev_autorun); #endif //20101117, [email protected], for autorun [END] err_open_i2c_handle: NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_INT_N_MUIC); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_AP20_UART_SW); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_IFX_UART_SW); NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_USIF1_SW); #if defined(CONFIG_MACH_STAR_REV_D) || defined(CONFIG_MACH_STAR_REV_E) || defined(CONFIG_MACH_STAR_REV_F) NvOdmGpioReleasePinHandle(s_hMuicHandle.hGpio, s_hMuicHandle.h_USB_VBUS_EN); #endif err_open_gpio_pin_acquire_fail: NvOdmGpioClose(s_hMuicHandle.hGpio); err_open_gpio_fail: return -ENOSYS; }