static void ConfigPowerRail( NvOdmServicesPmuHandle hPMUDevice, NvU32 Id, NvBool IsEnable) { NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; if (hPMUDevice && Id) { NvOdmServicesPmuGetCapabilities(hPMUDevice, Id, &vddrailcap); if (IsEnable) { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, vddrailcap.requestMilliVolts, &settletime); } else { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, vddrailcap.MinMilliVolts, &settletime); } if (settletime) NvOdmOsWaitUS(settletime); } }
static void star_proxi_vddio_vi_power_onoff( NvU32 vdd_id, NvBool is_enable ) { NvOdmServicesPmuHandle h_pmu = NvOdmServicesPmuOpen(); NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; if(h_pmu) { NvOdmServicesPmuGetCapabilities(h_pmu, vdd_id, &vddrailcap); if( is_enable ) { #if 1 printk("VDDID_VI's pmu enable for PROXI_OUT\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, vddrailcap.requestMilliVolts, &settletime); } else { #if 1 printk("VDDID_VI's pmu do not enable for PROXI_OUT\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, NVODM_VOLTAGE_OFF, &settletime); } if(settletime) NvOdmOsWaitUS(settletime); } NvOdmServicesPmuClose(h_pmu); }
static void NvOdmSetPowerOnSdio(NvOdmSdioHandle pDevice, NvBool enable) { const NvOdmPeripheralConnectivity *pConn; NvU32 i; pConn = pDevice->pConnectivity; for (i=0; i<pConn->NumAddress; i++) { const NvOdmIoAddress *addr = &pConn->AddressList[i]; NvU32 settle; NvU32 voltage; if (addr->Interface != NvOdmIoModule_Vdd) continue; if (enable) { NvOdmServicesPmuVddRailCapabilities caps; NvOdmServicesPmuGetCapabilities(pDevice->hPmu, addr->Address, &caps); voltage = caps.requestMilliVolts; } else { voltage = ODM_VOLTAGE_OFF; } NvOdmServicesPmuSetVoltage(pDevice->hPmu, addr->Address, voltage, &settle); if (settle) NvOdmOsWaitUS(settle); } }
static int vib_set_power_rail( NvU32 vdd_id, NvBool is_enable ) { NvOdmServicesPmuHandle h_pmu = NvOdmServicesPmuOpen( ); NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; if ( h_pmu ) { NvOdmServicesPmuGetCapabilities( h_pmu, vdd_id, &vddrailcap ); if ( is_enable ) { DbgOut(( "[ImmVibeSPI] vibrator PMU enable\n" )); NvOdmServicesPmuSetVoltage( h_pmu, vdd_id, vddrailcap.requestMilliVolts, &settletime ); } else { DbgOut(( "[ImmVibeSPI] vibrator PMU do not enable\n" )); NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, NVODM_VOLTAGE_OFF, &settletime); } if ( settletime ) NvOdmOsWaitUS( settletime ); NvOdmServicesPmuClose( h_pmu ); DbgOut(( "[ImmVibeSPI] vibrator voltage = %d or %d \n", vddrailcap.requestMilliVolts, vddrailcap.MinMilliVolts )); return 0; } return -1; }
static void NvOdmSetPowerOnSdio(NvOdmSdioHandle pDevice, NvBool IsEnable) { NvU32 Index = 0; NvOdmServicesPmuVddRailCapabilities RailCaps; NvU32 SettlingTime = 0; const NvOdmPeripheralConnectivity *pConnectivity; pConnectivity = pDevice->pConnectivity; if (IsEnable) // Turn on Power { // Search for the Vdd rail and set the proper volage to the rail. for (Index = 0; Index < pConnectivity->NumAddress; ++Index) { if (pConnectivity->AddressList[Index].Interface == NvOdmIoModule_Vdd) { NvOdmServicesPmuGetCapabilities(pDevice->hPmu, pConnectivity->AddressList[Index].Address, &RailCaps); NvOdmServicesPmuSetVoltage(pDevice->hPmu, pConnectivity->AddressList[Index].Address, RailCaps.requestMilliVolts, &SettlingTime); if (SettlingTime) { NvOdmOsWaitUS(SettlingTime); } } } } else // Shutdown Power { // Search for the Vdd rail and power Off the module for (Index = 0; Index < pConnectivity->NumAddress; ++Index) { if (pConnectivity->AddressList[Index].Interface == NvOdmIoModule_Vdd) { NvOdmServicesPmuGetCapabilities(pDevice->hPmu, pConnectivity->AddressList[Index].Address, &RailCaps); NvOdmServicesPmuSetVoltage(pDevice->hPmu, pConnectivity->AddressList[Index].Address, ODM_VOLTAGE_OFF, &SettlingTime); if (SettlingTime) { NvOdmOsWaitUS(SettlingTime); } } } } }
NvBool Synaptics_OneTouch_PowerOnOff (NvOdmOneTouchDeviceHandle hDevice, NvBool OnOff) { // 20101120 [email protected] power off when Onetouch close #if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F) NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; Synaptics_OneTouch_Device* hTouch = (Synaptics_OneTouch_Device*)hDevice; hTouch->hPmu = NvOdmServicesPmuOpen(); printk("[ONETOUCH] Synaptics_OneTouch_PowerOnOff\n"); if (!hTouch->hPmu) { printk("[ONETOUCH] NvOdmServicesPmuOpen Error\n"); return NV_FALSE; } NvOdmServicesPmuGetCapabilities( hTouch->hPmu, hTouch->VddId, &vddrailcap); printk("[ONETOUCH] power on[%d], vol[%d]\n", OnOff, vddrailcap.requestMilliVolts); if(OnOff) { // 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [START] #if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F) if(hGpioIntr_touch) NvOdmGpioInterruptMask(hGpioIntr_touch, NV_TRUE); #endif // 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [END] NvOdmServicesPmuSetVoltage( hTouch->hPmu, hTouch->I2cVddId, NVODM_VOLTAGE_OFF, &settletime); NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*1000); // wait to settle power NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, NVODM_VOLTAGE_OFF, &settletime); NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*2*1000); // wait to settle power NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, MAX8907_REQUESTVOLTAGE_LDO16, &settletime); NvOdmServicesPmuSetVoltage( hTouch->hPmu, hTouch->I2cVddId, MAX8907_REQUESTVOLTAGE_LDO19, &settletime); // 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [START] #if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F) if(hGpioIntr_touch) NvOdmGpioInterruptMask(hGpioIntr_touch, NV_FALSE); #endif // 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [END] }else NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, NVODM_VOLTAGE_OFF, &settletime); NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*5*1000); // wait to settle power NvOdmServicesPmuClose(hTouch->hPmu); #endif return NV_TRUE; }
static int __init touchLED_probe(struct platform_device *pdev) { s_touchLED.conn = NvOdmPeripheralGetGuid( NV_ODM_GUID('t','o','u','c','h','L','E','D') ); /* enable the power rail */ s_touchLED.hPmu = NvOdmServicesPmuOpen(); if( s_touchLED.conn->AddressList[0].Interface == NvOdmIoModule_Vdd ) { NvOdmServicesPmuVddRailCapabilities cap; NvU32 settle_us; /* address is the vdd rail id */ NvOdmServicesPmuGetCapabilities( s_touchLED.hPmu, s_touchLED.conn->AddressList[0].Address, &cap ); s_touchLED.setVal = cap.requestMilliVolts; s_touchLED.maxVal = 100; /*10.0mA*/ /* set the rail volatage to the recommended */ NvOdmServicesPmuSetVoltage( s_touchLED.hPmu, s_touchLED.conn->AddressList[0].Address, cap.requestMilliVolts, &settle_us ); /* wait for rail to settle */ NvOdmOsWaitUS( settle_us ); } INIT_WORK(&s_touchLED.work, touchLED_timeout); #ifdef TOUCH_LED_TIMER hrtimer_init(&s_touchLED.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); s_touchLED.timer.function = touchLED_timer_func; s_touchLED.delay = TOUCH_DELAY_SEC; hrtimer_start(&s_touchLED.timer, ktime_set(BOOT_DELAY_SEC, 0), HRTIMER_MODE_REL); #endif #ifdef CONFIG_HAS_EARLYSUSPEND s_touchLED.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; s_touchLED.early_suspend.suspend = touchLED_early_suspend; s_touchLED.early_suspend.resume = touchLED_late_resume; register_early_suspend(&s_touchLED.early_suspend); #endif //20101104, [email protected], WLED set [START] if (sysfs_create_group(&pdev->dev.kobj, &star_wled_group)) { printk(KERN_ERR "[star touch led] sysfs_create_group ERROR\n"); } //20101104, [email protected], WLED set [END] return 0; }
void NvAccelerometerSetPowerRail(NvOdmServicesPmuHandle hPMUDevice, NvU32 Id, NvBool IsEnable) { NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; if (hPMUDevice) { NvOdmServicesPmuGetCapabilities(hPMUDevice, Id, &vddrailcap); if (IsEnable) { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, vddrailcap.requestMilliVolts, &settletime); } else { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, vddrailcap.MinMilliVolts, &settletime); } NvOdmOsWaitUS(settletime); // wait to settle power } }
void NvGyroAccelSetPowerRail(NvOdmServicesPmuHandle hPMUDevice, NvU32 Id, NvBool IsEnable) { NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; printk(" ## MPU3050 : 3 \n") ; Accel_PRail = Id; if (hPMUDevice) { NvOdmServicesPmuGetCapabilities(hPMUDevice, Id, &vddrailcap); if (IsEnable) { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, vddrailcap.requestMilliVolts, &settletime); } else { NvOdmServicesPmuSetVoltage(hPMUDevice, Id, NVODM_VOLTAGE_OFF, &settletime); } if (settletime) NvOdmOsWaitUS(settletime); // wait to settle power } }
static int star_vib_set_power_rail( u32 vdd_id, u8 is_enable ) { printk("vib: %s,%d\n", __FUNCTION__, __LINE__); #if 0 // by DENNIS NvOdmServicesPmuHandle h_pmu = NvOdmServicesPmuOpen(); NvOdmServicesPmuVddRailCapabilities vddrailcap; u32 settletime; if(h_pmu) { NvOdmServicesPmuGetCapabilities( h_pmu, vdd_id, &vddrailcap ); if( is_enable ) { #if VIB_DEBUG printk("[skhwang] vibrator PMU enable\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, vddrailcap.requestMilliVolts, &settletime); } else { #if VIB_DEBUG printk("[skhwang] vibrator PMU do not enable\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, NVODM_VOLTAGE_OFF, &settletime); } if(settletime) NvOdmOsWaitUS(settletime); NvOdmServicesPmuClose(h_pmu); #if VIB_DEBUG printk("[skhwang] vibrator voltage = %d or %d \n", vddrailcap.requestMilliVolts, vddrailcap.MinMilliVolts); #endif return 0; } return -1; #endif }
static void star_proxi_power_onoff(ProximityDevice *data, bool enable) { #if 1 NvOdmServicesPmuHandle ldo_pmu = NvOdmServicesPmuOpen(); NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime = 0; if (enable) { NvOdmServicesPmuGetCapabilities(ldo_pmu, data->vddId, &vddrailcap); NvOdmServicesPmuSetVoltage(ldo_pmu, data->vddId, vddrailcap.requestMilliVolts, &settletime); } else { NvOdmServicesPmuSetVoltage(ldo_pmu, data->vddId, NVODM_VOLTAGE_OFF, &settletime); } //if (settletime) NvOdmOsWaitUS(10000); NvOdmServicesPmuClose(ldo_pmu); #endif }
// 20100903 Power control bug fix [START] static int star_hall_set_power_rail( NvU32 vdd_id, NvBool is_enable ) { NvOdmServicesPmuHandle h_pmu = NvOdmServicesPmuOpen(); NvOdmServicesPmuVddRailCapabilities vddrailcap; NvU32 settletime; if(h_pmu) { NvOdmServicesPmuGetCapabilities( h_pmu, vdd_id, &vddrailcap ); if( is_enable ) { #if HALL_DEBUG printk("HALL IC PMU enable\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, vddrailcap.requestMilliVolts, &settletime); } else { #if HALL_DEBUG printk("HALL IC PMU do not enable\n"); #endif NvOdmServicesPmuSetVoltage(h_pmu, vdd_id, NVODM_VOLTAGE_OFF, &settletime); } if(settletime) NvOdmOsWaitUS(settletime); NvOdmServicesPmuClose(h_pmu); #if HALL_DEBUG printk("[skhwang] HALL IC voltage = %d or %d \n", vddrailcap.requestMilliVolts, vddrailcap.MinMilliVolts); #endif return 0; } return -1; }
/** * @brief Allocates a handle to the device. Configures the PWM * control to the Vibro motor with default values. To change * the amplitude and frequency use NvOdmVibrateSetParameter API. * @param hOdmVibrate [IN] Opaque handle to the device. * @return NV_TRUE on success and NV_FALSE on error */ NvBool NvOdmVibOpen(NvOdmVibDeviceHandle *hOdmVibrate) { const NvOdmPeripheralConnectivity *pConnectivity = NULL; NvU32 Index = 0; NV_ASSERT(hOdmVibrate); /* Allocate the handle */ (*hOdmVibrate) = (NvOdmVibDeviceHandle)NvOdmOsAlloc(sizeof(NvOdmVibDevice)); if (*hOdmVibrate == NULL) { NV_ODM_TRACE(("Error Allocating NvOdmPmuDevice. \n")); return NV_FALSE; } NvOsMemset((*hOdmVibrate), 0, sizeof(NvOdmVibDevice)); #if (defined(CONFIG_7546Y_V10)) /*HZJ ADD FOR VIBRATE*/ (*hOdmVibrate)->vibrate_gpio= NvOdmGpioOpen(); if (!(*hOdmVibrate)->vibrate_gpio) { NV_ODM_TRACE("err open gpio vibrate hzj added\r\n"); kfree(*hOdmVibrate); return -1; } (*hOdmVibrate)->vibrate_pin = NvOdmGpioAcquirePinHandle((*hOdmVibrate)->vibrate_gpio, VIBRATE_DET_ENABLE_PORT, VIBRATE_DET_ENABLE_PIN); if (!(*hOdmVibrate)->vibrate_pin) { NV_ODM_TRACE("err acquire detect pin handle vibrate\r\n"); NvOdmGpioClose((*hOdmVibrate)->vibrate_gpio); return -1; } NvOdmGpioConfig((*hOdmVibrate)->vibrate_gpio, (*hOdmVibrate)->vibrate_pin, NvOdmGpioPinMode_Output); /*End Hzj aded*/ (*hOdmVibrate)->vibrate_segpio= NvOdmGpioOpen(); if (!(*hOdmVibrate)->vibrate_segpio) { NV_ODM_TRACE("err open gpio vibrate hzj added\r\n"); kfree(*hOdmVibrate); return -1; } (*hOdmVibrate)->vibrate_sepin = NvOdmGpioAcquirePinHandle((*hOdmVibrate)->vibrate_segpio, VIBRATE_SE_PORT, VIBRATE_SE_PIN); if (!(*hOdmVibrate)->vibrate_sepin) { NV_ODM_TRACE("err acquire detect pin handle vibrate\r\n"); NvOdmGpioClose((*hOdmVibrate)->vibrate_segpio); return -1; } NvOdmGpioConfig((*hOdmVibrate)->vibrate_segpio, (*hOdmVibrate)->vibrate_sepin, NvOdmGpioPinMode_Output); #endif /* Get the PMU handle */ (*hOdmVibrate)->hOdmServicePmuDevice = NvOdmServicesPmuOpen(); if (!(*hOdmVibrate)->hOdmServicePmuDevice) { NV_ODM_TRACE(("Error Opening Pmu device. \n")); NvOdmOsFree(*hOdmVibrate); *hOdmVibrate = NULL; return NV_FALSE; } // Get the peripheral connectivity information pConnectivity = NvOdmPeripheralGetGuid(VIBRATE_DEVICE_GUID); if (pConnectivity == NULL) return NV_FALSE; // Search for the Vdd rail and set the proper volage to the rail. for (Index = 0; Index < pConnectivity->NumAddress; ++Index) { if (pConnectivity->AddressList[Index].Interface == NvOdmIoModule_Vdd) { (*hOdmVibrate)->VddId = pConnectivity->AddressList[Index].Address; NvOdmServicesPmuGetCapabilities((*hOdmVibrate)->hOdmServicePmuDevice, (*hOdmVibrate)->VddId, &((*hOdmVibrate)->RailCaps)); break; } } return NV_TRUE; }
static int headsetdet_probe(struct platform_device *pdev) { struct gpio_switch_platform_data *pdata = pdev->dev.platform_data; struct headset_switch_data *switch_data; int ret = 0; NvS32 err = 0; struct input_dev *ip_dev; struct input_dev *ip_dev_wake; int i, j; NvU32 I2cInstance = 0; NvU32 pin[4], port[4]; const NvOdmPeripheralConnectivity *pConnectivity = NULL; pConnectivity = NvOdmPeripheralGetGuid(HEADSET_GUID); for (i = 0, j = 0 ; i < pConnectivity->NumAddress; i++) { switch (pConnectivity->AddressList[i].Interface) { case NvOdmIoModule_Gpio: port[j] = pConnectivity->AddressList[i].Instance; pin[j] = pConnectivity->AddressList[i].Address; j++; break; //20101117, [email protected], gpio wakeup from LP1 [START] case NvOdmIoModule_Vdd: { NvOdmServicesPmuVddRailCapabilities vddrailcap; headset_h_pmu = NvOdmServicesPmuOpen(); headset_vdd_address = pConnectivity->AddressList[i].Address; NvOdmServicesPmuGetCapabilities(headset_h_pmu, pConnectivity->AddressList[i].Address, &vddrailcap); headset_vdd_voltage = vddrailcap.requestMilliVolts; } break; //20101117, [email protected], gpio wakeup from LP1 [END] default: break; } } if (!pdata) return -EBUSY; switch_data = kzalloc(sizeof(struct headset_switch_data), GFP_KERNEL); if (!switch_data) return -ENOMEM; switch_data->sdev.name = pdata->name; switch_data->gpio = pdata->gpio; switch_data->name_on = pdata->name_on; switch_data->name_off = pdata->name_off; switch_data->state_on = pdata->state_on; switch_data->state_off = pdata->state_off; switch_data->sdev.print_state = switch_gpio_print_state; lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headsetdet_probe() => headset detection started..!!\n"); //20100421 [email protected] [LGE] ret = switch_dev_register(&switch_data->sdev); //20100421 [email protected] Headset Detection by Headset Observer [LGE] if (ret < 0) goto err_switch_dev_register; lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - switch device registered..!!\n"); //20100421 [email protected] [LGE] /*====================== nVidia GPIO Control(S) =======================*/ s_hHeadsetHandle.hGpio = NvOdmGpioOpen(); if (!s_hHeadsetHandle.hGpio) { lprintk(D_AUDIO, "%s: NvOdmGpioOpen Error \n", __func__); goto err_open_gpio_fail; } lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - NvOdmGpioOpen() success..!! : s_hHeadsetHandle.hGpio = %d, port[0] = %d, pin[0] = %d\n", s_hHeadsetHandle.hGpio, port[0], pin[0]); //20100421 [email protected] [LGE] s_hHeadsetHandle.h_Headset_Detection = NvOdmGpioAcquirePinHandle(s_hHeadsetHandle.hGpio, port[0], pin[0]); if (!s_hHeadsetHandle.h_Headset_Detection) { lprintk(D_AUDIO, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - NvOdmGpioAcquirePinHandle() success..!!\n"); //20100421 [email protected] [LGE] NvOdmGpioConfig(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection, NvOdmGpioPinMode_InputData/*NvOdmGpioPinMode_InputInterruptHigh*/); lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - NvOdmGpioConfig() success..!! - NvOdmGpioPinMode_InputData"); //20100421 [email protected] [LGE] s_hHeadsetHandle.h_Hookkey_Detection = NvOdmGpioAcquirePinHandle(s_hHeadsetHandle.hGpio, port[1], pin[1]); if (!s_hHeadsetHandle.h_Hookkey_Detection) { lprintk(D_AUDIO, "%s:Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } NvOdmGpioConfig(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection, NvOdmGpioPinMode_InputData); ip_dev = input_allocate_device(); switch_data->ip_dev = ip_dev; set_bit(EV_SYN, switch_data->ip_dev->evbit); set_bit(EV_KEY, switch_data->ip_dev->evbit); set_bit(KEY_HOOK, switch_data->ip_dev->keybit); switch_data->ip_dev->name = "star_headset_hook"; ip_dev_wake = input_allocate_device(); switch_data->ip_dev_wake = ip_dev_wake; set_bit(EV_SYN, switch_data->ip_dev_wake->evbit); set_bit(EV_KEY, switch_data->ip_dev_wake->evbit); set_bit(KEY_VOLUMEDOWN, switch_data->ip_dev_wake->keybit); switch_data->ip_dev_wake->name = "star_headset_wake"; ret = input_register_device(switch_data->ip_dev); INIT_DELAYED_WORK(&switch_data->hook_delayed_work, hook_det_work); if (NvOdmGpioInterruptRegister(s_hHeadsetHandle.hGpio, &s_hHeadsetHandle.hhookInterrupt, s_hHeadsetHandle.h_Hookkey_Detection, NvOdmGpioPinMode_InputInterruptAny, headset_hook_int_handler, switch_data, 0) == NV_FALSE) { lprintk(D_AUDIO, KERN_ERR "%s: cannot register interrupt.\n", __func__); goto err_get_interrupt_handler; } block_hook_int =1; //20101005 [email protected] Gpio MicBias[START_LGE_LAB1] #if defined(STAR_COUNTRY_KR)&& !defined(CONFIG_MACH_STAR_SKT_REV_A) s_hHeadsetHandle.h_Headset_MicBias = NvOdmGpioAcquirePinHandle(s_hHeadsetHandle.hGpio, port[2], pin[2]); if (!s_hHeadsetHandle.h_Headset_MicBias) { lprintk(D_AUDIO, "%s: Couldn't NvOdmGpioAcquirePinHandle pin \n", __func__); goto err_open_gpio_pin_acquire_fail; } lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset MicBias - NvOdmGpioAcquirePinHandle() success..!!\n"); //20100421 [email protected] [LGE] NvOdmGpioConfig(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_MicBias, NvOdmGpioPinMode_Output); lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset MicBias- NvOdmGpioConfig() success..!! - NvOdmGpioPinMode_Output"); //20100421 [email protected] [LGE] #endif //20101005 [email protected] Gpio MicBias[END_LGE_LAB1] INIT_WORK(&switch_data->work, headset_det_work); INIT_DELAYED_WORK(&switch_data->delayed_work, type_det_work); lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - INIT_WORK() & INIT_DELAYED_WORK() success..!!\n"); //20100421 [email protected] [LGE] if (NvOdmGpioInterruptRegister(s_hHeadsetHandle.hGpio, &s_hHeadsetHandle.hheadsetInterrupt, s_hHeadsetHandle.h_Headset_Detection, NvOdmGpioPinMode_InputInterruptAny/*NvOdmGpioPinMode_InputInterruptFallingEdge*//*NvOdmGpioPinMode_InputInterruptRisingEdge*/, headset_int_handler, switch_data, 0) == NV_FALSE) { lprintk(D_AUDIO, KERN_ERR "%s: cannot register interrupt.\n", __func__); goto err_get_interrupt_handler; } lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - NvOdmGpioInterruptRegister() success..!!\n"); //20100421 [email protected] [LGE] //20101125, [email protected], hookkey press is skipped When wakeup from LP1 [START] //wake_lock_init(&hook_det_lock, WAKE_LOCK_SUSPEND, "hook_det_wake"); //20101125, [email protected], hookkey press is skipped When wakeup from LP1 [END] /*====================== nVidia GPIO Control(E) =======================*/ /* Perform initial detection */ headset_sw_data = switch_data; //P990_IFX_GB_PORTING_LGSI_START //FIDO - GB Porting [09/08/2011] - Start #if 1 //defined (STAR_OPERATOR_FIDO) wake_lock_init(&headset_wake_lock, WAKE_LOCK_SUSPEND, "headset_wlock"); //20110425 [email protected] headset wake lock timeout #endif //FIDO - GB Porting [09/08/2011] - End //P990_IFX_GB_PORTING_LGSI_END //headset_det_work(&switch_data->work); lprintk(D_AUDIO, KERN_ERR "##(Headset_det.c)## headset detection - headset_det_work() first detection - success..!!\n"); //20100421 [email protected] [LGE] err = device_create_file(&pdev->dev, &dev_attr_detect); err = device_create_file(&pdev->dev, &dev_attr_block_hook); err = device_create_file(&pdev->dev, &dev_attr_factory_test); return 0; err_open_gpio_fail: switch_dev_unregister(&switch_data->sdev); err_switch_dev_register: kfree(switch_data); err_open_gpio_pin_acquire_fail: NvOdmGpioClose(s_hHeadsetHandle.hGpio); err_get_interrupt_handler: NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Headset_Detection); NvOdmGpioReleasePinHandle(s_hHeadsetHandle.hGpio, s_hHeadsetHandle.h_Hookkey_Detection); //20100421 [email protected] for Hookkey [LGE] return ret; }
/** * @brief Allocates a handle to the device. Configures the PWM * control to the Vibro motor with default values. To change * the amplitude and frequency use NvOdmVibrateSetParameter API. * @param hOdmVibrate [IN] Opaque handle to the device. * @return NV_TRUE on success and NV_FALSE on error */ NvBool NvOdmVibOpen(NvOdmVibDeviceHandle *hOdmVibrate) { #if 1 /* yuyang(20100615):Create I2C handle */ const NvOdmPeripheralConnectivity *pConnectivity = NULL; NvU32 Index = 0; NvU32 I2cInstance = 0; NV_ASSERT(hOdmVibrate); /* Allocate the handle */ (*hOdmVibrate) = (NvOdmVibDeviceHandle)NvOdmOsAlloc(sizeof(NvOdmVibDevice)); if (*hOdmVibrate == NULL) { NV_ODM_TRACE(("Error Allocating NvOdmPmuDevice. \n")); return NV_FALSE; } NvOsMemset((*hOdmVibrate), 0, sizeof(NvOdmVibDevice)); /* Get the PMU handle */ (*hOdmVibrate)->hOdmServicePmuDevice = NvOdmServicesPmuOpen(); if (!(*hOdmVibrate)->hOdmServicePmuDevice) { NV_ODM_TRACE(("Error Opening Pmu device. \n")); NvOdmOsFree(*hOdmVibrate); *hOdmVibrate = NULL; return NV_FALSE; } // Get the peripheral connectivity information pConnectivity = NvOdmPeripheralGetGuid(VIBRATE_DEVICE_GUID); if (pConnectivity == NULL) { NV_ODM_TRACE(("Error pConnectivity NULL. \n")); return NV_FALSE; } for (Index = 0; Index < pConnectivity->NumAddress; ++Index) { switch (pConnectivity->AddressList[Index].Interface) { case NvOdmIoModule_I2c: (*hOdmVibrate)->DeviceAddr = (pConnectivity->AddressList[Index].Address); I2cInstance = pConnectivity->AddressList[Index].Instance; NV_ODM_TRACE("%s: hTouch->DeviceAddr = 0x%x, I2cInstance = %x\n", __func__, (*hOdmVibrate)->DeviceAddr, I2cInstance); break; case NvOdmIoModule_Vdd: (*hOdmVibrate)->VddId = pConnectivity->AddressList[Index].Address; NvOdmServicesPmuGetCapabilities((*hOdmVibrate)->hOdmServicePmuDevice, (*hOdmVibrate)->VddId, &((*hOdmVibrate)->RailCaps)); break; default: break; } } (*hOdmVibrate)->hOdmI2c = NvOdmI2cOpen(NvOdmIoModule_I2c_Pmu, I2cInstance); if (!(*hOdmVibrate)->hOdmI2c) { NV_ODM_TRACE(("NvOdm Touch : NvOdmI2cOpen Error \n")); return NV_FALSE; } #else const NvOdmPeripheralConnectivity *pConnectivity = NULL; NvU32 Index = 0; NV_ASSERT(hOdmVibrate); /* Allocate the handle */ (*hOdmVibrate) = (NvOdmVibDeviceHandle)NvOdmOsAlloc(sizeof(NvOdmVibDevice)); if (*hOdmVibrate == NULL) { NV_ODM_TRACE(("Error Allocating NvOdmPmuDevice. \n")); return NV_FALSE; } NvOsMemset((*hOdmVibrate), 0, sizeof(NvOdmVibDevice)); /* Get the PMU handle */ (*hOdmVibrate)->hOdmServicePmuDevice = NvOdmServicesPmuOpen(); if (!(*hOdmVibrate)->hOdmServicePmuDevice) { NV_ODM_TRACE(("Error Opening Pmu device. \n")); NvOdmOsFree(*hOdmVibrate); *hOdmVibrate = NULL; return NV_FALSE; } // Get the peripheral connectivity information pConnectivity = NvOdmPeripheralGetGuid(VIBRATE_DEVICE_GUID); if (pConnectivity == NULL) return NV_FALSE; // Search for the Vdd rail and set the proper volage to the rail. for (Index = 0; Index < pConnectivity->NumAddress; ++Index) { if (pConnectivity->AddressList[Index].Interface == NvOdmIoModule_Vdd) { (*hOdmVibrate)->VddId = pConnectivity->AddressList[Index].Address; NvOdmServicesPmuGetCapabilities((*hOdmVibrate)->hOdmServicePmuDevice, (*hOdmVibrate)->VddId, &((*hOdmVibrate)->RailCaps)); break; } } #endif /* __yuyang(20100615) */ return NV_TRUE; }
NvBool Adt7461Init(NvOdmTmonDeviceHandle hTmon) { NvU8 Data; NvBool ExtRange; NvU32 i = 0; NvU32 I2cInstance = 0; NvOdmIoModule I2cModule = NvOdmIoModule_Num; // Inavlid module const ADT7461RegisterInfo* pReg = NULL; ADT7461PrivData* pPrivData = NULL; NV_ASSERT(hTmon && hTmon->pConn && hTmon->pConn->AddressList); // Allocate and clear priavte data pPrivData = (ADT7461PrivData*) NvOdmOsAlloc(sizeof(ADT7461PrivData)); if (pPrivData == NULL) { NVODM_ADT7461_PRINTF(("ADT7461: Error Allocating PrivData. \n")); return NV_FALSE; } NvOdmOsMemset(pPrivData, 0, sizeof(ADT7461PrivData)); hTmon->pPrivate = pPrivData; // Register for PMU services pPrivData->hOdmPmuSevice = NvOdmServicesPmuOpen(); if (pPrivData->hOdmPmuSevice == NULL) { NVODM_ADT7461_PRINTF(("ADT7461: Error Open PMU service. \n")); goto fail; } // Register for GPIO services pPrivData->hGpio = NvOdmGpioOpen(); if (pPrivData->hOdmPmuSevice == NULL) { NVODM_ADT7461_PRINTF(("ADT7461: Error Open GPIO service. \n")); goto fail; } /* * Parse connectivity data: turn On power to the device, acquire I2C * interface and GPIO interrupt (optional); map device channels to * thermal zones */ for (i = 0; i < hTmon->pConn->NumAddress; i ++) { const NvOdmIoAddress* pIoAddress = &hTmon->pConn->AddressList[i]; if (pIoAddress->Interface == NvOdmIoModule_I2c_Pmu) { I2cModule = NvOdmIoModule_I2c_Pmu; I2cInstance = pIoAddress->Instance; NV_ASSERT(pIoAddress->Address != 0); pPrivData->DeviceI2cAddr = pIoAddress->Address; } else if (pIoAddress->Interface == NvOdmIoModule_Tsense) { NV_ASSERT(pIoAddress->Instance < NvOdmTmonZoneID_Num); NV_ASSERT(pIoAddress->Address < ADT7461ChannelID_Num); pPrivData->ConnectivityMap[pIoAddress->Instance] = pIoAddress->Address; } else if (pIoAddress->Interface == NvOdmIoModule_Vdd) { NvU32 usec = 0; NvU32 RailAddress = pIoAddress->Address; NvOdmServicesPmuVddRailCapabilities RailCapabilities; NvOdmServicesPmuGetCapabilities( pPrivData->hOdmPmuSevice, RailAddress, &RailCapabilities); NvOdmServicesPmuSetVoltage(pPrivData->hOdmPmuSevice, RailAddress, RailCapabilities.requestMilliVolts, &usec); NvOdmOsWaitUS(usec + (ADT7461_POWERUP_DELAY_MS * 1000)); } else if (pIoAddress->Interface == NvOdmIoModule_Gpio) { NvU32 port = pIoAddress->Instance; NvU32 pin = pIoAddress->Address; pPrivData->hGpioPin = NvOdmGpioAcquirePinHandle( pPrivData->hGpio, port, pin); } } NV_ASSERT(I2cModule == NvOdmIoModule_I2c_Pmu); pPrivData->hOdmI2C = NvOdmI2cOpen(I2cModule, I2cInstance); if (pPrivData->hOdmI2C == NULL) { NVODM_ADT7461_PRINTF(("ADT7461: Error Open I2C device. \n")); goto fail; } /* * Initialize device info and configuration. Force standby mode to avoid * glitch on shutdown comparator output when temperature range and/or * comparator limit is changing during initialization. The Adt7461Run() * call from the hal that follows initialization will switch device to * run mode and re-start temperature monitoring (note that out of limit * interrupt is always masked during and after initialization) */ pPrivData->pDeviceInfo = &s_Adt7461Info; pPrivData->ShadowRegPtr = ADT7461_INVALID_ADDR; pReg = &pPrivData->pDeviceInfo->Config; if (!Adt7461ReadReg(pPrivData, pReg, &Data)) goto fail; if ((Data & ADT7461ConfigBits_ExtendedRange) != (ADT7461_INITIAL_CONFIG & ADT7461ConfigBits_ExtendedRange)) { // Only switch from standard to extended range is supported NV_ASSERT((Data & ADT7461ConfigBits_ExtendedRange) == 0); Data |= ADT7461ConfigBits_Standby; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; } Data = ADT7461_INITIAL_CONFIG | ADT7461ConfigBits_Standby; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; pPrivData->ShadowConfig = Data; #if PRE_ER_GMT_THERMALSENSOR ExtRange = 0; /* not support ADT thermal sensor*/ #else ExtRange = ((Data & ADT7461ConfigBits_ExtendedRange) != 0); #endif // Program shutdown comparators settings Data = ADT7461_T_VALUE_TO_DATA( ExtRange, ADT7461_ODM_LOCAL_COMPARATOR_LIMIT_VALUE); pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Local].ComparatorLimit; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; Data = ADT7461_T_VALUE_TO_DATA( ExtRange, ADT7461_ODM_REMOTE_COMPARATOR_LIMIT_VALUE); pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Remote].ComparatorLimit; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; // Set interrupt limits to the range boundaries to prevent out of limit // interrupt Data = ADT7461_T_VALUE_TO_DATA( ExtRange, ADT7461_T_RANGE_LIMIT_HIGH(ExtRange)); pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Local].IntrLimitHigh; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Remote].IntrLimitHigh; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; Data = ADT7461_T_VALUE_TO_DATA( ExtRange, ADT7461_T_RANGE_LIMIT_LOW(ExtRange)); pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Local].IntrLimitLow; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Remote].IntrLimitLow; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; // Set initial rate Data = ADT7461_INITIAL_RATE_SETTING; pReg = &pPrivData->pDeviceInfo->Rate; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; pPrivData->ShadowRate = Data; // Set remote channel offset (8-bit 2's complement value for any range) Data = ((NvU8)ADT7461_ODM_REMOTE_OFFSET_VALUE); pReg = &pPrivData->pDeviceInfo->Channels[ ADT7461ChannelID_Remote].Toffset; if(!Adt7461WriteReg(pPrivData, pReg, Data)) goto fail; // Read ADT7461 status and ARA (clear pending Alert interrupt, if any) pReg = &pPrivData->pDeviceInfo->Status; if (!Adt7461ReadReg(pPrivData, pReg, &Data)) goto fail; // TODO: check open remote circuit error Adt7461ReadAra(pPrivData); return NV_TRUE; fail: Adt7461FreePrivData(pPrivData); hTmon->pPrivate = NULL; return NV_FALSE; }
int __devinit tegra_sdhci_simple_probe(struct platform_device *pdev) { struct tegra_sdhci_simple *host; struct tegra_sdhci_simple_platform_data *pdata = pdev->dev.platform_data; NvOdmPeripheralConnectivity *pConn; NvU32 NumOfGuids = 1; NvU64 guid; NvU32 searchVals[4]; const NvOdmPeripheralSearch searchAttrs[] = { NvOdmPeripheralSearch_PeripheralClass, NvOdmPeripheralSearch_IoModule, NvOdmPeripheralSearch_Instance, NvOdmPeripheralSearch_Address, }; int i, ret = -ENODEV; pr_info("%s", __func__); if (pdev->id == -1) { dev_err(&pdev->dev, "dynamic instance assignment not allowed\n"); return -ENODEV; } host = &tegra_sdhci_simple_host; /* * Emulate NvOdmSdioOpen() to avoid heap usage and power on request */ searchVals[0] = NvOdmPeripheralClass_Other; searchVals[1] = NvOdmIoModule_Sdio; searchVals[2] = pdev->id; searchVals[3] = 0; NumOfGuids = NvOdmPeripheralEnumerate(searchAttrs, searchVals, 4, &guid, NumOfGuids); pConn = (NvOdmPeripheralConnectivity*)NvOdmPeripheralGetGuid(guid); if (pConn == NULL) goto err_odm; for (i = 0; i < pConn->NumAddress; i++) { if (pConn->AddressList[i].Interface == NvOdmIoModule_Vdd) { host->VddAddress = pConn->AddressList[i].Address; NvOdmServicesPmuGetCapabilities(host->hPmu, host->VddAddress, &host->VddRailCaps); } } host->hPmu = NvOdmServicesPmuOpen(); if (host->hPmu == NULL) { pr_err("%s: failed to open PMU\n", __func__); goto err_odm; } for (i = 0; i < pdata->num_resources; i++) { if (pdata->resource && pdata->resource[i].flags & IORESOURCE_MEM && pdata->resource[i].end - pdata->resource[i].start > 0) break; } if (i >= pdata->num_resources) { dev_err(&pdev->dev, "no memory I/O resource provided\n"); ret = -ENODEV; goto err_odm; } host->ioaddr = ioremap(pdata->resource[i].start, pdata->resource[i].end - pdata->resource[i].start + 1); host->clk = clk_get_sys(pdata->clk_dev_name, NULL); if (!host->clk) { dev_err(&pdev->dev, "unable to get clock %s\n", pdata->clk_dev_name); ret = -ENODEV; goto err_ioremap; } host->pdev = pdev; host->pinmux = pdata->sdhci_pdata->pinmux; host->nr_pins = pdata->sdhci_pdata->nr_pins; if (pdata->sdhci_pdata->max_clk) host->max_clk = min_t(unsigned int, 52000000, pdata->sdhci_pdata->max_clk); else {