/*
* Read I2C register function.
* offset[Input]: I2C register offset of accelerometer.
* value[Output]: Fegister value you get.
* len[Input]: Requested bytes.
* Returns NV_TRUE if successful, or NV_FALSE otherwise.
*/
NvBool NvGyroAccelI2CGetRegs(NvOdmGyroAccelHandle hDevice, NvU8 offset, NvU8* value, NvU32 len)
{
int i;
NvOdmI2cStatus i2c_status = NvOdmI2cStatus_Timeout;
NvOdmI2cTransactionInfo TransactionInfo[2];
// LGE_CHANGE_S [] 2011-05-28, [LGE_AP20] sensors: I2C recovery
if (reboot == 1)
return NV_FALSE;
// LGE_CHANGE_E [] 2011-05-28, [LGE_AP20] sensors: I2C recovery
if ((NULL == hDevice) || (NULL == value) || (len > I2C_GYROACCEL_PACKET_SIZE-1)) {
printk("NvOdmI2c Get Regs Failed, max size is %d bytes\n", I2C_GYROACCEL_PACKET_SIZE-1);
return NV_FALSE;
}
for (i = 0; i < TIMEOUT && i2c_status != NvOdmI2cStatus_Success; i++)
{
NvOdmOsMemset(s_WriteBuffer, 0, sizeof(s_WriteBuffer));
s_WriteBuffer[0] = offset;
TransactionInfo[0].Address = hDevice->nDevAddr;
TransactionInfo[0].Buf = s_WriteBuffer;
TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE;
TransactionInfo[0].NumBytes = 1;
NvOdmOsMemset(s_ReadBuffer, 0, sizeof(s_ReadBuffer));
TransactionInfo[1].Address = (hDevice->nDevAddr| 0x1);
TransactionInfo[1].Buf = s_ReadBuffer;
TransactionInfo[1].Flags = 0;
TransactionInfo[1].NumBytes = len;
i2c_status = NvOdmI2cTransaction(hDevice->hOdmI2C, TransactionInfo, 2, 400, I2C_GYROACCEL_TRANSACTION_TIMEOUT);
if ((i % 2) == 1)
mdelay(1);
}
if (i2c_status != NvOdmI2cStatus_Success) {
printk(" ## MPU3050 _ Give up!! NvGyroAccelI2CSetRegs failed: register %d \n", offset);
//reboot sensors
reboot = 1;
return NV_FALSE;
}
NvOdmOsMemcpy(value, &s_ReadBuffer[0], len);
return NV_TRUE;
}
NvU32 EETI_RawI2cRead(NvOdmTouchDeviceHandle hDevice, NvOdmTouchRawI2cData *i2c_data) {
EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice;
NvOdmI2cTransactionInfo TransactionInfo;
NvOdmI2cStatus Error;
if (i2c_data == NULL)
return NV_FALSE;
NvOdmOsMemset(i2c_data->datum, 0, EETI_MAX_READ_BYTES);
TransactionInfo.Address = hTouch->DeviceAddr;
TransactionInfo.Buf = i2c_data->datum;
TransactionInfo.Flags = 0;
TransactionInfo.NumBytes = EETI_MAX_READ_BYTES;
do {
Error = NvOdmI2cTransaction(hTouch->hOdmI2c,
&TransactionInfo,
1,
hTouch->I2cClockSpeedKHz,
EETI_I2C_TIMEOUT);
} while (Error == NvOdmI2cStatus_Timeout);
if (Error != NvOdmI2cStatus_Success) {
NvOdmOsPrintf("error!\r\n");
return NV_FALSE;
}
i2c_data->data_len = TransactionInfo.NumBytes;
return TransactionInfo.NumBytes;
}
NvBool NvAmbientsensorI2CGetLx(NvOdmALSHandle hDevice, NvU16* value)
{
NvOdmI2cTransactionInfo TransactionInfo;
NvU16 byte_swap;
if( (NULL == hDevice) || (NULL == value))
{
return NV_FALSE;
}
NvOdmOsMemset(s_ReadBuffer, 0, sizeof(s_ReadBuffer));
TransactionInfo.Address = (hDevice->nDevAddr| 0x1);
TransactionInfo.Buf = s_ReadBuffer;
TransactionInfo.Flags = 0;
TransactionInfo.NumBytes = I2C_ALS_READ_PACKET_SIZE;
//Read the data from the eeprom at the specified offset
if(NvOdmI2cStatus_Success != NvOdmI2cTransaction(hDevice->hI2c, &TransactionInfo, 1, 400, I2C_ALS_TRANSACTION_TIMEOUT))
{
return NV_FALSE;
};
byte_swap = s_ReadBuffer[0];
s_ReadBuffer[0] = s_ReadBuffer[1];
s_ReadBuffer[1] = byte_swap;
*value = *( NvU16 *)s_ReadBuffer;
return NV_TRUE;
}
static NvBool EETI_ProbeTouchDevice (EETI_TouchDevice* hTouch) {
NvOdmI2cTransactionInfo TransactionInfo;
NvU8 arr[EETI_MAX_READ_BYTES];
NvOdmI2cStatus Error;
NvOdmOsMemset(arr, 0, EETI_MAX_READ_BYTES);
arr[0] = 0x03;
arr[1] = 0x01;
arr[2] = (NvU8)'A';
TransactionInfo.Address = hTouch->DeviceAddr;
TransactionInfo.Buf = arr;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = 3;
Error = NvOdmI2cTransaction(hTouch->hOdmI2c,
&TransactionInfo,
1,
hTouch->I2cClockSpeedKHz,
EETI_I2C_TIMEOUT);
if (Error != NvOdmI2cStatus_Success) {
return NV_FALSE;
}
return NV_TRUE;
}
NvU32 EETI_RawI2cWrite(NvOdmTouchDeviceHandle hDevice, NvOdmTouchRawI2cData *i2c_data) {
EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice;
NvOdmI2cTransactionInfo TransactionInfo;
NvU8 arr[EETI_MAX_READ_BYTES];
NvOdmI2cStatus Error;
NvOdmOsMemset(arr, 0, EETI_MAX_READ_BYTES);
NvOdmOsMemcpy(arr, i2c_data->datum, i2c_data->data_len);
TransactionInfo.Address = hTouch->DeviceAddr;
TransactionInfo.Buf = arr;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = i2c_data->data_len;
Error = NvOdmI2cTransaction(hTouch->hOdmI2c,
&TransactionInfo,
1,
hTouch->I2cClockSpeedKHz,
EETI_I2C_TIMEOUT);
if (Error != NvOdmI2cStatus_Success) {
return 0;
}
return TransactionInfo.NumBytes;
}
/*
* Write I2C register function.
* offset[Input]: I2C register offset of accelerometer.
* value[Input]: register value you will write.
* len[Input]: requested bytes.
* Returns NV_TRUE if successful, or NV_FALSE otherwise.
*/
NvBool NvAccelerometerI2CSetRegs(NvOdmAccelHandle hDevice, NvU8 offset, NvU8* value, NvU32 len)
{
NvOdmI2cTransactionInfo TransactionInfo;
if( (NULL == hDevice) || (NULL == value) || (len > I2C_ACCELRATOR_PACKET_SIZE-1 ))
{
//NVODMACCELEROMETER_PRINTF("NvOdmI2c Set Regs Failed, max size is %d bytes\n", I2C_ACCELRATOR_PACKET_SIZE-1);
return NV_FALSE;
}
NvOdmOsMemset(s_WriteBuffer, 0, sizeof(s_WriteBuffer));
s_WriteBuffer[0] = offset;
NvOdmOsMemcpy(&s_WriteBuffer[1], value, len);
TransactionInfo.Address = hDevice->nDevAddr;
TransactionInfo.Buf = s_WriteBuffer;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = len+1;
// Write the accelerator offset (from where data is to be read).
if(NvOdmI2cStatus_Success != NvOdmI2cTransaction(hDevice->hOdmI2C, &TransactionInfo, 1, 400, I2C_ACCELRATOR_TRANSACTION_TIMEOUT))
{
return NV_FALSE;
};
return NV_TRUE;
}
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;
}
static NvBool EETI_GetTouchReport (EETI_TouchDevice* hTouch, NvU8 *ReportData, NvU32 *len) {
/* Issue i2c transaction to get multi-touch report from the controller */
NvOdmI2cTransactionInfo TransactionInfo;
NvOdmI2cStatus Error;
NvOdmOsMemset(ReportData, 0, EETI_MAX_READ_BYTES);
TransactionInfo.Address = hTouch->DeviceAddr;
TransactionInfo.Buf = ReportData;
TransactionInfo.Flags = 0;
TransactionInfo.NumBytes = EETI_MAX_READ_BYTES;
do {
Error = NvOdmI2cTransaction(hTouch->hOdmI2c,
&TransactionInfo,
1,
hTouch->I2cClockSpeedKHz,
EETI_I2C_TIMEOUT);
} while (Error == NvOdmI2cStatus_Timeout);
*len = TransactionInfo.NumBytes;
if (Error != NvOdmI2cStatus_Success) {
NvOdmOsPrintf("error!\r\n");
return NV_FALSE;
}
return NV_TRUE;
}
NvBool EETI_EnableInterrupt (NvOdmTouchDeviceHandle hDevice, NvOdmOsSemaphoreHandle hIntSema) {
EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice;
NvOdmTouchCoordinateInfo coord;
NV_ASSERT(hIntSema);
/* can only be initialized once */
if (hTouch->hGpioIntr || hTouch->hIntSema)
return NV_FALSE;
NvOdmOsMemset(&coord, 0, sizeof(NvOdmTouchCoordinateInfo));
/* zero intr status */
EETI_GetSample(hTouch, &coord);
hTouch->hIntSema = hIntSema;
if (NvOdmGpioInterruptRegister(hTouch->hGpio, &hTouch->hGpioIntr,
hTouch->hPin, NvOdmGpioPinMode_InputInterruptLow, EETI_GpioIsr,
(void*)hTouch, EETI_DEBOUNCE_TIME_MS) == NV_FALSE) {
return NV_FALSE;
}
if (!hTouch->hGpioIntr)
return NV_FALSE;
return NV_TRUE;
}
NvBool NvOdmBatteryDeviceOpen(NvOdmBatteryDeviceHandle *hDevice,
NvOdmOsSemaphoreHandle *hOdmSemaphore)
{
NvOdmBatteryDevice *pBattContext = NULL;
NvU32 i;
NvError NvStatus = NvError_Success;
NvU32 PinState;
pBattContext = NvOdmOsAlloc(sizeof(NvOdmBatteryDevice));
if (!pBattContext)
{
NvOsDebugPrintf(("NvOdmOsAlloc failed to allocate pBattContext."));
return NV_FALSE;
}
NvOdmOsMemset(pBattContext, 0, sizeof(NvOdmBatteryDevice));
NvStatus = NvRmOpen(&pBattContext->hRm, 0);
if (NvStatus != NvError_Success)
goto Cleanup;
NvStatus = NvRmGpioOpen(pBattContext->hRm, &pBattContext->hGpio);
if (NvStatus != NvError_Success)
goto Cleanup;
pBattContext->pGpioPinInfo = NvOdmQueryGpioPinMap(
NvOdmGpioPinGroup_Battery,
0,
&pBattContext->PinCount);
if (pBattContext->pGpioPinInfo == NULL)
{
goto Cleanup;
}
for (i = 0; i < pBattContext->PinCount; i++ )
{
/*Need the pin 1 to be set to Output for charging of the battery. */
if (i == 1)
{
NvRmGpioAcquirePinHandle(
pBattContext->hGpio,
pBattContext->pGpioPinInfo[i].Port,
pBattContext->pGpioPinInfo[i].Pin,
&pBattContext->hPin);
if (!pBattContext->hPin)
{
goto Cleanup;
}
NvRmGpioConfigPins(pBattContext->hGpio, &pBattContext->hPin, 1, NvRmGpioPinMode_Output);
PinState = NvRmGpioPinState_Low;
NvRmGpioWritePins(pBattContext->hGpio, &pBattContext->hPin, &PinState,1);
}
}
*hDevice = pBattContext;
return NV_TRUE;
Cleanup:
NvOdmBatteryDeviceClose(pBattContext);
return NV_FALSE;
}
void
NvOdmPmuGetCapabilities(NvU32 vddId,
NvOdmPmuVddRailCapabilities* pCapabilities)
{
// use a manual handle, since this function doesn't takea handle
NvOdmPmuDevice* pmu = GetPmuInstance((NvOdmPmuDeviceHandle)1);
if (pmu && pmu->pfnGetCaps)
pmu->pfnGetCaps(vddId, pCapabilities);
else if (pCapabilities)
{
NvOdmOsMemset(pCapabilities, 0, sizeof(NvOdmPmuVddRailCapabilities));
pCapabilities->OdmProtected = NV_TRUE;
}
}
static NvOdmI2cStatus
NvOdmPeripheralI2cRead8(
NvOdmServicesI2cHandle hOdmI2c,
NvU8 I2cAddr,
NvU8 Offset,
NvU8 *pData)
{
NvU8 ReadBuffer[1];
NvOdmI2cStatus Error;
NvOdmI2cTransactionInfo TransactionInfo;
ReadBuffer[0] = Offset;
TransactionInfo.Address = I2cAddr;
TransactionInfo.Buf = ReadBuffer;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = 1;
Error = NvOdmI2cTransaction(
hOdmI2c, &TransactionInfo, 1, NVODM_QUERY_I2C_CLOCK_SPEED, NV_WAIT_INFINITE);
if (Error != NvOdmI2cStatus_Success)
{
return Error;
}
NvOdmOsMemset(ReadBuffer, 0, sizeof(ReadBuffer));
TransactionInfo.Address = (I2cAddr | 0x1);
TransactionInfo.Buf = ReadBuffer;
TransactionInfo.Flags = 0;
TransactionInfo.NumBytes = 1;
// Read data from ROM at the specified offset
Error = NvOdmI2cTransaction(
hOdmI2c, &TransactionInfo, 1, NVODM_QUERY_I2C_CLOCK_SPEED, NV_WAIT_INFINITE);
if (Error != NvOdmI2cStatus_Success)
{
return Error;
}
*pData = ReadBuffer[0];
return Error;
}
static NvBool Synaptics_OneTouch_Init(Synaptics_OneTouch_Device* hTouch)
{
NvU8 pBuffer[OT_NUM_CONFIG_BYTES];
NvU8 bTemp;
NvOdmOsMemset(pBuffer, 0, sizeof(pBuffer));
if(hTouch == NULL)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] Synaptics Driver Initialize Fail\n"));
return NV_FALSE;
}
// Write the configuration to the OneTouch
if(!Synaptics_OneTouch_WriteRegisterMulti(hTouch, g_OT_Config, OT_NUM_CONFIG_BYTES))
{
NVODMTOUCH_PRINTF(("[ONETOUCH] Fail Write the configuration to the OneTouch\n" ));
return NV_FALSE;
}
// read the entire configuration back from the device
if(!Synaptics_OneTouch_ReadRegisterSafe(hTouch, pBuffer, OT_NUM_CONFIG_BYTES -2))
{
NVODMTOUCH_PRINTF(("[ONETOUCH] Fail read the entire configuration back from the devicen"));
return NV_FALSE;
}
// verify the configuration registers are written correctly
for(bTemp=0; bTemp < (OT_NUM_CONFIG_BYTES-2); bTemp++)
{
NVODMTOUCH_PRINTF(("[ONETOUCH] pBuffer[%d]=%d == g_OT_Config[%d]=%d \n", bTemp, pBuffer[bTemp], bTemp, g_OT_Config[bTemp+2]));
if(pBuffer[bTemp] != g_OT_Config[bTemp+2])
return NV_FALSE;
}
// set base address
Synaptics_OneTouch_SetReadAddr(hTouch);
// read the data register to deassert the attention line
Synaptics_OneTouch_ReadRegisterSafe(hTouch, pBuffer, 1);
return NV_TRUE;
}
static NvOdmPmuDevice*
GetPmuInstance(NvOdmPmuDeviceHandle hDevice)
{
static NvOdmPmuDevice Pmu;
static NvBool first = NV_TRUE;
if (first)
{
NvOdmOsMemset(&Pmu, 0, sizeof(Pmu));
first = NV_FALSE;
{
Pmu.pfnSetup = RegulatorSetup;
Pmu.pfnRelease = RegulatorRelease;
Pmu.pfnGetCaps = RegulatorGetCapabilities;
Pmu.pfnGetVoltage = RegulatorGetVoltage;
Pmu.pfnSetVoltage = RegulatorSetVoltage;
Pmu.pfnGetAcLineStatus = RegulatorGetAcLineStatus;
Pmu.pfnGetBatteryStatus = RegulatorGetBatteryStatus;
Pmu.pfnGetBatteryData = RegulatorGetBatteryData;
Pmu.pfnGetBatteryFullLifeTime = RegulatorGetBatteryFullLifeTime;
Pmu.pfnGetBatteryChemistry = RegulatorGetBatteryChemistry;
Pmu.pfnSetChargingCurrent = RegulatorSetChargingCurrent;
Pmu.pfnInterruptHandler = RegulatorInterruptHandler;
Pmu.pfnReadRtc = RegulatorRtcCountRead;
Pmu.pfnWriteRtc = RegulatorRtcCountWrite;
Pmu.pfnIsRtcInitialized = RegulatorIsRtcInitialized;
Pmu.pPrivate = NULL;
Pmu.Hal = NV_TRUE;
Pmu.Init = NV_FALSE;
}
}
if (hDevice && Pmu.Hal)
return &Pmu;
return NULL;
}
NvBool NvGyroAccelI2CSetRegs(NvOdmGyroAccelHandle hDevice, NvU8 offset, NvU8* value, NvU32 len)
{
int i;
NvOdmI2cStatus i2c_status = NvOdmI2cStatus_Timeout;
NvOdmI2cTransactionInfo TransactionInfo;
if ((NULL == hDevice) || (NULL == value) || (len > I2C_GYROACCEL_PACKET_SIZE-1)) {
return NV_FALSE;
}
for(i = 0; i < TIMEOUT && i2c_status != NvOdmI2cStatus_Success; i++)
{
NvOdmOsMemset(s_WriteBuffer, 0, sizeof(s_WriteBuffer));
s_WriteBuffer[0] = offset;
NvOdmOsMemcpy(&s_WriteBuffer[1], value, len);
TransactionInfo.Address = hDevice->nDevAddr;
TransactionInfo.Buf = s_WriteBuffer;
TransactionInfo.Flags = NVODM_I2C_IS_WRITE;
TransactionInfo.NumBytes = len+1;
i2c_status = NvOdmI2cTransaction(hDevice->hOdmI2C, &TransactionInfo, 1, 400, I2C_GYROACCEL_TRANSACTION_TIMEOUT);
if ((i % 2) == 1)
mdelay(1);
}
if (i2c_status != NvOdmI2cStatus_Success) {
printk(" ## MPU3050 _ Give up!! NvGyroAccelI2CSetRegs failed: register %d \n", offset);
//reboot sensors
reboot = 1;
return NV_FALSE;
}
return NV_TRUE;
}
NvBool Adt7461Init(NvOdmTmonDeviceHandle hTmon)
{
NvU8 Data;
NvBool ExtRange;
NvU32 i = 0;
NvU32 I2cInstance = 0;
NvOdmIoModule I2cModule = NvOdmIoModule_Num; // Inavlid module
const ADT7461RegisterInfo* pReg = NULL;
ADT7461PrivData* pPrivData = NULL;
NV_ASSERT(hTmon && hTmon->pConn && hTmon->pConn->AddressList);
// Allocate and clear priavte data
pPrivData = (ADT7461PrivData*) NvOdmOsAlloc(sizeof(ADT7461PrivData));
if (pPrivData == NULL)
{
NVODM_ADT7461_PRINTF(("ADT7461: Error Allocating PrivData. \n"));
return NV_FALSE;
}
NvOdmOsMemset(pPrivData, 0, sizeof(ADT7461PrivData));
hTmon->pPrivate = pPrivData;
// Register for PMU services
pPrivData->hOdmPmuSevice = NvOdmServicesPmuOpen();
if (pPrivData->hOdmPmuSevice == NULL)
{
NVODM_ADT7461_PRINTF(("ADT7461: Error Open PMU service. \n"));
goto fail;
}
// Register for GPIO services
pPrivData->hGpio = NvOdmGpioOpen();
if (pPrivData->hOdmPmuSevice == NULL)
{
NVODM_ADT7461_PRINTF(("ADT7461: Error Open GPIO service. \n"));
goto fail;
}
/*
* Parse connectivity data: turn On power to the device, acquire I2C
* interface and GPIO interrupt (optional); map device channels to
* thermal zones
*/
for (i = 0; i < hTmon->pConn->NumAddress; i ++)
{
const NvOdmIoAddress* pIoAddress = &hTmon->pConn->AddressList[i];
if (pIoAddress->Interface == NvOdmIoModule_I2c_Pmu)
{
I2cModule = NvOdmIoModule_I2c_Pmu;
I2cInstance = pIoAddress->Instance;
NV_ASSERT(pIoAddress->Address != 0);
pPrivData->DeviceI2cAddr = pIoAddress->Address;
}
else if (pIoAddress->Interface == NvOdmIoModule_Tsense)
{
NV_ASSERT(pIoAddress->Instance < NvOdmTmonZoneID_Num);
NV_ASSERT(pIoAddress->Address < ADT7461ChannelID_Num);
pPrivData->ConnectivityMap[pIoAddress->Instance] =
pIoAddress->Address;
}
else if (pIoAddress->Interface == NvOdmIoModule_Vdd)
{
NvU32 usec = 0;
NvU32 RailAddress = pIoAddress->Address;
NvOdmServicesPmuVddRailCapabilities RailCapabilities;
NvOdmServicesPmuGetCapabilities(
pPrivData->hOdmPmuSevice, RailAddress, &RailCapabilities);
NvOdmServicesPmuSetVoltage(pPrivData->hOdmPmuSevice, RailAddress,
RailCapabilities.requestMilliVolts, &usec);
NvOdmOsWaitUS(usec + (ADT7461_POWERUP_DELAY_MS * 1000));
}
else if (pIoAddress->Interface == NvOdmIoModule_Gpio)
{
NvU32 port = pIoAddress->Instance;
NvU32 pin = pIoAddress->Address;
pPrivData->hGpioPin = NvOdmGpioAcquirePinHandle(
pPrivData->hGpio, port, pin);
}
}
NV_ASSERT(I2cModule == NvOdmIoModule_I2c_Pmu);
pPrivData->hOdmI2C = NvOdmI2cOpen(I2cModule, I2cInstance);
if (pPrivData->hOdmI2C == NULL)
{
NVODM_ADT7461_PRINTF(("ADT7461: Error Open I2C device. \n"));
goto fail;
}
/*
* Initialize device info and configuration. Force standby mode to avoid
* glitch on shutdown comparator output when temperature range and/or
* comparator limit is changing during initialization. The Adt7461Run()
* call from the hal that follows initialization will switch device to
* run mode and re-start temperature monitoring (note that out of limit
* interrupt is always masked during and after initialization)
*/
pPrivData->pDeviceInfo = &s_Adt7461Info;
pPrivData->ShadowRegPtr = ADT7461_INVALID_ADDR;
pReg = &pPrivData->pDeviceInfo->Config;
if (!Adt7461ReadReg(pPrivData, pReg, &Data))
goto fail;
if ((Data & ADT7461ConfigBits_ExtendedRange) !=
(ADT7461_INITIAL_CONFIG & ADT7461ConfigBits_ExtendedRange))
{
// Only switch from standard to extended range is supported
NV_ASSERT((Data & ADT7461ConfigBits_ExtendedRange) == 0);
Data |= ADT7461ConfigBits_Standby;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
}
Data = ADT7461_INITIAL_CONFIG | ADT7461ConfigBits_Standby;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
pPrivData->ShadowConfig = Data;
#if PRE_ER_GMT_THERMALSENSOR
ExtRange = 0; /* not support ADT thermal sensor*/
#else
ExtRange = ((Data & ADT7461ConfigBits_ExtendedRange) != 0);
#endif
// Program shutdown comparators settings
Data = ADT7461_T_VALUE_TO_DATA(
ExtRange, ADT7461_ODM_LOCAL_COMPARATOR_LIMIT_VALUE);
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Local].ComparatorLimit;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
Data = ADT7461_T_VALUE_TO_DATA(
ExtRange, ADT7461_ODM_REMOTE_COMPARATOR_LIMIT_VALUE);
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Remote].ComparatorLimit;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
// Set interrupt limits to the range boundaries to prevent out of limit
// interrupt
Data = ADT7461_T_VALUE_TO_DATA(
ExtRange, ADT7461_T_RANGE_LIMIT_HIGH(ExtRange));
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Local].IntrLimitHigh;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Remote].IntrLimitHigh;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
Data = ADT7461_T_VALUE_TO_DATA(
ExtRange, ADT7461_T_RANGE_LIMIT_LOW(ExtRange));
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Local].IntrLimitLow;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Remote].IntrLimitLow;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
// Set initial rate
Data = ADT7461_INITIAL_RATE_SETTING;
pReg = &pPrivData->pDeviceInfo->Rate;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
pPrivData->ShadowRate = Data;
// Set remote channel offset (8-bit 2's complement value for any range)
Data = ((NvU8)ADT7461_ODM_REMOTE_OFFSET_VALUE);
pReg = &pPrivData->pDeviceInfo->Channels[
ADT7461ChannelID_Remote].Toffset;
if(!Adt7461WriteReg(pPrivData, pReg, Data))
goto fail;
// Read ADT7461 status and ARA (clear pending Alert interrupt, if any)
pReg = &pPrivData->pDeviceInfo->Status;
if (!Adt7461ReadReg(pPrivData, pReg, &Data))
goto fail;
// TODO: check open remote circuit error
Adt7461ReadAra(pPrivData);
return NV_TRUE;
fail:
Adt7461FreePrivData(pPrivData);
hTmon->pPrivate = NULL;
return NV_FALSE;
}
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;
}
//-----------------------------------------------------------------
//--------------------------------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;
}
//-----------------------------------------------------------------
//--------------------------------New API--------------------------
//-----------------------------------------------------------------
NvBool
NvOdmAccelOpen(NvOdmAccelHandle* hDevice)
{
NvU32 test_val;
NvU32 i;
NvBool foundGpio = NV_FALSE, foundI2cModule = NV_FALSE;
const NvOdmPeripheralConnectivity *pConnectivity;
NvOdmAccelHandle hAccel;
hAccel = NvOdmOsAlloc(sizeof(NvOdmAccel));
if (hAccel == NULL)
{
//NVODMACCELEROMETER_PRINTF("Error Allocating NvOdmAccel. \n");
return NV_FALSE;
}
NvOdmOsMemset(hAccel, 0, sizeof(NvOdmAccel));
hAccel->hPmu = NULL;
hAccel->hOdmI2C = NULL;
hAccel->nBusType = NV_ACCELEROMETER_BUS_I2C;
// Chip init cfg info here, here just a sample for common interrupt now!
// This part will move to a configuration table later.
// Start here.
// Only enable common interrupt
// Enable common and single tap at the same time.
hAccel->CtrlRegsList[0].RegAddr = XLR_CTL; //0x12
hAccel->CtrlRegsList[0].RegValue = 0x20;
hAccel->CtrlRegsList[1].RegAddr = XLR_INTCONTROL; //0x13
hAccel->CtrlRegsList[1].RegValue = 0xF3; // modify so that sw is compatible
hAccel->CtrlRegsList[2].RegAddr = XLR_INTCONTROL2; //0x14
hAccel->CtrlRegsList[2].RegValue = 0xe0;
hAccel->CtrlRegsList[3].RegAddr = XLR_THRESHG; //0x1C
hAccel->CtrlRegsList[3].RegValue = NV_ADI340_ACCELEROMETER_NORMAL_THRESHOLD;
hAccel->CtrlRegsList[4].RegAddr = XLR_OFSX; //0x1E
hAccel->CtrlRegsList[4].RegValue = 0;
hAccel->CtrlRegsList[5].RegAddr = XLR_OFSY; //0x1F
hAccel->CtrlRegsList[5].RegValue = 0;
hAccel->CtrlRegsList[6].RegAddr = XLR_OFSZ; //0x20
hAccel->CtrlRegsList[6].RegValue = 0;
hAccel->CtrlRegsList[7].RegAddr = XLR_THRESHC; //0x1D
hAccel->CtrlRegsList[7].RegValue = NV_ADI340_ACCELEROMETER_TAP_THRESHOLD;
hAccel->CtrlRegsList[8].RegAddr = XLR_DUR; //0x21
hAccel->CtrlRegsList[8].RegValue = 0x40;
hAccel->CtrlRegsList[9].RegAddr = XLR_LATENT; //0x22
hAccel->CtrlRegsList[9].RegValue = 0xff;
hAccel->CtrlRegsList[10].RegAddr = XLR_INTVL; //0x23
hAccel->CtrlRegsList[10].RegValue = 0;
hAccel->CtrlRegsList[11].RegAddr = XLR_INTCONTROL2; //0x14
hAccel->CtrlRegsList[11].RegValue = 0xe1;
hAccel->CtrlRegsList[12].RegAddr = XLR_INTCONTROL2; //0x14
hAccel->CtrlRegsList[12].RegValue = 0xe0;
hAccel->nLength = 13;
// Stop here.
// Info of accelerometer with current setting.
hAccel->Caption.MaxForceInGs = 2000;
hAccel->Caption.MaxTapTimeDeltaInUs = 255;
hAccel->Caption.NumMotionThresholds = 1;
hAccel->Caption.SupportsFreefallInt = 0;
hAccel->Caption.MaxSampleRate = 100;
hAccel->Caption.MinSampleRate = 3;
hAccel->PowerState = NvOdmAccelPower_Fullrun;
hAccel->AxisXMapping = NvOdmAccelAxis_X;
hAccel->AxisXDirection = 1;
hAccel->AxisYMapping = NvOdmAccelAxis_Y;
hAccel->AxisYDirection = 1;
hAccel->AxisZMapping = NvOdmAccelAxis_Z;
hAccel->AxisZDirection = -1;
hAccel->hPmu = NvOdmServicesPmuOpen();
if (!hAccel->hPmu)
{
//NVODMACCELEROMETER_PRINTF("NvOdmServicesPmuOpen Error \n");
goto error;
}
pConnectivity = (NvOdmPeripheralConnectivity*)NvOdmPeripheralGetGuid(NV_ODM_GUID('a','c','c','e','l','e','r','o'));
if (!pConnectivity)
{
NvOdmOsDebugPrintf("NvOdmPeripheralGetGuid doesn't detect accelerometer 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:
hAccel->I2CChannelId = pConnectivity->AddressList[i].Instance;
hAccel->nDevAddr = (NvU8)pConnectivity->AddressList[i].Address;
foundI2cModule = NV_TRUE;
break;
case NvOdmIoModule_Gpio:
hAccel->GPIOPortINT = pConnectivity->AddressList[i].Instance;
hAccel->GPIOPinINT = pConnectivity->AddressList[i].Address;
foundGpio = NV_TRUE;
break;
case NvOdmIoModule_Vdd:
hAccel->VddId = pConnectivity->AddressList[i].Address;
// Power on accelerometer according to Vddid
NvAccelerometerSetPowerRail(hAccel->hPmu, hAccel->VddId, NV_TRUE);
break;
default:
break;
}
}
if(foundGpio != NV_TRUE || foundI2cModule != NV_TRUE)
{
//NVODMACCELEROMETER_PRINTF("Accelerometer : didn't find any periperal in discovery query for touch device Error \n");
goto error;
}
// Set up I2C bus.
if(NV_FALSE == NvAccelerometerI2COpen(&hAccel->hOdmI2C, hAccel->I2CChannelId))
{
goto error;
};
hAccel->RegsRead = NvAccelerometerI2CGetRegs;
hAccel->RegsWrite = NvAccelerometerI2CSetRegs;
NvOdmAccelerometerGetParameter(hAccel, XLR_WHOAMI, &test_val);
if(XLR_IDNUM != test_val)
{
goto error;
}
NvOdmAccelerometerGetParameter(hAccel, XLR_DEVID, &test_val);
if (test_val == XLR_NEWCHIPID)
{
// This chip is ADXL345
//NvOdmOsDebugPrintf("This chip is ADXL345!!!\n");
hAccel->CtrlRegsList[4].RegValue = 0x0A; // offset X
hAccel->CtrlRegsList[5].RegValue = 0x0B; // offset Y
hAccel->CtrlRegsList[6].RegValue = 0x14; // offset Z
}
//NVODMACCELEROMETER_PRINTF("ID is 0x%x\n", test_val);
/* We don't know the reset state of the accelerometer. So, program the
* accelerometer to disable generation of interrupts.
*
* Write to INTCONTROL register to disable genetration of the interrupts.
* Write to INTCONTROL2 to clear the already latched interrupts.
*/
NvOdmAccelerometerSetParameter(hAccel, XLR_ATTR_INTCONTROL, 0x0);
NvOdmAccelerometerSetParameter(hAccel, XLR_ATTR_INTCONTROL2, 0x1);
if(NV_FALSE == NvAccelerometerConnectSemaphore(hAccel))
{
goto error;
}
//init accelerometer
for(i=0; i<hAccel->nLength; i++)
{
NvOdmAccelerometerSetParameter(hAccel,
hAccel->CtrlRegsList[i].RegAddr,
hAccel->CtrlRegsList[i].RegValue);
}
// Set up event.
//NvOdmAccelerometerGetParameter(XLR_SCALE, hAccel);
*hDevice = hAccel;
return NV_TRUE;
error:
// Release all of resources requested.
if(NULL != hAccel)
{
NvAccelerometerSetPowerRail(hAccel->hPmu, hAccel->VddId, NV_FALSE);
NvOdmServicesPmuClose(hAccel->hPmu);
hAccel->hPmu = NULL;
NvAccelerometerI2CClose(hAccel->hOdmI2C);
hAccel->hOdmI2C = NULL;
NvOdmOsFree(hAccel);
*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;
}
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;
}
NvBool
NvOdmMouseDeviceOpen(
NvOdmMouseDeviceHandle *hDevice)
{
NvOdmMouseDevice *hMouseDev = NULL;
NvBool ret = NV_FALSE;
NvU32 InstanceId = 0, count = 0, MousePort = 0, i = 0;
#if WAKE_FROM_MOUSE
NvError err = NvError_Success;
NvEcRequest Request = {0};
NvEcResponse Response = {0};
#endif
// Allocate memory for request type structure
hMouseDev = (NvOdmMouseDevice *)NvOdmOsAlloc(sizeof(NvOdmMouseDevice));
if (!hMouseDev)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate hMouseDev!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev, 0, sizeof(NvOdmMouseDevice));
// open channel to the EC
if ((NvEcOpen(&hMouseDev->hEc, InstanceId)) != NvSuccess)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvEcOpen failed !!"));
goto fail_safe;
}
hMouseDev->pRequest = NULL;
hMouseDev->pResponse = NULL;
hMouseDev->pEvent = NULL;
hMouseDev->CompressionEnabled = NV_FALSE;
hMouseDev->CompressionState = 0x0;
do
{
hMouseDev->ValidMousePorts[count] = INVALID_MOUSE_PORT_ID;
count++;
} while (count <= MAX_NUM_MOUSE_PORTS);
// Allocate memory for request type structure
hMouseDev->pRequest = NvOdmOsAlloc(sizeof(NvEcRequest));
if (!hMouseDev->pRequest)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pRequest!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pRequest, 0, sizeof(NvEcRequest));
// Allocate memory for response type structure
hMouseDev->pResponse = NvOdmOsAlloc(sizeof(NvEcResponse));
if (!hMouseDev->pResponse)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pResponse!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pResponse, 0, sizeof(NvEcResponse));
// Allocate memory for event type structure
hMouseDev->pEvent = NvOdmOsAlloc(sizeof(NvEcEvent));
if (!hMouseDev->pEvent)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pEvent!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pEvent, 0, sizeof(NvEcEvent));
MousePort = MOUSE_PS2_PORT_ID_0;
count = CMD_MAX_RETRIES + 1; i = 0;
while (count--)
{
// fill up request structure
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_AuxDevice;
Request.RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,MousePort))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_SendCommand);
Request.NumPayloadBytes = 2;
Request.Payload[0] = 0xFF; // set the reset command
Request.Payload[1] = 3;
// Request to EC
err = NvEcSendRequest(hMouseDev->hEc, &Request, &Response, sizeof(Request),
sizeof(Response));
if (NvSuccess != err)
{
NVODMMOUSE_PRINTF(("NvEcSendRequest failed !!"));
break;
}
// mouse not found
if (NvEcStatus_Success != Response.Status)
{
NVODMMOUSE_PRINTF(("EC response failed !!"));
if (MousePort != MOUSE_PS2_PORT_ID_1)
{
count = CMD_MAX_RETRIES + 1;
MousePort = MOUSE_PS2_PORT_ID_1;
continue;
}
break;
}
if (Response.NumPayloadBytes != 3)
continue;
// success
if (Response.Payload[0] == 0xFA)
{
hMouseDev->ValidMousePorts[i] = MousePort;
if (MousePort != MOUSE_PS2_PORT_ID_1)
{
count = CMD_MAX_RETRIES + 1;
MousePort = MOUSE_PS2_PORT_ID_1;
i++;
continue;
}
break;
}
}
#if WAKE_FROM_MOUSE
i = 0;
do
{
/* enable mouse as wake up source */
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_AuxDevice;
Request.RequestSubtype = ((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hMouseDev->ValidMousePorts[i]))) |
(NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_ConfigureWake;
Request.NumPayloadBytes = 2;
Request.Payload[0] = NVEC_AUX_DEVICE_WAKE_ENABLE_0_ACTION_ENABLE;
Request.Payload[1] = NVEC_AUX_DEVICE_EVENT_TYPE_0_ANY_EVENT_ENABLE;
err = NvEcSendRequest(
hMouseDev->hEc,
&Request,
&Response,
sizeof(Request),
sizeof(Response));
if (err != NvError_Success)
{
ret = NV_FALSE;
goto fail_safe;
}
if (Response.Status != NvEcStatus_Success)
{
ret = NV_FALSE;
goto fail_safe;
}
} while (hMouseDev->ValidMousePorts[++i] != INVALID_MOUSE_PORT_ID);
#endif
*hDevice = (NvOdmMouseDeviceHandle)hMouseDev;
ret = NV_TRUE;
return ret;
fail_safe:
NvOdmMouseDeviceClose((NvOdmMouseDeviceHandle)hMouseDev);
hMouseDev = NULL;
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;
}
