int odm_i2c_block_read(struct odm_i2c_dev *dev, unsigned char cmd, unsigned char **buffer) { /* TODO: How to implement this ? */ /* OK, let's read twice, first time we get the total number, then get all the block data */ int i; unsigned char data_len = 0; unsigned char *read_buffer; NvOdmI2cStatus I2cStatus; NvOdmI2cTransactionInfo TransactionInfo[2]; TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE | NVODM_I2C_USE_REPEATED_START; TransactionInfo[0].Address = dev->address; TransactionInfo[0].Buf = &cmd; TransactionInfo[0].NumBytes = 1; TransactionInfo[1].Flags = 0; TransactionInfo[1].Address = dev->address | 0x1; TransactionInfo[1].Buf = &data_len; TransactionInfo[1].NumBytes = 1; I2cStatus = NvOdmI2cTransaction(dev->i2c, TransactionInfo, 2, dev->speed, dev->timeout); if (I2cStatus != NvOdmI2cStatus_Success || data_len <= 0) { return -EINVAL; } read_buffer = kzalloc(data_len+2, GFP_KERNEL); if (!read_buffer) { return -ENOMEM; } TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE | NVODM_I2C_USE_REPEATED_START; TransactionInfo[0].Address = dev->address; TransactionInfo[0].Buf = &cmd; TransactionInfo[0].NumBytes = 1; TransactionInfo[1].Flags = 0; TransactionInfo[1].Address = dev->address | 0x1; TransactionInfo[1].Buf = read_buffer; TransactionInfo[1].NumBytes = data_len + 1; I2cStatus = NvOdmI2cTransaction(dev->i2c, TransactionInfo, 2, dev->speed, dev->timeout); if (I2cStatus != NvOdmI2cStatus_Success) { kfree(read_buffer); return -EINVAL; } for (i = 0; i < data_len; i++) { read_buffer[i] = read_buffer[i+1]; } read_buffer[i] = '\0'; return 0; }
int odm_i2c_block_write(struct odm_i2c_dev *dev, unsigned char cmd, unsigned char *buffer, unsigned char buffer_len) { unsigned int i; unsigned char *write_buffer; NvOdmI2cStatus I2cStatus; NvOdmI2cTransactionInfo TransactionInfo; write_buffer = kzalloc(buffer_len + 2, GFP_KERNEL); if (!write_buffer) { return -ENOMEM; } write_buffer[0] = cmd; write_buffer[1] = buffer_len; memcpy(write_buffer + 2, buffer, buffer_len); TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.Address = dev->address; TransactionInfo.Buf = write_buffer; TransactionInfo.NumBytes = buffer_len+2; I2cStatus = NvOdmI2cTransaction(dev->i2c, &TransactionInfo, 2, dev->speed, dev->timeout); kfree(write_buffer); return (I2cStatus == NvOdmI2cStatus_Success) ? 0 : -1; }
int odm_i2c_process_call(struct odm_i2c_dev *dev, unsigned char cmd, unsigned short int write_data, unsigned short int *read_data) { unsigned char write_buffer[3]; unsigned char read_buffer[2]; NvOdmI2cStatus I2cStatus; NvOdmI2cTransactionInfo TransactionInfo[2]; write_buffer[0] = cmd; write_buffer[1] = write_data & 0x00ff; write_buffer[2] = write_data >> 8; TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE | NVODM_I2C_USE_REPEATED_START; TransactionInfo[0].Address = dev->address; TransactionInfo[0].Buf = write_buffer; TransactionInfo[0].NumBytes = 3; TransactionInfo[1].Flags = 0; TransactionInfo[1].Address = dev->address | 0x1; TransactionInfo[1].Buf = read_buffer; TransactionInfo[1].NumBytes = 2; I2cStatus = NvOdmI2cTransaction(dev->i2c, TransactionInfo, 2, dev->speed, dev->timeout); if (I2cStatus != NvOdmI2cStatus_Success) { return -1; } *read_data = read_buffer[0] | (read_buffer[1] << 8); return 0; }
int odm_i2c_read_word(struct odm_i2c_dev *dev, unsigned char cmd, unsigned short int *data) { unsigned char buffer[2]; NvOdmI2cStatus I2cStatus; NvOdmI2cTransactionInfo TransactionInfo[2]; TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE | NVODM_I2C_USE_REPEATED_START; TransactionInfo[0].Address = dev->address; TransactionInfo[0].Buf = &cmd; TransactionInfo[0].NumBytes = 1; TransactionInfo[1].Flags = 0; TransactionInfo[1].Address = dev->address | 0x1; TransactionInfo[1].Buf = buffer; TransactionInfo[1].NumBytes = 2; I2cStatus = NvOdmI2cTransaction(dev->i2c, TransactionInfo, 2, dev->speed, dev->timeout); if (I2cStatus != NvOdmI2cStatus_Success) { logd("I2cAddress=%d, I2cStatus=%d\r\n", dev->address, I2cStatus); return -EINVAL; } *data = buffer[0] | buffer[1] << 8; return 0; }
static bool star_accel_i2c_write_data( star_accel_device *accel, unsigned char reg, unsigned char* data, unsigned char len ) { NvOdmI2cStatus i2c_status; NvOdmI2cTransactionInfo info; unsigned char* transfer_data; transfer_data = (unsigned char*)NvOdmOsAlloc(len+1); transfer_data[0] = reg; NvOdmOsMemcpy( &transfer_data[1], data, (size_t)len); info.Address = accel->i2c_address; info.Buf = transfer_data; info.Flags = NVODM_I2C_IS_WRITE; info.NumBytes = len+1; do{ i2c_status = NvOdmI2cTransaction( accel->h_gen2_i2c, &info, 1, 400, 1000 ); }while(i2c_status == NvOdmI2cStatus_Timeout); if( i2c_status != NvOdmI2cStatus_Success ) { printk("[star accel driver] %s : i2c transaction error(Number = %d)!\n",__func__,i2c_status); goto err; } NvOdmOsFree(transfer_data); return true; err: NvOdmOsFree(transfer_data); return false; }
static NvBool Synaptics_OneTouch_ReadRegisterOnce (Synaptics_OneTouch_Device* hTouch, NvU8* buffer, NvU32 len) { int i=0; NvOdmI2cStatus Error = NvOdmI2cStatus_Timeout; NvOdmI2cTransactionInfo TransactionInfo; TransactionInfo.Address = hTouch->DeviceAddr | 0x1; //read TransactionInfo.Buf = buffer; TransactionInfo.Flags = 0; TransactionInfo.NumBytes = len; for (i = 0; i < SYNAPTICS_I2C_RETRY_COUNT && Error != NvOdmI2cStatus_Success; i++) { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, &TransactionInfo, 1, // transactioncnt SYNAPTICS_I2C_SPEED_KHZ, SYNAPTICS_I2C_TIMEOUT); } if (Error != NvOdmI2cStatus_Success) { NVODMTOUCH_PRINTF(("[ONETOUCH] I2C Read Failure = %d (addr=0x%x)\n", Error, hTouch->DeviceAddr)); return NV_FALSE; } return NV_TRUE; }
static void Adt7461ReadAra(ADT7461PrivData* pPrivData) { NvU32 i; NvU8 Buffer = 0; NvOdmI2cStatus status; NvOdmI2cTransactionInfo TransactionInfo; NV_ASSERT(pPrivData); for (i = 0; i < ADT7461_ARA_RETRY_CNT; i++) { TransactionInfo.Address = (ADT7461_ARA | 0x1); TransactionInfo.Buf = &Buffer; TransactionInfo.Flags = 0; TransactionInfo.NumBytes = 1; status = NvOdmI2cTransaction(pPrivData->hOdmI2C, &TransactionInfo, 1, ADT7461_I2C_SPEED_KHZ, ADT7461_I2C_TIMEOUT_MS); if ((status == NvOdmI2cStatus_SlaveNotFound) || // False alarm ((status == NvOdmI2cStatus_Success) && ((Buffer & 0xFE) == (NvU8)pPrivData->DeviceI2cAddr)) // Cleared ARA ) break; } }
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 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 star_proxi_write_reg(ProximityDevice* proximity, NvU8 reg, NvU8 val) { NvOdmI2cStatus Error; NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[2]; arr[0] = reg; // register address arr[1] = val; // u16 value (lsb-msb) TransactionInfo.Address = proximity->i2c_address; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; do { Error = NvOdmI2cTransaction(proximity->gen2_i2c, &TransactionInfo, 1, 400, 10); } while (Error == NvOdmI2cStatus_Timeout); if (Error != NvOdmI2cStatus_Success) { lprintk(D_PROXI,"I2C Write Failure = %d (addr=0x%x, reg=0x%x, val=0x%0x)\n", Error, proximity->i2c_address, reg, val); return NV_FALSE; } 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; }
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; }
static NvBool I2C_Write (NvOdmVibDeviceHandle hOdmVibrate, NvU8 reg, NvU8 val) { NvOdmI2cStatus Status; NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[2]; arr[0] = reg; arr[1] = val; TransactionInfo.Address = hOdmVibrate->DeviceAddr; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; Status = NvOdmI2cTransaction(hOdmVibrate->hOdmI2c, &TransactionInfo, 1, TPS6586x_I2C_SPEED_KHZ, NV_WAIT_INFINITE); if (Status != NvOdmI2cStatus_Success) { NV_ODM_TRACE(("I2C Write Failure = %d (addr=0x%x, reg=0x%x, val=0x%0x)\n", Status, hOdmVibrate->DeviceAddr, reg, val)); return NV_FALSE; } return NV_TRUE; }
// Dummy write accelerometer in order to workaround a HW bug of ADL340 // Will Remove it once we use new accelerometer static NvBool NvAccDummyI2CSetRegs(TPK_TouchDevice* hTouch) { NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[2]; NvOdmI2cStatus Error; arr[0] = 0x0; arr[1] = 0x0; TransactionInfo.Address = 0x3A; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; // Write dummy data to accelerometer do { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, &TransactionInfo, 1, hTouch->I2cClockSpeedKHz, TPK_I2C_TIMEOUT); } while (Error == NvOdmI2cStatus_Timeout); if (Error != NvOdmI2cStatus_Success) { //NvOdmOsDebugPrintf("error!\r\n"); return NV_FALSE; } //NvOdmOsDebugPrintf("dummy!\r\n"); return NV_TRUE; }
static NvBool I2C_Read(NvOdmVibDeviceHandle hOdmVibrate, NvU8 reg, NvU8 *val) { NvU8 ReadBuffer = 0; NvOdmI2cStatus Status; NvOdmI2cTransactionInfo TransactionInfo[2]; ReadBuffer = reg & 0xFF; TransactionInfo[0].Address = hOdmVibrate->DeviceAddr; TransactionInfo[0].Buf = &ReadBuffer; TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE; TransactionInfo[0].NumBytes = 1; TransactionInfo[1].Address = (hOdmVibrate->DeviceAddr | 0x1); TransactionInfo[1].Buf = &ReadBuffer; TransactionInfo[1].Flags = 0; TransactionInfo[1].NumBytes = 1; Status = NvOdmI2cTransaction(hOdmVibrate->hOdmI2c, &TransactionInfo[0], 2, TPS6586x_I2C_SPEED_KHZ, NV_WAIT_INFINITE); if (Status != NvOdmI2cStatus_Success) { NV_ODM_TRACE(("I2C Read Failure = %d (addr=0x%x, reg=0x%x)\n", Status, hOdmVibrate->DeviceAddr, reg)); return NV_FALSE; } *val = ReadBuffer; return NV_TRUE; }
// set register address before read static NvBool Synaptics_OneTouch_SetReadAddr (Synaptics_OneTouch_Device* hTouch) { int i=0; NvOdmI2cStatus Error = NvOdmI2cStatus_Timeout; NvOdmI2cTransactionInfo TransactionInfo; NvU8 pReg[2]; pReg[0] = OT_DATA_REG_START_ADDR_HIGH; pReg[1] = OT_DATA_REG_START_ADDR_LOW; // set register address TransactionInfo.Address = hTouch->DeviceAddr; TransactionInfo.Buf = (NvU8*)&pReg; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; for (i = 0; i < SYNAPTICS_I2C_RETRY_COUNT && Error != NvOdmI2cStatus_Success; i++) { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, &TransactionInfo, 1, SYNAPTICS_I2C_SPEED_KHZ, SYNAPTICS_I2C_TIMEOUT); } if (Error != NvOdmI2cStatus_Success) { NVODMTOUCH_PRINTF(("[ONETOUCH] I2C Write Failure = %d (addr=0x%x)\n", Error, hTouch->DeviceAddr)); return NV_FALSE; } return NV_TRUE; }
/* * 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; }
// setting register static NvBool Synaptics_OneTouch_WriteRegister (Synaptics_OneTouch_Device* hTouch, NvU8 val) { int i=0; NvOdmI2cStatus Error = NvOdmI2cStatus_Timeout; NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[1]; arr[0] = val; // register address TransactionInfo.Address = hTouch->DeviceAddr; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 1; for (i = 0; i < SYNAPTICS_I2C_RETRY_COUNT && Error != NvOdmI2cStatus_Success; i++) { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, &TransactionInfo, 1, SYNAPTICS_I2C_SPEED_KHZ, SYNAPTICS_I2C_TIMEOUT); } if (Error != NvOdmI2cStatus_Success) { NVODMTOUCH_PRINTF(("[ONETOUCH] I2C Write Failure = %d (addr=0x%x, val=0x%0x)\n", Error, hTouch->DeviceAddr, val)); return NV_FALSE; } return NV_TRUE; }
static NvBool TPK_WriteRegister (TPK_TouchDevice* hTouch, NvU8 reg, NvU8 val) { NvOdmI2cStatus Error; NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[2]; #if TPK_ADL340_WAR // dummy write Error = NvAccDummyI2CSetRegs(hTouch); #endif arr[0] = reg; arr[1] = val; TransactionInfo.Address = hTouch->DeviceAddr; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; do { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, &TransactionInfo, 1, hTouch->I2cClockSpeedKHz, TPK_I2C_TIMEOUT); } while (Error == NvOdmI2cStatus_Timeout); if (Error != NvOdmI2cStatus_Success) { NVODMTOUCH_PRINTF(("I2C Write Failure = %d (addr=0x%x, reg=0x%x, val=0x%0x)\n", Error, hTouch->DeviceAddr, reg, val)); return NV_FALSE; } return NV_TRUE; }
static NvBool WriteReg( NvOdmAccelHandle hDevice, NvU8 RegAddr, 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; } s_WriteBuffer[0] = RegAddr; 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 RegAddr (from where data is to be read). if (NvOdmI2cTransaction(hDevice->hOdmI2C, &TransactionInfo, 1, I2C_CLK_SPEED, I2C_ACCELRATOR_TRANSACTION_TIMEOUT) != 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; }
static NvBool TPK_ReadRegisterOnce (TPK_TouchDevice* hTouch, NvU8 reg, NvU8* buffer, NvU32 len) { NvOdmI2cStatus Error; NvOdmI2cTransactionInfo TransactionInfo[2 * TPK_MAX_READS]; int reads = (len+(TPK_MAX_PACKET_SIZE-1))/TPK_MAX_PACKET_SIZE; int left = len; int i; NV_ASSERT(len <= TPK_MAX_READ_BYTES); #if TPK_ADL340_WAR // dummy write Error = NvAccDummyI2CSetRegs(hTouch); #endif //////////////////////////////////////////////////////////////////////////// // For multi-byte reads, the TPK panel supports just sending the first // address and then keep reading registers (non-standard SMBus operation). // The limit for I2C packets is 8 bytes, so we read up to 8 bytes per // multi-byte read transaction. //////////////////////////////////////////////////////////////////////////// for (i = 0; i < reads; i++) { int ind = i*2; TransactionInfo[ind].Address = hTouch->DeviceAddr; TransactionInfo[ind].Buf = ® TransactionInfo[ind].Flags = NVODM_I2C_IS_WRITE; TransactionInfo[ind].NumBytes = 1; ind++; TransactionInfo[ind].Address = hTouch->DeviceAddr | 0x1; TransactionInfo[ind].Buf = buffer + i*TPK_MAX_PACKET_SIZE; TransactionInfo[ind].Flags = 0; TransactionInfo[ind].NumBytes = left > TPK_MAX_PACKET_SIZE ? TPK_MAX_PACKET_SIZE : left; left -= TPK_MAX_PACKET_SIZE; } do { Error = NvOdmI2cTransaction(hTouch->hOdmI2c, TransactionInfo, reads * 2, hTouch->I2cClockSpeedKHz, TPK_I2C_TIMEOUT); } while (Error == NvOdmI2cStatus_Timeout); if (Error != NvOdmI2cStatus_Success) { NVODMTOUCH_PRINTF(("I2C Read Failure = %d (addr=0x%x, reg=0x%x)\n", Error, hTouch->DeviceAddr, reg)); return NV_FALSE; } return NV_TRUE; }
static NvBool Adt7461ReadReg( ADT7461PrivData* pPrivData, const ADT7461RegisterInfo* pReg, NvU8* pData) { NvU32 i; NvU8 Buffer = 0; NvOdmI2cStatus status; NvOdmI2cTransactionInfo TransactionInfo[2]; NV_ASSERT(pPrivData && pReg && pData); NV_ASSERT(pReg->RdAddr != ADT7461_INVALID_ADDR); // TODO: possible optimization - is shadow pointer matches register // address, just send one read transaction (can be done only if Read/Wr // Reg routines are serialized). for (i = 0; i < ADT7461_I2C_RETRY_CNT; i++) { Buffer = pReg->RdAddr; TransactionInfo[0].Address = pPrivData->DeviceI2cAddr; TransactionInfo[0].Buf = &Buffer; TransactionInfo[0].Flags = NVODM_I2C_IS_WRITE; TransactionInfo[0].NumBytes = 1; TransactionInfo[1].Address = (pPrivData->DeviceI2cAddr | 0x1); TransactionInfo[1].Buf = &Buffer; TransactionInfo[1].Flags = 0; TransactionInfo[1].NumBytes = 1; status = NvOdmI2cTransaction(pPrivData->hOdmI2C, &TransactionInfo[0], 2, ADT7461_I2C_SPEED_KHZ, ADT7461_I2C_TIMEOUT_MS); if (status == NvOdmI2cStatus_Success) break; } switch (status) { case NvOdmI2cStatus_Success: pPrivData->ShadowRegPtr = pReg->RdAddr; *pData = Buffer; return NV_TRUE; case NvOdmI2cStatus_Timeout: NVODM_ADT7461_PRINTF(("ADT7461: ReadReg Timeout\n")); return NV_FALSE; case NvOdmI2cStatus_SlaveNotFound: default: NVODM_ADT7461_PRINTF(("ADT7461: ReadReg SlaveNotFound\n")); return NV_FALSE; } }
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 ReadReg( NvOdmEcompassHandle hDevice, NvU8 RegAddr, NvU8* value, NvU32 len) { NvOdmI2cTransactionInfo TransactionInfo; if ( (NULL == hDevice) || (NULL == value) || (len > I2C_ECOMPASS_PACKET_SIZE-1 ) ) { NVODMECOMPASS_PRINTF(("NvOdmI2c Get Regs Failed, max size is %d bytes\n", I2C_ECOMPASS_PACKET_SIZE-1)); return NV_FALSE; } s_WriteBuffer[0] = RegAddr; TransactionInfo.Address = hDevice->nDevAddr; TransactionInfo.Buf = s_WriteBuffer; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 1; // Write the accelerometor RegAddr (from where data is to be read). if (NvOdmI2cTransaction(hDevice->hOdmI2C, &TransactionInfo, 1, NVODMECOMPASS_I2C_SPEED_KHZ, I2C_ECOMPASS_TRANSACTION_TIMEOUT) != NvOdmI2cStatus_Success) return NV_FALSE; s_ReadBuffer[0] = 0; TransactionInfo.Address = (hDevice->nDevAddr| 0x1); TransactionInfo.Buf = s_ReadBuffer; TransactionInfo.Flags = 0; TransactionInfo.NumBytes = len; //Read the data from the eeprom at the specified RegAddr if (NvOdmI2cTransaction(hDevice->hOdmI2C, &TransactionInfo, 1, NVODMECOMPASS_I2C_SPEED_KHZ, I2C_ECOMPASS_TRANSACTION_TIMEOUT) != NvOdmI2cStatus_Success) return NV_FALSE; NvOdmOsMemcpy(value, &s_ReadBuffer[0], len); return NV_TRUE; }
NvBool Max8907bI2cRead8( NvOdmPmuDeviceHandle hDevice, NvU8 Addr, NvU8 *Data) { NvU32 i; NvU8 ReadBuffer = 0; NvOdmI2cStatus status = NvOdmI2cStatus_Success; Max8907bPrivData *hPmu = (Max8907bPrivData*)hDevice->pPrivate; NvOdmI2cTransactionInfo TransactionInfo[2]; for (i = 0; i < MAX8907B_I2C_RETRY_CNT; i++) { NvU32 TransactionCount = 0; // Write the PMU offset ReadBuffer = Addr & 0xFF; TransactionInfo[TransactionCount].Address = hPmu->DeviceAddr; TransactionInfo[TransactionCount].Buf = &ReadBuffer; TransactionInfo[TransactionCount].Flags = NVODM_I2C_IS_WRITE | NVODM_I2C_USE_REPEATED_START; TransactionInfo[TransactionCount++].NumBytes = 1; TransactionInfo[TransactionCount].Address = (hPmu->DeviceAddr | 0x1); TransactionInfo[TransactionCount].Buf = &ReadBuffer; TransactionInfo[TransactionCount].Flags = 0; TransactionInfo[TransactionCount++].NumBytes = 1; // Read data from PMU at the specified offset status = NvOdmI2cTransaction(hPmu->hOdmI2C, &TransactionInfo[0], TransactionCount, MAX8907B_I2C_SPEED_KHZ, NV_WAIT_INFINITE); if (status == NvOdmI2cStatus_Success) { *Data = ReadBuffer; return NV_TRUE; } } // Transaction Error switch (status) { case NvOdmI2cStatus_Timeout: NVODMPMU_PRINTF(("NvOdmPmuI2cRead8 Failed: Timeout\n")); break; case NvOdmI2cStatus_SlaveNotFound: default: NVODMPMU_PRINTF(("NvOdmPmuI2cRead8 Failed: SlaveNotFound\n")); break; } return NV_FALSE; }
/* * 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; }
/* Send byte protocol*/ int odm_i2c_send_byte(struct odm_i2c_dev *dev, unsigned char data) { NvOdmI2cTransactionInfo TransactionInfo; NvOdmI2cStatus I2cStatus; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.Address = dev->address; TransactionInfo.Buf = &data; TransactionInfo.NumBytes = 1; I2cStatus = NvOdmI2cTransaction(dev->i2c, &TransactionInfo, 1, dev->speed, dev->timeout); return (I2cStatus == NvOdmI2cStatus_Success) ? 0 : -1; }
int odm_i2c_receive_byte(struct odm_i2c_dev *dev, unsigned char *data) { NvOdmI2cTransactionInfo TransactionInfo; NvOdmI2cStatus I2cStatus; TransactionInfo.Flags = 0; TransactionInfo.Address = dev->address; TransactionInfo.Buf = data; TransactionInfo.NumBytes = 1; I2cStatus = NvOdmI2cTransaction(dev->i2c, &TransactionInfo, 1, dev->speed, dev->timeout); return (I2cStatus == NvOdmI2cStatus_Success) ? 0 : -1; }
static NvBool MUIC_Reg_Write (Muic_Device* hMuicHandle, NvU8 reg, NvU8 val) { #ifdef _MUIC_GPIO_I2C_ unsigned char data[2] = {0,}; NvBool ret = NV_FALSE; data[0] = reg; data[1] = val; if ( simi2c_write(hMuicHandle,0x44,data,2,1) < 1) { printk("i2c read error\n"); return ret; } return NV_TRUE; #else NvOdmI2cStatus Error; NvOdmI2cTransactionInfo TransactionInfo; NvU8 arr[2]; arr[0] = reg; // register address arr[1] =val; // u16 value (lsb-msb) TransactionInfo.Address = hMuicHandle->DeviceAddr; TransactionInfo.Buf = arr; TransactionInfo.Flags = NVODM_I2C_IS_WRITE; TransactionInfo.NumBytes = 2; do { Error = NvOdmI2cTransaction(hMuicHandle->hOdmI2c, &TransactionInfo, 1, MUIC_I2C_SPEED_KHZ, MUIC_I2C_TIMEOUT); } while (Error == NvOdmI2cStatus_Timeout); if (Error != NvOdmI2cStatus_Success) { NVODMMUIC_PRINTF(("I2C Write Failure = %d (addr=0x%x, reg=0x%x, val=0x%0x)\n", Error, hMuicHandle->DeviceAddr, reg, val)); return NV_FALSE; } return NV_TRUE; #endif }