static int pmic_get(void *data, u64 *val)
{
const NvOdmPeripheralConnectivity *con = NULL;
int ldo_number;
NvU32 millivolts;
struct pmic_struct *pmic_info = data;
ldo_number = pmic_info->ldo_number;
con = NvOdmPeripheralGetGuid(NV_ODM_GUID('a','l','l','p','o','w','e','r'));
if (con == NULL){
*val = 9999;
printk("PMIC(debugfs) : query ERROR\n");
return 0;
}
NvRmPmuGetVoltage(s_hRmGlobal,
con->AddressList[ldo_number].Address, &millivolts);
if(millivolts){
*val = 1;
printk("PMIC(debugfs) : LDO%d (on)\n",
ldo_number+1);
}else{
*val = 0;
printk("PMIC(debugfs) : LDO%d (off)\n",
ldo_number+1);
}
return 0;
}
static void __init register_spi_ipc_devices(void)
{
unsigned long instance = 0xFFFF;
unsigned long cs = 0xFFFF;
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
int i;
pConnectivity =
NvOdmPeripheralGetGuid(NV_ODM_GUID('s','p','i',' ','_','i','p','c'));
if (!pConnectivity)
return;
for (i = 0; i < pConnectivity->NumAddress; i++) {
switch (pConnectivity->AddressList[i].Interface) {
case NvOdmIoModule_Spi:
instance = pConnectivity->AddressList[i].Instance;
cs = pConnectivity->AddressList[i].Address;
break;
default:
break;
}
}
if (instance == 0xffff || cs == 0xffff) {
pr_err("%s: SPI IPC Protocol driver: Instance and CS are Invalid\n", __func__);
return;
}
tegra_spi_ipc_devices[0].bus_num = instance;
tegra_spi_ipc_devices[0].chip_select = cs;
if (spi_register_board_info(tegra_spi_ipc_devices, ARRAY_SIZE(tegra_spi_ipc_devices)) != 0) {
pr_err("%s: spi_register_board_info returned error\n", __func__);
}
}
NvBool NvOdmEcompassOpen(NvOdmEcompassHandle* hDevice)
{
NvU32 i;
NvOdmEcompassHandle hEcompass;
NvOdmIoModule IoModule = NvOdmIoModule_I2c;
const NvOdmPeripheralConnectivity *pConnectivity;
NvBool FoundGpio = NV_FALSE, FoundI2cModule = NV_FALSE;
hEcompass = NvOdmOsAlloc(sizeof(NvOdmEcompass));
if (hEcompass == NULL)
{
NVODMECOMPASS_PRINTF(("AKM8975 compass driver: Open fail\n"));
return NV_FALSE;
}
NvOdmOsMemset(hEcompass,0,sizeof(NvOdmEcompass));
hEcompass->nBusType = NV_ECOMPASS_BUS_I2C;
// Info of ecompass with current setting
pConnectivity = (NvOdmPeripheralConnectivity*)NvOdmPeripheralGetGuid(
ECOMPASS_GUID);
if (!pConnectivity)
{
NvOdmOsDebugPrintf(("NvOdmPeripheralGetGuid doesn't detect\
AKM8975/B device\n"));
goto error;
}
void
NvRmPrivPmuRailControl(
NvRmDeviceHandle hRmDevice,
NvU64 NvRailId,
NvBool TurnOn)
{
NvU32 RailAddress, TimeUs;
const NvOdmPeripheralConnectivity* pPmuRail;
NvRmPmuVddRailCapabilities RailCapabilities = {0};
if (!s_PmuSupportedEnv)
return;
pPmuRail = NvOdmPeripheralGetGuid(NvRailId);
NV_ASSERT(hRmDevice);
NV_ASSERT(pPmuRail);
NV_ASSERT(pPmuRail->NumAddress);
RailAddress = pPmuRail->AddressList[0].Address;
if (TurnOn)
{
NvRmPmuGetCapabilities(hRmDevice, RailAddress, &RailCapabilities);
NvRmPmuSetVoltage(hRmDevice, RailAddress,
RailCapabilities.requestMilliVolts, &TimeUs);
}
else
{
NvRmPmuSetVoltage(
hRmDevice, RailAddress, ODM_VOLTAGE_OFF, &TimeUs);
}
NvOsWaitUS(TimeUs);
}
void NvRmPrivIoPowerControlInit(NvRmDeviceHandle hRmDeviceHandle)
{
NvU32 i, v;
NvU32 NoIoPwrMask = 0;
const NvOdmPeripheralConnectivity* pPmuRail = NULL;
if (NvRmPrivGetExecPlatform(hRmDeviceHandle) != ExecPlatform_Soc)
{
// Invalidate IO Power detect map if not SoC platform
for (i = 0; i < NV_ARRAY_SIZE(s_IoPowerDetectMap); i++)
s_IoPowerDetectMap[i].PmuRailAddress = NV_RAIL_ADDR_INVALID;
return;
}
for (i = 0; i < NV_ARRAY_SIZE(s_IoPowerDetectMap); i++)
{
// Fill in PMU rail addresses in IO Power detect map
pPmuRail = NvOdmPeripheralGetGuid(s_IoPowerDetectMap[i].PowerRailId);
NV_ASSERT(pPmuRail && pPmuRail->NumAddress);
s_IoPowerDetectMap[i].PmuRailAddress = pPmuRail->AddressList[0].Address;
// Find all unpowered rails
v = NvRmPrivPmuRailGetVoltage(
hRmDeviceHandle, s_IoPowerDetectMap[i].PowerRailId);
if (v == ODM_VOLTAGE_OFF)
NoIoPwrMask |= s_IoPowerDetectMap[i].DisableRailMask;
}
// Latch already powered IO rails
NvRmPrivIoPowerDetectLatch(hRmDeviceHandle);
// Disable IO pads for unpowered rails
if (NoIoPwrMask)
NvRmPrivIoPowerControl(hRmDeviceHandle, NoIoPwrMask, NV_FALSE);
}
static void UsbPrivEnableVbus(NvDdkUsbPhy *pUsbPhy, NvBool Enable)
{
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
NvRmPmuVddRailCapabilities RailCaps;
NvU32 i;
switch (pUsbPhy->Instance)
{
case 0:
pConnectivity = NvOdmPeripheralGetGuid(NV_VDD_VBUS_ODM_ID);
break;
case 1:
pConnectivity = NvOdmPeripheralGetGuid(NV_VDD_USB2_VBUS_ODM_ID);
break;
case 2:
pConnectivity = NvOdmPeripheralGetGuid(NV_VDD_USB3_VBUS_ODM_ID);
break;
default:
break;
}
if (pConnectivity != NULL)
{
for (i = 0; i < pConnectivity->NumAddress; i++)
{
// Search for the vdd rail entry
if (pConnectivity->AddressList[i].Interface == NvOdmIoModule_Vdd)
{
NvRmPmuGetCapabilities(pUsbPhy->hRmDevice,
pConnectivity->AddressList[i].Address, &RailCaps);
if (Enable)
{
NvRmPmuSetVoltage(pUsbPhy->hRmDevice,
pConnectivity->AddressList[i].Address, RailCaps.requestMilliVolts, NULL);
}
else
{
NvRmPmuSetVoltage(pUsbPhy->hRmDevice,
pConnectivity->AddressList[i].Address, ODM_VOLTAGE_OFF, NULL);
}
}
}
}
}
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;
}
NvOdmUartHandle NvOdmUartOpen(NvU32 Instance)
{
NvOdmUart *pDevice = NULL;
NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[2];
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
};
searchVals[0] = NvOdmIoModule_Uart;
searchVals[1] = Instance;
NumOfGuids = NvOdmPeripheralEnumerate(
searchAttrs,
searchVals,
2,
&guid,
NumOfGuids);
pConnectivity = (NvOdmPeripheralConnectivity *)NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
goto ExitUartOdm;
pDevice = NvOdmOsAlloc(sizeof(NvOdmUart));
if(pDevice == NULL)
goto ExitUartOdm;
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
goto ExitUartOdm;
}
// Switch On UART Interface
pDevice->pConnectivity = pConnectivity;
return pDevice;
ExitUartOdm:
NvOdmOsFree(pDevice);
pDevice = NULL;
return NULL;
}
NvBool NvOdmVibStart(NvOdmVibDeviceHandle hDevice)
{
NvOdmPeripheralConnectivity const *conn;
NvU64 guid;
/* get the main panel */
guid = VIBRATOR_GUID;
/* get the connectivity info */
conn = NvOdmPeripheralGetGuid(guid);
if(conn == NULL)
{
return NV_FALSE;
}
/* acquire GPIO pins */
ghGpio = NvOdmGpioOpen();
if (ghGpio == NULL)
{
return NV_FALSE;
}
if (ghVibGpioPin == NULL)
{
/* Search for the GPIO pin */
if (conn->AddressList[0].Interface == NvOdmIoModule_Gpio)
{
ghVibGpioPin = NvOdmGpioAcquirePinHandle(ghGpio,
conn->AddressList[0].Instance,
conn->AddressList[0].Address);
}
}
if (ghVibGpioPin == NULL)
{
return NV_FALSE;
}
NvOdmGpioSetState(ghGpio, ghVibGpioPin, 0x1);
NvOdmGpioConfig(ghGpio, ghVibGpioPin, NvOdmGpioPinMode_Output);
VIBE_TPS658620_I2cWrite8(TPS658620_PWM1_ADDR, hDevice->CurrentIndex);
return NV_TRUE;
}
NvU32
NvRmPrivPmuRailGetVoltage(
NvRmDeviceHandle hRmDevice,
NvU64 NvRailId)
{
NvU32 RailAddress;
const NvOdmPeripheralConnectivity* pPmuRail;
NvU32 MilliVolts = NVRM_NO_PMU_DEFAULT_VOLTAGE;
if (s_PmuSupportedEnv)
{
pPmuRail = NvOdmPeripheralGetGuid(NvRailId);
NV_ASSERT(hRmDevice);
NV_ASSERT(pPmuRail);
NV_ASSERT(pPmuRail->NumAddress);
RailAddress = pPmuRail->AddressList[0].Address;
NvRmPmuGetVoltage(hRmDevice, RailAddress, &MilliVolts);
}
return MilliVolts;
}
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);
}
void NvRmPrivPmuLPxStateConfig(
NvRmDeviceHandle hRmDevice,
NvOdmSocPowerState state,
NvBool enter)
{
NvOdmPmuProperty PmuProperty = {0};
NvBool HasPmuProperty = NvOdmQueryGetPmuProperty(&PmuProperty);
const NvOdmPeripheralConnectivity* pCoreRail =
NvOdmPeripheralGetGuid(NV_VDD_CORE_ODM_ID);
NV_ASSERT(hRmDevice);
NV_ASSERT(pCoreRail);
NV_ASSERT(pCoreRail->NumAddress);
// On platforms with combined cpu/core power request core power rail
// should be controlled by the combined request only during deep sleep
// - enable the On/Off control on entry, and disable on exit
if (state == NvOdmSocPowerState_DeepSleep)
{
// : AP20 need USB power work around
#if defined(CONFIG_MACH_STAR)
if (HasPmuProperty)
#else
if (HasPmuProperty && PmuProperty.CombinedPowerReq)
#endif
{
NvU32 level = enter ?
ODM_VOLTAGE_ENABLE_EXT_ONOFF : ODM_VOLTAGE_DISABLE_EXT_ONOFF;
NvRmPmuSetVoltage(hRmDevice, pCoreRail->AddressList[0].Address,
level, NULL);
}
}
// Mask/Unmask PMU interrupt on entry/exit to/from suspend or deep sleep
if ((state == NvOdmSocPowerState_Suspend) ||
(state == NvOdmSocPowerState_DeepSleep))
NvRmPrivPmuInterruptMask(hRmDevice, enter);
}
NvOdmSdioHandle NvOdmSdioOpen(NvU32 Instance)
{
static NvOdmSdio *pDevice = NULL;
NvOdmServicesGpioHandle hGpioTemp = NULL;
const NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[2];
const NvU32 *pOdmConfigs;
NvU32 NumOdmConfigs;
NvBool Status = NV_TRUE;
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
};
searchVals[0] = NvOdmIoModule_Sdio;
searchVals[1] = Instance;
NvOdmQueryPinMux(NvOdmIoModule_Sdio, &pOdmConfigs, &NumOdmConfigs);
if (Instance >= NumOdmConfigs )
return NULL;
if( pOdmConfigs[Instance] == 0 )
return NULL;
NumOfGuids = NvOdmPeripheralEnumerate(searchAttrs, searchVals,
2, &guid, NumOfGuids);
// Get the peripheral connectivity information
pConnectivity = NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
return NULL;
pDevice = NvOdmOsAlloc(sizeof(NvOdmSdio));
pDevice->hPmu = NULL;
if(pDevice == NULL)
return (pDevice);
if (pDevice->hPmu == NULL)
{
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (NULL);
}
}
pDevice->pConnectivity = pConnectivity;
NvOdmSetPowerOnSdio(pDevice, NV_TRUE);
if (pConnectivity->Guid == WLAN_GUID)
{
// Getting the OdmGpio Handle
hGpioTemp = NvOdmGpioOpen();
if (hGpioTemp == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
// Search for the Vdd rail and set the proper volage to the rail.
if (pConnectivity->AddressList[1].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Power Pin
pDevice->hPwrPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[1].Instance,
pConnectivity->AddressList[1].Address);
}
if (pConnectivity->AddressList[2].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Reset Pin
pDevice->hResetPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[2].Instance,
pConnectivity->AddressList[2].Address);
}
// Setting the ON/OFF pin to output mode.
NvOdmGpioConfig(hGpioTemp, pDevice->hPwrPin, NvOdmGpioPinMode_Output);
NvOdmGpioConfig(hGpioTemp, pDevice->hResetPin, NvOdmGpioPinMode_Output);
// Setting the Output Pin to Low
NvOdmGpioSetState(hGpioTemp, pDevice->hPwrPin, 0x0);
NvOdmGpioSetState(hGpioTemp, pDevice->hResetPin, 0x0);
pDevice->hGpio = hGpioTemp;
Status = SdioOdmWlanPower(pDevice, NV_TRUE);
if (Status != NV_TRUE)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
}
pDevice->PoweredOn = NV_TRUE;
pDevice->Instance = Instance;
return pDevice;
}
NvOdmSdioHandle NvOdmSdioOpen(NvU32 Instance)
{
static NvOdmSdio *pDevice = NULL;
NvOdmServicesGpioHandle hGpioTemp = NULL;
NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[2];
const NvU32 *pOdmConfigs;
NvU32 NumOdmConfigs;
NvBool Status = NV_TRUE;
NvU32 DutyCycle;
NvU32 gRequestedFreqHzOrPeriod;
NvU32 ReturnedFreq;
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
};
searchVals[0] = NvOdmIoModule_Sdio;
searchVals[1] = Instance;
NvOdmQueryPinMux(NvOdmIoModule_Sdio, &pOdmConfigs, &NumOdmConfigs);
if (Instance >= NumOdmConfigs )
return NULL;
if( pOdmConfigs[Instance] == 0 )
return NULL;
NumOfGuids = NvOdmPeripheralEnumerate(
searchAttrs,
searchVals,
2,
&guid,
NumOfGuids);
// Get the peripheral connectivity information
pConnectivity = (NvOdmPeripheralConnectivity *)NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
return NULL;
pDevice = NvOdmOsAlloc(sizeof(NvOdmSdio));
pDevice->hPmu = NULL;
if(pDevice == NULL)
return (pDevice);
if (pDevice->hPmu == NULL)
{
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (NULL);
}
}
pDevice->pConnectivity = pConnectivity;
NvOdmSetPowerOnSdio(pDevice, NV_TRUE);
if (pConnectivity->Guid == WLAN_GUID)
{
// Getting the OdmGpio Handle
hGpioTemp = NvOdmGpioOpen();
if (hGpioTemp == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
// Search for the Vdd rail and set the proper volage to the rail.
/*
if (pConnectivity->AddressList[1].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Power Pin
pDevice->hPwrPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[1].Instance,
pConnectivity->AddressList[1].Address);
}
*/// Sam ---
if (pConnectivity->AddressList[2].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Reset Pin
pDevice->hResetPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[2].Instance,
pConnectivity->AddressList[2].Address);
}
// Setting the ON/OFF pin to output mode.
//NvOdmGpioConfig(hGpioTemp, pDevice->hPwrPin, NvOdmGpioPinMode_Output);// Sam ---
NvOdmGpioConfig(hGpioTemp, pDevice->hResetPin, NvOdmGpioPinMode_Output);
// Setting the Output Pin to Low
//NvOdmGpioSetState(hGpioTemp, pDevice->hPwrPin, 0x0); //Sam ---
NvOdmGpioSetState(hGpioTemp, pDevice->hResetPin, 0x0);
pDevice->hGpio = hGpioTemp;
s_hOdmPwm = NvOdmPwmOpen();
gRequestedFreqHzOrPeriod = 32000; //32KHz
DutyCycle = 3211264;
NvOdmPwmConfig(s_hOdmPwm, NvOdmPwmOutputId_Blink, NvOdmPwmMode_Blink_32KHzClockOutput,
DutyCycle, &gRequestedFreqHzOrPeriod, &ReturnedFreq);
Status = SdioOdmWlanSetPowerOn(pDevice, NV_TRUE);
if (Status != NV_TRUE)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
}
pDevice->PoweredOn = NV_TRUE;
pDevice->Instance = Instance;
NV_DRIVER_TRACE(("Open SDIO%d", Instance));
return pDevice;
}
/**
* @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;
}
NvOdmSdioHandle NvOdmSdioOpen(NvU32 Instance)
{
static NvOdmSdio *pDevice = NULL;
NvOdmServicesGpioHandle hGpioTemp = NULL;
NvOdmPeripheralConnectivity *pConnectivity;
NvU32 NumOfGuids = 1;
NvU64 guid;
NvU32 searchVals[4];
const NvU32 *pOdmConfigs;
NvU32 NumOdmConfigs;
NvBool Status = NV_TRUE;
const NvOdmPeripheralSearch searchAttrs[] =
{
NvOdmPeripheralSearch_PeripheralClass,
NvOdmPeripheralSearch_IoModule,
NvOdmPeripheralSearch_Instance,
NvOdmPeripheralSearch_Address,
};
NvOdmBoardInfo BoardInfo;
NvBool status = NV_FALSE;
searchVals[0] = NvOdmPeripheralClass_Other;
searchVals[1] = NvOdmIoModule_Sdio;
searchVals[2] = Instance;
NvOdmQueryPinMux(NvOdmIoModule_Sdio, &pOdmConfigs, &NumOdmConfigs);
if ((Instance == 0) && (pOdmConfigs[0] == NvOdmSdioPinMap_Config1))
{
// sdio is connected to sdio2 slot.
searchVals[3] = NvOdmSdioDiscoveryAddress_1;
}
else
{
// sdio is connected to wifi module.
searchVals[3] = NvOdmSdioDiscoveryAddress_0;
}
NumOfGuids = NvOdmPeripheralEnumerate(searchAttrs,
searchVals,
4,
&guid,
NumOfGuids);
// Get the peripheral connectivity information
pConnectivity = (NvOdmPeripheralConnectivity *)NvOdmPeripheralGetGuid(guid);
if (pConnectivity == NULL)
return NULL;
pDevice = NvOdmOsAlloc(sizeof(NvOdmSdio));
if(pDevice == NULL)
return (pDevice);
pDevice->hPmu = NvOdmServicesPmuOpen();
if(pDevice->hPmu == NULL)
{
NvOdmOsFree(pDevice);
pDevice = NULL;
return (NULL);
}
if (pConnectivity->Guid == WLAN_GUID)
{
// WARNING: This function *cannot* be called before RmOpen().
status = NvOdmPeripheralGetBoardInfo((BOARD_ID_E951), &BoardInfo);
if (NV_TRUE != status)
{
// whistler should have E951 Module, if it is not presnt return NULL Handle.
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmOsFree(pDevice);
pDevice = NULL;
NvOdmOsDebugPrintf(("No E951 Detected"));
return (pDevice);
}
}
pDevice->pConnectivity = pConnectivity;
NvOdmSetPowerOnSdio(pDevice, NV_TRUE);
if (pConnectivity->Guid == WLAN_GUID)
{
// Getting the OdmGpio Handle
hGpioTemp = NvOdmGpioOpen();
if (hGpioTemp == NULL)
{
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
// Search for the Vdd rail and set the proper volage to the rail.
if (pConnectivity->AddressList[1].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Power Pin
pDevice->hPwrPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[1].Instance,
pConnectivity->AddressList[1].Address);
}
if (pConnectivity->AddressList[2].Interface == NvOdmIoModule_Gpio)
{
// Acquiring Pin Handles for Reset Pin
pDevice->hResetPin= NvOdmGpioAcquirePinHandle(hGpioTemp,
pConnectivity->AddressList[2].Instance,
pConnectivity->AddressList[2].Address);
}
// Setting the ON/OFF pin to output mode.
NvOdmGpioConfig(hGpioTemp, pDevice->hPwrPin, NvOdmGpioPinMode_Output);
NvOdmGpioConfig(hGpioTemp, pDevice->hResetPin, NvOdmGpioPinMode_Output);
// Setting the Output Pin to Low
NvOdmGpioSetState(hGpioTemp, pDevice->hPwrPin, 0x0);
NvOdmGpioSetState(hGpioTemp, pDevice->hResetPin, 0x0);
pDevice->hGpio = hGpioTemp;
Status = SdioOdmWlanSetPowerOn(pDevice, NV_TRUE);
if (Status != NV_TRUE)
{
NvOdmServicesPmuClose(pDevice->hPmu);
NvOdmGpioReleasePinHandle(pDevice->hGpio, pDevice->hPwrPin);
NvOdmGpioReleasePinHandle(pDevice->hGpio, pDevice->hResetPin);
NvOdmGpioClose(pDevice->hGpio);
NvOdmOsFree(pDevice);
pDevice = NULL;
return (pDevice);
}
}
pDevice->PoweredOn = NV_TRUE;
pDevice->Instance = Instance;
NV_DRIVER_TRACE(("Open SDIO%d", Instance));
return pDevice;
}
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 {
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;
}
NvBool EETI_Open (NvOdmTouchDeviceHandle* hDevice) {
EETI_TouchDevice* hTouch;
NvU32 i;
NvU32 found = 0;
NvU32 GpioPort = 0;
NvU32 GpioPin = 0;
NvU32 I2cInstance = 0;
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
hTouch = NvOdmOsAlloc(sizeof(EETI_TouchDevice));
if (!hTouch) return NV_FALSE;
NvOdmOsMemset(hTouch, 0, sizeof(EETI_TouchDevice));
NvOdmOsMemset(tempReport, 0, sizeof(struct fingerReport_s) * 4);
/* set function pointers */
InitOdmTouch(&hTouch->OdmTouch);
pConnectivity = NvOdmPeripheralGetGuid(EETI_TOUCH_DEVICE_GUID);
if (!pConnectivity) {
NVODMTOUCH_PRINTF(("NvOdm Touch : pConnectivity is NULL Error \n"));
goto fail;
}
if (pConnectivity->Class != NvOdmPeripheralClass_HCI) {
NVODMTOUCH_PRINTF(("NvOdm Touch : didn't find any periperal in discovery query for touch device Error \n"));
goto fail;
}
for (i = 0; i < pConnectivity->NumAddress; i++) {
switch (pConnectivity->AddressList[i].Interface) {
case NvOdmIoModule_I2c:
hTouch->DeviceAddr = (pConnectivity->AddressList[i].Address << 1);
I2cInstance = pConnectivity->AddressList[i].Instance;
found |= 1;
break;
case NvOdmIoModule_Gpio:
GpioPort = pConnectivity->AddressList[i].Instance;
GpioPin = pConnectivity->AddressList[i].Address;
found |= 2;
break;
case NvOdmIoModule_Vdd:
hTouch->VddId = pConnectivity->AddressList[i].Address;
found |= 4;
break;
default:
break;
}
}
if ((found & 3) != 3) {
NVODMTOUCH_PRINTF(("NvOdm Touch : peripheral connectivity problem \n"));
goto fail;
}
if ((found & 4) != 0) {
if (NV_FALSE == EETI_PowerOnOff(&hTouch->OdmTouch, 1))
goto fail;
} else {
hTouch->VddId = 0xFF;
}
hTouch->hOdmI2c = NvOdmI2cOpen(NvOdmIoModule_I2c, I2cInstance);
if (!hTouch->hOdmI2c) {
NVODMTOUCH_PRINTF(("NvOdm Touch : NvOdmI2cOpen Error \n"));
goto fail;
}
hTouch->hGpio = NvOdmGpioOpen();
if (!hTouch->hGpio) {
NVODMTOUCH_PRINTF(("NvOdm Touch : NvOdmGpioOpen Error \n"));
goto fail;
}
hTouch->hPin = NvOdmGpioAcquirePinHandle(hTouch->hGpio, GpioPort, GpioPin);
if (!hTouch->hPin) {
NVODMTOUCH_PRINTF(("NvOdm Touch : Couldn't get GPIO pin \n"));
goto fail;
}
NvOdmGpioConfig(hTouch->hGpio,
hTouch->hPin,
NvOdmGpioPinMode_InputData);
NvOdmGpioGetState(hTouch->hGpio, hTouch->hPin, &i);
/* set default capabilities */
NvOdmOsMemcpy(&hTouch->Caps, &EETI_Capabilities, sizeof(NvOdmTouchCapabilities));
/* set default I2C speed */
hTouch->I2cClockSpeedKHz = EETI_I2C_SPEED_KHZ;
#if 1
if (EETI_ProbeTouchDevice (hTouch) != NV_TRUE) {
NvOdmOsPrintf("NvOdm Touch : Multitouch detection failure \n");
goto fail;
}
#endif
hTouch->Caps.XMaxPosition = 32767;
hTouch->Caps.YMaxPosition = 32767;
*hDevice = &hTouch->OdmTouch;
return NV_TRUE;
fail:
EETI_Close(&hTouch->OdmTouch);
return NV_FALSE;
}
static int vib_init( )
{
const NvOdmPeripheralConnectivity *pcon;
int err;
NvBool found_gpio = NV_FALSE;
int loop;
g_vib = kzalloc( sizeof(*g_vib), GFP_KERNEL );
if ( g_vib == NULL ) {
err = -1;
printk( "[%s] fail vib\n", __func__ );
return err;
}
pcon = ( NvOdmPeripheralConnectivity* ) NvOdmPeripheralGetGuid( NV_ODM_GUID('v','i','b','r','a','t','o','r') );
for ( loop=0; loop< pcon->NumAddress; loop++ ) {
switch ( pcon->AddressList[loop].Interface ) {
case NvOdmIoModule_Gpio:
g_vib->en_port = pcon->AddressList[loop].Instance;
g_vib->en_pin = pcon->AddressList[loop].Address;
found_gpio = NV_TRUE;
break;
case NvOdmIoModule_Vdd:
g_vib->vdd_id = pcon->AddressList[loop].Address;
DbgOut(( "VIB POWER %d\n", g_vib->vdd_id ));
if ( vib_set_power_rail( g_vib->vdd_id, NV_TRUE) != 0 )
return -ENOSYS;
break;
default:
break;
} // end of switch
} // end of for
DbgOut(( "[ImmVibeSPI][%s] : vibrator Int Port = %c, Int Pin = %d\n", __func__, (g_vib->en_port+'a'), g_vib->en_pin ));
g_vib->h_vib_gpio = NvOdmGpioOpen( );
if( ! g_vib->h_vib_gpio ) {
printk( "[ImmVibeSPI][%s] : Failed to open gpio\n", __func__ );
err = - ENOSYS;
return err;
}
#ifdef MACH_STAR_REV_A
g_vib->en_port = 'u' - 'a';
g_vib->en_pin = 5;
#endif
#if defined ( CONFIG_MACH_STAR )
g_vib->en_port = 'u' - 'a';
g_vib->en_pin = 4;
#endif
g_vib->h_vib_gpio_pin = NvOdmGpioAcquirePinHandle( g_vib->h_vib_gpio, g_vib->en_port, g_vib->en_pin );
if ( ! g_vib->h_vib_gpio_pin ) {
printk( "[ImmVibeSPI][%s] : Failed to acquire the pin handle\n", __func__ );
err = -ENOSYS;
return err;
}
g_vib->hOdmPwm = NvOdmPwmOpen( );
if ( ! g_vib->hOdmPwm ) {
printk( "[ImmVibeSPI][%s] : Failed to acquire the PWM handle\n", __func__ );
err = - ENOSYS;
return err;
}
return 0;
}
/**
* @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 VIBE_TPS658620_I2cWrite8(NvU8 Addr, NvU8 Data)
{
NvBool RetVal = NV_TRUE;
NvU8 WriteBuffer[2];
NvOdmI2cStatus status = NvOdmI2cStatus_Success;
NvOdmI2cTransactionInfo TransactionInfo;
NvU32 DeviceAddr = (NvU32)TPS658620_DEVICE_ADDR;
NvU32 i = 0;
NvOdmIoModule I2cModule = NvOdmIoModule_I2c;
NvU32 I2cInstance = 0;
NvU32 I2cAddress = 0;
const NvOdmPeripheralConnectivity *pConnectivity =
NvOdmPeripheralGetGuid(NV_ODM_GUID('t','p','s','6','5','8','6','x'));
for (i = 0; i < pConnectivity->NumAddress; i ++)
{
if (pConnectivity->AddressList[i].Interface == NvOdmIoModule_I2c_Pmu)
{
I2cModule = NvOdmIoModule_I2c_Pmu;
I2cInstance = pConnectivity->AddressList[i].Instance;
I2cAddress = pConnectivity->AddressList[i].Address;
break;
}
}
s_hOdmI2c = NvOdmI2cOpen(I2cModule, I2cInstance);
if (!s_hOdmI2c)
{
RetVal = NV_FALSE;
goto VIBE_TPS658620_I2cWrite8_exit;
}
DEBUG_VIBRATOR_TRACE(("[VIBE] : Open vibrate I2C success!\n"));
WriteBuffer[0] = Addr & 0xFF; // PMU offset
//modify by ,set DPWM_MODE=0, fixed freq=250Hz ,duty cycle=0~127
//WriteBuffer[1] = Data & 0xFF; // written data
WriteBuffer[1] = Data & 0x7F; // written data
TransactionInfo.Address = DeviceAddr;
TransactionInfo.Buf = WriteBuffer;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = 2;
status = NvOdmI2cTransaction(s_hOdmI2c, &TransactionInfo, 1,
TPS658620_I2C_SPEED_KHZ, NV_WAIT_INFINITE);
if (status == NvOdmI2cStatus_Success)
{
RetVal = NV_TRUE;
DEBUG_VIBRATOR_TRACE(("[VIBE] : Write vibrate I2C success!\n"));
}
else
{
RetVal = NV_FALSE;
goto VIBE_TPS658620_I2cWrite8_exit;
DEBUG_VIBRATOR_TRACE(("[VIBE] : Write vibrate I2C fail!\n"));
}
NvOdmI2cClose(s_hOdmI2c);
s_hOdmI2c = NULL;
return RetVal;
VIBE_TPS658620_I2cWrite8_exit:
DEBUG_VIBRATOR_TRACE(("[VIBE] : Open or Write vibrate I2C fail!\n"));
NvOdmI2cClose(s_hOdmI2c);
s_hOdmI2c = NULL;
return RetVal;
}
//-----------------------------------------------------------------
//--------------------------------New API--------------------------
//-----------------------------------------------------------------
NvBool
NvOdmGyroAccelOpen(NvOdmGyroAccelHandle* hDevice)
{
NvU32 i;
NvBool foundGpio = NV_FALSE, foundI2cModule = NV_FALSE;
const NvOdmPeripheralConnectivity *pConnectivity;
NvOdmGyroAccelHandle hGyro;
NvU32 reg_val = 0 ;
#if 1
printk(" ## MPU3050 : [NvOdmGyroOpen:%d] \n",__LINE__) ;
#endif
hGyro = NvOdmOsAlloc(sizeof(NvOdmGyro));
if (hGyro == NULL) {
printk("Error Allocating NvOdmAccel. \n");
return NV_FALSE;
}
NvOdmOsMemset(hGyro, 0, sizeof(NvOdmGyro));
hGyro->hPmu = NULL;
hGyro->hOdmI2C = NULL;
hGyro->hPmu = NvOdmServicesPmuOpen();
if (!hGyro->hPmu) {
printk("NvOdmServicesPmuOpen Error \n");
goto error;
}
pConnectivity = (NvOdmPeripheralConnectivity*)NvOdmPeripheralGetGuid(NV_ODM_GUID('g','y','r','o','s','c','o','p'));
if (!pConnectivity) {
printk("NvOdmPeripheralGetGuid doesn't detect gyro_accel device\n");
goto error;
}
if(pConnectivity->Class != NvOdmPeripheralClass_Other) {
goto error;
}
for (i = 0; i < pConnectivity->NumAddress; i++) {
switch(pConnectivity->AddressList[i].Interface) {
case NvOdmIoModule_I2c:
hGyro->I2CChannelId = pConnectivity->AddressList[i].Instance;
hGyro->nDevAddr = (pConnectivity->AddressList[i].Address << 1);
foundI2cModule = NV_TRUE;
foundGpio = NV_TRUE; //test
#if 1
printk("## MPU3050 I2CChannelId = %x. ## \n", hGyro->I2CChannelId);
printk("## MPU3050 i2c address = %x. ## \n", hGyro->nDevAddr);
#endif
break;
/*
case NvOdmIoModule_Gpio:
hGyro->GPIOPortINT = pConnectivity->AddressList[i].Instance;
hGyro->GPIOPinINT = pConnectivity->AddressList[i].Address;
foundGpio = NV_TRUE;
#if 1
printk("## MPU3050 GPIOPortINT = %x. ## \n",hGyro->GPIOPortINT);
printk("## MPU3050 GPIOPinINT = %x. ## \n", hGyro->GPIOPinINT);
#endif
break;*/
case NvOdmIoModule_Vdd:
hGyro->VddId = pConnectivity->AddressList[i].Address;
#if 1
printk("## MPU3050 NvOdmIoModule_VddId = %x. ## \n", hGyro->VddId);
#endif
// Power on accelerometer according to Vddid
NvGyroAccelSetPowerRail(hGyro->hPmu, hGyro->VddId, NV_TRUE);
break;
default:
break;
}
}
if (foundGpio != NV_TRUE || foundI2cModule != NV_TRUE) {
printk("GyroAccel : didn't find any periperal in discovery query for touch device Error \n");
goto error;
}
// Set up I2C bus.
if (NV_FALSE == NvGyroAccelI2COpen(&hGyro->hOdmI2C, hGyro->I2CChannelId)) {
printk("GyroAccel : NvGyroAccelI2COpen Error \n");
goto error;
};
printk(" ##1## GyroAccel : NvGyroAccelI2COpen check1 \n");
hGyro->RegsRead = NvGyroAccelI2CGetRegs;
hGyro->RegsWrite = NvGyroAccelI2CSetRegs;
printk(" ##2## GyroAccel : NvGyroAccelI2COpen check2 \n");
/*
if(NV_FALSE == NvGyroAccelConnectSemaphore(hGyro))
{
printk("GyroAccel : NvGyroAccelConnectSemaphore Error \n");
goto error;
}
*/
*hDevice = hGyro;
return NV_TRUE;
error:
// Release all of resources requested.
if (NULL != hGyro) {
NvGyroAccelSetPowerRail(hGyro->hPmu, hGyro->VddId, NV_FALSE);
NvOdmServicesPmuClose(hGyro->hPmu);
hGyro->hPmu = NULL;
NvGyroAccelI2CClose(hGyro->hOdmI2C);
hGyro->hOdmI2C = NULL;
NvOdmOsFree(hGyro);
*hDevice = NULL;
}
return NV_FALSE;
}
static NvOdmPmuDevice*
GetPmuInstance(NvOdmPmuDeviceHandle hDevice)
{
static NvOdmPmuDevice Pmu;
static NvBool first = NV_TRUE;
if (first)
{
NvOdmOsMemset(&Pmu, 0, sizeof(Pmu));
first = NV_FALSE;
if (NvOdmPeripheralGetGuid(NV_ODM_GUID('t','p','s','6','5','8','6','x')))
{
// fill in HAL functions here.
Pmu.Hal = NV_TRUE;
Pmu.pfnSetup = Tps6586xSetup;
Pmu.pfnRelease = Tps6586xRelease;
Pmu.pfnGetCaps = Tps6586xGetCapabilities;
Pmu.pfnGetVoltage = Tps6586xGetVoltage;
Pmu.pfnSetVoltage = Tps6586xSetVoltage;
Pmu.pfnGetAcLineStatus = Tps6586xGetAcLineStatus;
Pmu.pfnGetBatteryStatus = Tps6586xGetBatteryStatus;
Pmu.pfnGetBatteryData = Tps6586xGetBatteryData;
Pmu.pfnGetBatteryFullLifeTime = Tps6586xGetBatteryFullLifeTime;
Pmu.pfnGetBatteryChemistry = Tps6586xGetBatteryChemistry;
Pmu.pfnSetChargingCurrent = Tps6586xSetChargingCurrent;
Pmu.pfnInterruptHandler = Tps6586xInterruptHandler;
Pmu.pfnReadRtc = Tps6586xReadRtc;
Pmu.pfnWriteRtc = Tps6586xWriteRtc;
Pmu.pfnReadAlarm = Tps6586xReadAlarm;
Pmu.pfnWriteAlarm = Tps6586xWriteAlarm;
Pmu.pfnIsRtcInitialized = Tps6586xIsRtcInitialized;
}
else if (NvOdmPeripheralGetGuid(NV_ODM_GUID('p','c','f','_','p','m','u','0')))
{
Pmu.pfnSetup = Pcf50626Setup;
Pmu.pfnRelease = Pcf50626Release;
Pmu.pfnGetCaps = Pcf50626GetCapabilities;
Pmu.pfnGetVoltage = Pcf50626GetVoltage;
Pmu.pfnSetVoltage = Pcf50626SetVoltage;
Pmu.pfnGetAcLineStatus = Pcf50626GetAcLineStatus;
Pmu.pfnGetBatteryStatus = Pcf50626GetBatteryStatus;
Pmu.pfnGetBatteryData = Pcf50626GetBatteryData;
Pmu.pfnGetBatteryFullLifeTime = Pcf50626GetBatteryFullLifeTime;
Pmu.pfnGetBatteryChemistry = Pcf50626GetBatteryChemistry;
Pmu.pfnSetChargingCurrent = Pcf50626SetChargingCurrent;
Pmu.pfnInterruptHandler = Pcf50626InterruptHandler;
Pmu.pfnReadRtc = Pcf50626RtcCountRead;
Pmu.pfnWriteRtc = Pcf50626RtcCountWrite;
Pmu.pfnReadAlarm = NULL;
Pmu.pfnWriteAlarm = NULL;
Pmu.pfnIsRtcInitialized = Pcf50626IsRtcInitialized;
Pmu.pPrivate = NULL;
Pmu.Hal = NV_TRUE;
Pmu.Init = NV_FALSE;
}
else if (NvOdmPeripheralGetGuid(NV_ODM_GUID('m','a','x','8','9','0','7','b')))
{
Pmu.pfnSetup = Max8907bSetup;
Pmu.pfnRelease = Max8907bRelease;
Pmu.pfnGetCaps = Max8907bGetCapabilities;
Pmu.pfnGetVoltage = Max8907bGetVoltage;
Pmu.pfnSetVoltage = Max8907bSetVoltage;
Pmu.pfnGetAcLineStatus = Max8907bGetAcLineStatus;
Pmu.pfnGetBatteryStatus = Max8907bGetBatteryStatus;
Pmu.pfnGetBatteryData = Max8907bGetBatteryData;
Pmu.pfnGetBatteryFullLifeTime = Max8907bGetBatteryFullLifeTime;
Pmu.pfnGetBatteryChemistry = Max8907bGetBatteryChemistry;
Pmu.pfnSetChargingCurrent = Max8907bSetChargingCurrent;
Pmu.pfnInterruptHandler = Max8907bInterruptHandler;
Pmu.pfnReadRtc = Max8907bRtcCountRead;
Pmu.pfnWriteRtc = Max8907bRtcCountWrite;
Pmu.pfnReadAlarm = NULL;
Pmu.pfnWriteAlarm = NULL;
Pmu.pfnIsRtcInitialized = Max8907bIsRtcInitialized;
Pmu.pPrivate = NULL;
Pmu.Hal = NV_TRUE;
Pmu.Init = NV_FALSE;
}
}
if (hDevice && Pmu.Hal)
return &Pmu;
return NULL;
}
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;
}
NvBool Synaptics_OneTouch_Open (NvOdmOneTouchDeviceHandle* hDevice, NvOdmOsSemaphoreHandle* hIntSema)
{
Synaptics_OneTouch_Device* hTouch = (Synaptics_OneTouch_Device*)0;
NvU32 i;
NvU32 found = 0;
NvU32 I2cInstance = 0;
const NvOdmPeripheralConnectivity *pConnectivity = NULL;
NVODMTOUCH_PRINTF(("[Touch Driver] Synaptics_OneTouch_Open\n"));
hTouch = NvOdmOsAlloc(sizeof(Synaptics_OneTouch_Device));
if (!hTouch) return NV_FALSE;
NvOdmOsMemset(hTouch, 0, sizeof(Synaptics_OneTouch_Device));
/* set function pointers */
Synaptics_OneTouch_InitOdmTouch(&hTouch->OdmOneTouch);
pConnectivity = NvOdmPeripheralGetGuid(SYNAPTICS_ONETOUCH_DEVICE_GUID);
if (!pConnectivity)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : pConnectivity is NULL Error \n"));
goto fail;
}
if (pConnectivity->Class != NvOdmPeripheralClass_HCI)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : didn't find any periperal in discovery query for touch device Error \n"));
goto fail;
}
for (i = 0; i < pConnectivity->NumAddress; i++)
{
switch (pConnectivity->AddressList[i].Interface)
{
case NvOdmIoModule_I2c:
hTouch->DeviceAddr = (pConnectivity->AddressList[i].Address << 1);
hTouch->I2CInstance = pConnectivity->AddressList[i].Instance;
found |= 1;
NVODMTOUCH_PRINTF(("[ONETOUCH] i2c address = %x.\n", hTouch->DeviceAddr));
break;
case NvOdmIoModule_Gpio:
hTouch->GpioPort = pConnectivity->AddressList[i].Instance;
hTouch->GpioPin = pConnectivity->AddressList[i].Address;
found |= 2;
break;
case NvOdmIoModule_Vdd:
hTouch->VddId = pConnectivity->AddressList[i].Address;
found |= 4;
break;
case NvOdmIoModule_I2c_Pmu:
hTouch->I2cVddId = pConnectivity->AddressList[i].Address;
break;
default:
break;
}
}
if ((found & 3) != 3)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : peripheral connectivity problem \n"));
goto fail;
}
if ((found & 4) != 0)
{
// 20101120 [email protected] power off when Onetouch close
#if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F)
if (NV_FALSE == Synaptics_OneTouch_PowerOnOff(&hTouch->OdmOneTouch, 1))
goto fail;
#endif
}
else
{
NVODMTOUCH_PRINTF(("[ONETOUCH] Synaptics Power fail \n"));
hTouch->VddId = 0xFF;
}
hTouch->hOdmI2c = NvOdmI2cOpen(NvOdmIoModule_I2c, I2cInstance);
if (!hTouch->hOdmI2c)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : NvOdmI2cOpen Error \n"));
goto fail;
}
hTouch->hGpio = NvOdmGpioOpen();
if (!hTouch->hGpio)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : NvOdmGpioOpen Error \n"));
goto fail;
}
NVODMTOUCH_PRINTF(("[ONETOUCH] gpio port = %d. gpio pin = %d\n", hTouch->GpioPort, hTouch->GpioPin));
hTouch->hPin = NvOdmGpioAcquirePinHandle(hTouch->hGpio, hTouch->GpioPort, hTouch->GpioPin);
if (!hTouch->hPin)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] NvOdm Touch : Couldn't get GPIO pin \n"));
goto fail;
}
NvOdmGpioConfig(hTouch->hGpio,
hTouch->hPin,
NvOdmGpioPinMode_InputData);
/* set default I2C speed */
hTouch->I2cClockSpeedKHz = SYNAPTICS_I2C_SPEED_KHZ;
NVODMTOUCH_PRINTF(("[ONETOUCH] i2c speed = %d\n", hTouch->I2cClockSpeedKHz));
/* initialize */
if(!Synaptics_OneTouch_Init(hTouch)) goto fail;
*hDevice = &hTouch->OdmOneTouch;
if (Synaptics_OneTouch_EnableInterrupt(*hDevice, *hIntSema) == NV_FALSE)
goto fail;
return NV_TRUE;
fail:
Synaptics_OneTouch_Close(&hTouch->OdmOneTouch);
return NV_FALSE;
}
NvBool Pcf50626Setup(NvOdmPmuDeviceHandle hDevice)
{
NvOdmIoModule I2cModule = NvOdmIoModule_I2c;
NvU32 I2cInstance = 0;
NvU32 I2cAddress = 0;
NvU32 i = 0;
NvBool status = NV_FALSE;
const NvOdmPeripheralConnectivity *pConnectivity =
NvOdmPeripheralGetGuid(PMUGUID);
NV_ASSERT(hDevice);
pPrivData = (Pcf50626PrivData*) NvOdmOsAlloc(sizeof(Pcf50626PrivData));
if (pPrivData == NULL)
{
NVODMPMU_PRINTF(("Error Allocating Pcf50626PrivData. \n"));
return NV_FALSE;
}
NvOdmOsMemset(pPrivData, 0, sizeof(Pcf50626PrivData));
hDevice->pPrivate = pPrivData;
((Pcf50626PrivData*)hDevice->pPrivate)->supplyRefCntTable = NvOdmOsAlloc(sizeof(NvU32) * PCF50626PmuSupply_Num);
if (((Pcf50626PrivData*)hDevice->pPrivate)->supplyRefCntTable == NULL)
{
NVODMPMU_PRINTF(("Error Allocating RefCntTable. \n"));
goto fail;
}
// memset
for (i = 0; i < PCF50626PmuSupply_Num; i++)
{
((Pcf50626PrivData*)hDevice->pPrivate)->supplyRefCntTable[i] = 0;
}
if (pConnectivity != NULL) // PMU is in database
{
for (i = 0; i < pConnectivity->NumAddress; i ++)
{
if (pConnectivity->AddressList[i].Interface == NvOdmIoModule_I2c_Pmu)
{
I2cModule = NvOdmIoModule_I2c_Pmu;
I2cInstance = pConnectivity->AddressList[i].Instance;
I2cAddress = pConnectivity->AddressList[i].Address;
break;
}
}
NV_ASSERT(I2cModule == NvOdmIoModule_I2c_Pmu);
NV_ASSERT(I2cAddress != 0);
((Pcf50626PrivData*)hDevice->pPrivate)->hOdmI2C = NvOdmI2cOpen(I2cModule, I2cInstance);
if (!((Pcf50626PrivData*)hDevice->pPrivate)->hOdmI2C)
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Error Open I2C device. \n"));
NVODMPMU_PRINTF(("[NVODM PMU]Please check PMU device I2C settings. \n"));
goto fail;
}
((Pcf50626PrivData*)hDevice->pPrivate)->DeviceAddr = I2cAddress;
((Pcf50626PrivData*)hDevice->pPrivate)->hOdmPmuSevice = NvOdmServicesPmuOpen();
if (!((Pcf50626PrivData*)hDevice->pPrivate)->hOdmPmuSevice)
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Error Open PMU Odm service. \n"));
goto fail;
}
}
else
{
// if PMU is not presented in the database, then the platform is PMU-less.
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: The system did not doscover PMU fromthe data base. \n"));
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: If this is not intended, please check the peripheral database for PMU settings. \n"));
goto fail;
}
if (!Pcf50626BatteryChargerSetup(hDevice))
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Pcf50626BatteryChargerSetup() failed. \n"));
goto fail;
}
//Check battery presence
if (!Pcf50626BatteryChargerCBCMainBatt(hDevice,&((Pcf50626PrivData*)hDevice->pPrivate)->battPresence))
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Pcf50626BatteryChargerCBCMainBatt() failed. \n"));
goto fail;
}
// The interrupt assumes not supported until pcf50626InterruptHandler() is called.
((Pcf50626PrivData*)hDevice->pPrivate)->pmuInterruptSupported = NV_FALSE;
// setup the interrupt any way.
if (!Pcf50626SetupInterrupt(hDevice, &((Pcf50626PrivData*)hDevice->pPrivate)->pmuStatus))
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Pcf50626SetupInterrupt() failed. \n"));
goto fail;
}
// Check battery Fullness
if (((Pcf50626PrivData*)hDevice->pPrivate)->battPresence == NV_TRUE)
{
if (!Pcf50626BatteryChargerCBCBattFul(hDevice,&status))
{
NVODMPMU_PRINTF(("[NVODM PMU]Pcf50626Setup: Pcf50626BatteryChargerCBCBattFul() failed. \n"));
goto fail;
}
((Pcf50626PrivData*)hDevice->pPrivate)->pmuStatus.batFull = status;
}
else
{
((Pcf50626PrivData*)hDevice->pPrivate)->pmuStatus.batFull = NV_FALSE;
}
return NV_TRUE;
fail:
Pcf50626Release(hDevice);
return NV_FALSE;
}
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 pmic_set(void *data, u64 val)
{
u32 settling_time;
const NvOdmPeripheralConnectivity *con = NULL;
int ldo_number;
int j;
NvU32 millivolts;
NvU32 loop_count = MAX_REFCOUNT_LOOP;
NvRmPmuVddRailCapabilities rail;
struct pmic_struct *pmic_info = data;
ldo_number = pmic_info->ldo_number;
printk("PMIC(debugfs) : WARNING!! reference counter will be broken\n");
con = NvOdmPeripheralGetGuid(NV_ODM_GUID('a','l','l','p','o','w','e','r'));
if (con == NULL){
printk("PMIC(debugfs) : query ERROR\n");
return 0;
}
if(ldo_number == 2){
printk("PMIC(debugfs) : skip LDO2 test, always on!!!\n");
return 0;
}
NvRmPmuGetVoltage(s_hRmGlobal,
con->AddressList[ldo_number].Address, &millivolts);
if(val){
if(millivolts){
printk("PMIC(debugfs) : LDO%d already turned on\n"
, ldo_number+1);
return 0;
}
NvRmPmuGetCapabilities(s_hRmGlobal,
con->AddressList[ldo_number].Address, &rail);
for(j=MAX_REFCOUNT_LOOP;j>powerRefCount[ldo_number];j--){
NvRmPmuSetVoltage(s_hRmGlobal,
con->AddressList[ldo_number].Address,
rail.requestMilliVolts, &settling_time);
}
printk("PMIC(debugfs) : LDO%d turn on\n",
ldo_number+1);
//udelay(settling_time);
}else{
if(!millivolts){
printk("PMIC(debugfs) : LDO%d already turned off\n",
ldo_number+1);
return 0;
}
while(millivolts && loop_count--){
NvRmPmuSetVoltage(s_hRmGlobal,
con->AddressList[ldo_number].Address, NVODM_VOLTAGE_OFF,
&settling_time);
NvRmPmuGetVoltage(s_hRmGlobal,
con->AddressList[ldo_number].Address, &millivolts);
if(!millivolts){
powerRefCount[ldo_number]=loop_count;
printk("PMIC(debugfs) : LDO%d turn off\n",
ldo_number+1);
}
}
//udelay(settling_time);
}
return 0;
}
