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; }
/** * @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 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 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 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 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 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); } } } } }
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; }
/** * @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) { /** * yuyang(20100801) * ER vibration behavior is opposite to PR */ #if 1 int rv; if (Vib_mode) /* ER board */ { rv = I2C_Write(hOdmVibrate, TPS6586x_R5B_PWM, 0xFF); }else{ /* PR board */ rv = I2C_Write(hOdmVibrate, TPS6586x_R5B_PWM, 0x00); } if (rv != NV_TRUE) NV_ODM_TRACE(("Vibrator off: failed!\n")); #else NvU32 SettlingTime; NV_ASSERT(hOdmVibrate); if (!hOdmVibrate) { return NV_FALSE; } 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 /* __yuyang(20100801) */ return NV_TRUE; }
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; }
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 ssize_t star_pmic_store(struct device *dev, struct device_attribute *attr, char *buf, size_t count) { u32 val = 0; val = simple_strtoul(buf, NULL, 10); if(val){ NvOdmPeripheralConnectivity const *conn = NULL; NvOdmServicesPmuHandle hPmu; conn = NvOdmPeripheralGetGuid( NV_ODM_GUID('p','m','_','r','e','s','e','t') ); hPmu = NvOdmServicesPmuOpen(); if(!conn){ printk("ERROR : invalid GUID\n"); sprintf(buf, "PMIC reset fail\n"); return (ssize_t)(strlen(buf) + 1); } if( conn->AddressList[0].Interface == NvOdmIoModule_Vdd ) { NvU32 settle_us; /* set the rail volatage to the recommended */ NvOdmServicesPmuSetVoltage( hPmu, conn->AddressList[0].Address, NVODM_VOLTAGE_OFF, &settle_us ); /* wait for rail to settle */ NvOdmOsWaitUS( settle_us ); } NvOdmServicesPmuClose(hPmu); } sprintf(buf, "PMIC reset\n"); printk("PMIC reset\n"); return (ssize_t)(strlen(buf) + 1); }
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; }
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; }
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 NvBool Pcf50626AdcIn1Read(NvOdmPmuDeviceHandle hDevice, NvU32 *volt) { NvU32 timeout = 0; NvU8 dataS1 = 0; NvU8 dataS3 = 0; NV_ASSERT(hDevice); NV_ASSERT(volt); // Turn off GPIO7 if(! Pcf50626I2cWrite8(hDevice, PCF50626_GPIO7C1_ADDR, 0x0)) return NV_FALSE; //ADCC3 - Division sel if(! Pcf50626I2cWrite8(hDevice, PCF50626_ADCC3_ADDR, PCF50626_ADCC3_RESET)) return NV_FALSE; //ADCC1 - Resolustion, Mux Sel, Avg sel if(! Pcf50626I2cWrite8(hDevice, PCF50626_ADCC1_ADDR, 0x0C)) return NV_FALSE; // Start Converstion if(! Pcf50626I2cWrite8(hDevice, PCF50626_ADCC1_ADDR, 0x0D)) return NV_FALSE; // Wait for conversion NvOdmOsWaitUS(ADC_CONVERSION_DELAY_USEC); // make sure the conversion is completed, or timeout. while (timeout < ADC_CONVERSION_TIMEOUT_USEC) { if(! Pcf50626I2cRead8(hDevice, PCF50626_ADCS3_ADDR, &dataS3)) return NV_FALSE; if (dataS3 & 0x80) break; NvOdmOsWaitUS(ADC_CONVERSION_DELAY_USEC); timeout += ADC_CONVERSION_DELAY_USEC; } if (timeout >= ADC_CONVERSION_TIMEOUT_USEC) { NVODMPMU_PRINTF(("ADC conversion timeout.\n")); return NV_FALSE; } // read the conversion result if (!Pcf50626I2cRead8(hDevice, PCF50626_ADCS1_ADDR, &dataS1)) return NV_FALSE; // Get result *volt = (((NvU32)((dataS1 << 2) | (dataS3 & 0x03))) * ADC_CONVERSION_VOLTAGE_RANGE * ADC_CONVERSION_DIVIDOR) >> ADC_CONVERSION_PRECISION; return NV_TRUE; }