static int lp5521_load_program(struct lp5521_chip *chip, u8 *pattern)
{
struct i2c_client *client = chip->client;
int ret = 0;
/* Enter load program mode for all led channels */
ret |= lp5521_write(client, LP5521_REG_OP_MODE, 0x15); /* 0001 0101 */
if (ret)
return ret;
if (chip->red)
ret |= i2c_smbus_write_i2c_block_data(client,
LP5521_REG_R_PROG_MEM,
LP5521_PROGRAM_LENGTH,
pattern);
if (chip->green)
ret |= i2c_smbus_write_i2c_block_data(client,
LP5521_REG_G_PROG_MEM,
LP5521_PROGRAM_LENGTH,
pattern);
if (chip->blue)
ret |= i2c_smbus_write_i2c_block_data(client,
LP5521_REG_B_PROG_MEM,
LP5521_PROGRAM_LENGTH,
pattern);
return ret;
}
static int bcmpmu_i2c_write_device_direct_bulk(struct bcmpmu *bcmpmu, int map, int addr, unsigned int *val, int len)
{
int err;
struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
u8 *uval = (u8 *)val;
int i;
if (addr + len > acc->pagesize) return -ENODEV;
for (i = 0; i < len; i++)
uval[i] = (u8)val[i];
bcmpmu_i2c_lock(acc);
err = bcmpmu_i2c_retry(bcmpmu);
if (err < 0)
goto err;
if (map == 0)
err = i2c_smbus_write_i2c_block_data(acc->i2c_client, addr, len, uval);
else if (map == 1)
err = i2c_smbus_write_i2c_block_data(acc->i2c_client1, addr, len, uval);
else err = -EIO;
last_i2c_trans = I2C_TRANS_WRITE;
bcmpmu_i2c_unlock(acc);
err:
if (err < 0) return err;
return 0;
}
static bool bq27541_authenticate(struct i2c_client *client)
{
#ifdef CONFIG_MACH_FIND7OP
return true;
#else
char recv_buf[MESSAGE_LEN]= {0x0};
char send_buf[MESSAGE_LEN]= {0x0};
char result[MESSAGE_LEN]= {0x0};
char Key[KEY_LEN]= {0x77,0x30,0xa1,0x28,0x0a,0xa1,0x13,0x20,0xef,0xcd,0xab,0x89,0x67,0x45,0x23,0x01};
char checksum_buf[1] = {0x0};
char authen_cmd_buf[1] = {0x00};
int i,rc;
pr_info("%s Enter\n",__func__);
// step 0: produce 20 bytes random data and checksum
get_random_bytes(send_buf,20);
for(i = 0; i < 20; i++) {
checksum_buf[0] = checksum_buf[0] + send_buf[i];
}
checksum_buf[0] = 0xff - (checksum_buf[0]&0xff);
/* step 1: unseal mode->write 0x01 to blockdatactrl
authen_cmd_buf[0] = 0x01;
rc = i2c_smbus_write_i2c_block_data(client,BLOCKDATACTRL,1,&authen_cmd_buf[0]);
} */
// step 1: seal mode->write 0x00 to dataflashblock
rc = i2c_smbus_write_i2c_block_data(client,DATAFLASHBLOCK,1,&authen_cmd_buf[0]);
if( rc < 0 ) {
pr_info("%s i2c write error\n",__func__);
return false;
}
// step 2: write 20 bytes to authendata_reg
i2c_smbus_write_i2c_block_data(client,AUTHENDATA,MESSAGE_LEN,&send_buf[0]);
msleep(1);
// step 3: write checksum to authenchecksum_reg for compute
i2c_smbus_write_i2c_block_data(client,AUTHENCHECKSUM,1,&checksum_buf[0]);
msleep(50);
// step 4: read authendata
i2c_smbus_read_i2c_block_data(client,AUTHENDATA,MESSAGE_LEN,&recv_buf[0]);
// step 5: phone do hmac(sha1-generic) algorithm
BQ27541_HMACSHA1_authenticate(send_buf,Key,result);
// step 6: compare recv_buf from bq27541 and result by phone
rc = strncmp(recv_buf,result,MESSAGE_LEN);
if(rc == 0) {
pr_info("bq27541_authenticate success\n");
return true;
}
pr_info("bq27541_authenticate error,dump buf:\n");
for(i = 0; i < 20; i++) {
pr_info("send_buf[%d]:0x%x,recv_buf[%d]:0x%x ?= result[%d]:0x%x\n",i,send_buf[i],i,recv_buf[i],i,result[i]);
}
return false;
#endif
}
static int pic16f_fw_write(unsigned char *data_buf,unsigned int offset,unsigned int length)
{
unsigned int count = 0;
unsigned char zero_buf[1] = {0};
unsigned char temp_buf[1] = {0};
unsigned char addr_buf[2] = {0x00,0x00};
unsigned char temp;
int i,rc;
count = offset;
//write data begin
while(count < (offset + length))
{
addr_buf[0] = data_buf[count + 1];
addr_buf[1] = data_buf[count];
//printk("%s write data addr_buf[0]:0x%x,addr_buf[1]:0x%x\n",__func__,addr_buf[0],addr_buf[1]);
rc = i2c_smbus_write_i2c_block_data(pic16F_client,0x01,2,&addr_buf[0]);
if(rc < 0){
pr_err("%s i2c_write 0x01 error\n",__func__);
return -1;
}
//byte_count = buf[count];
//swap low byte and high byte begin
//because LSB is before MSB in buf,but pic16F receive MSB first
for(i = 0;i < 2 * BYTES_TO_WRITE;i = (i+2)){
temp = data_buf[count+BYTE_OFFSET+i];
data_buf[count+BYTE_OFFSET+i] = data_buf[count+BYTE_OFFSET+i+1];
data_buf[count+BYTE_OFFSET+i+1] = temp;
}
//swap low byte and high byte end
//write 16 bytes data to pic16F
i2c_smbus_write_i2c_block_data(pic16F_client,0x02,BYTES_TO_WRITE,&data_buf[count+BYTE_OFFSET]);
i2c_smbus_write_i2c_block_data(pic16F_client,0x05,1,&zero_buf[0]);
i2c_smbus_read_i2c_block_data(pic16F_client,0x05,1,&temp_buf[0]);
//printk("lfc read 0x05,temp_buf[0]:0x%x\n",temp_buf[0]);
//write 16 bytes data to pic16F again
i2c_smbus_write_i2c_block_data(pic16F_client,0x02,BYTES_TO_WRITE,&data_buf[count+BYTE_OFFSET+BYTES_TO_WRITE]);
i2c_smbus_write_i2c_block_data(pic16F_client,0x05,1,&zero_buf[0]);
i2c_smbus_read_i2c_block_data(pic16F_client,0x05,1,&temp_buf[0]);
//printk("lfc read again 0x05,temp_buf[0]:0x%x\n",temp_buf[0]);
count = count + BYTE_OFFSET + 2 * BYTES_TO_WRITE;
msleep(2);
//pr_err("%s count:%d,offset:%d,length:%d\n",__func__,count,offset,length);
if(count > (offset + length - 1)){
break;
}
}
return 0;
}
void i2c_access::write(const unsigned int data_addr, const unsigned char *values, size_t length)
{
int ret;
std::string error_msg;
if (fd < 0) {
error_msg = "member is not initialized";
throw error_msg;
}
if (data_addr < 0 || data_addr > 0xff) {
error_msg = "Data address invalid!";
throw error_msg;
}
for (unsigned int i=0; i<=retry_times; i++) {
ret = i2c_smbus_write_i2c_block_data(fd, data_addr, (__u8)length, (__u8*)values);
if (ret == 0) {
break;
} else {
if (i < retry_times) {
usleep(10000);
}
}
}
if (ret < 0) {
char addr_str[256] = {0};
snprintf(addr_str, sizeof(addr_str), "data_addr=0x%02x, length=%d, ", data_addr, length);
error_msg = "I2C bus write failed : ";
error_msg.append(addr_str);
error_msg.append(strerror(ret * -1));
throw error_msg;
}
}
static int mma7660_rx_data(struct i2c_client *client, char *rxData, int length)
{
int ret = 0;
char reg = rxData[0];
ret = i2c_smbus_write_i2c_block_data(client, reg, length, rxData);
return (ret > 0)? 0 : ret;
}
static int lp855x_i2c_write(struct lp855x *lp, u8 reg, u8 *data, u8 len)
{
s32 ret;
ret = i2c_smbus_write_i2c_block_data(lp->client, reg, len, data);
return ret;
}
static int i2c_block_write(struct stmpe *stmpe, u8 reg, u8 length,
const u8 *values)
{
struct i2c_client *i2c = stmpe->client;
return i2c_smbus_write_i2c_block_data(i2c, reg, length, values);
}
static int k3g_resume(struct device *dev)
{
int err = 0;
struct i2c_client *client = to_i2c_client(dev);
struct k3g_data *k3g_data = i2c_get_clientdata(client);
struct k3g_platform_data *pdata;
if(DEBUG_FUNC_TRACE & debug_mask)
printk(KERN_INFO "%s: line %d\n", __func__, __LINE__);
pdata = client->dev.platform_data;
if (pdata->power_on){
if(DEBUG_GEN_INFO & debug_mask)
printk(KERN_INFO "%s: goes to resume, power on\n", __func__);
pdata->power_on(1<<SENSOR_TYPE_GYROSCOPE);
mdelay(1);
}
if (k3g_data->enable) {
mutex_lock(&k3g_data->lock);
mdelay(300);
k3g_restart_fifo(k3g_data);
if (!k3g_data->interruptible)
hrtimer_start(&k3g_data->timer,
k3g_data->polling_delay, HRTIMER_MODE_REL);
err = i2c_smbus_write_i2c_block_data(client,
CTRL_REG1 | AC, sizeof(k3g_data->ctrl_regs),
k3g_data->ctrl_regs);
mutex_unlock(&k3g_data->lock);
}
return err;
}
static int bebot_base_pass(struct senseact_device *senseact, unsigned int type, unsigned int index, unsigned int count, int *values)
{
struct bebot_base_device *base = senseact_get_drvdata(senseact);
struct i2c_client *client = base->client;
int buffer[SETSPEED_COUNT];
int i, n, rc;
for (i = 0; i < count; i++) {
switch (type) {
case SENSEACT_TYPE_SPEED:
if ((index + i) < SETSPEED_COUNT) {
base->speed[index + i] = SPEED_TO_REG(values[i]);
}
break;
case SENSEACT_TYPE_SYNC:
rc = i2c_smbus_write_i2c_block_data(client, SETSPEED_REG, SETSPEED_SIZE, base->speed);
if (rc < 0)
return rc;
for (n = 0; n < SETSPEED_COUNT; n++)
buffer[n] = SPEED_FROM_REG((int) base->speed[n]);
senseact_pass_actions(senseact, SENSEACT_TYPE_SPEED, SENSEACT_PREFIX_MILLI, 0, SETSPEED_COUNT, buffer);
senseact_sync(senseact, SENSEACT_SYNC_ACTOR);
break;
}
}
return 0;
}
static int d2041_i2c_write_device(struct d2041 * const d2041, char const reg,
int const bytes, const u8 *src /*void * const src*/)
{
int ret = 0;
// Redundant. It already checked in d2041_reg_read & write function
//if ((reg + bytes) > D2041_MAX_REGISTER_CNT) {
// printk(KERN_ERR "Bad input to d2041_i2c_write_device(0x%x, %d)\n", reg, bytes);
// return -EINVAL;
//}
#ifdef CONFIG_D2041_USE_SMBUS_API
if(bytes > 1)
ret = i2c_smbus_write_i2c_block_data(d2041->i2c_client, reg, bytes, src);
else
ret = i2c_smbus_write_byte_data(d2041->i2c_client, reg, *src);
return ret;
#else
u8 msg[bytes + 1];
msg[0] = reg;
memcpy(&msg[1], src, bytes);
ret = i2c_master_send(d2041->i2c_client, msg, bytes + 1);
if (ret < 0)
return ret;
if (ret != bytes + 1)
return -EIO;
return 0;
#endif /* CONFIG_D2041_USE_SMBUS_API */
}
static int leds_i2c_write_all(struct i2c_client *client)
{
struct an30259a_data *data = i2c_get_clientdata(client);
int ret;
/*we need to set all the configs setting first, then LEDON later*/
mutex_lock(&data->mutex);
ret = i2c_smbus_write_i2c_block_data(client,
AN30259A_REG_SEL | AN30259A_CTN_RW_FLG,
AN30259A_REG_MAX - AN30259A_REG_SEL,
&data->shadow_reg[AN30259A_REG_SEL]);
if (ret < 0) {
dev_err(&client->adapter->dev,
"%s: failure on i2c block write\n",
__func__);
goto exit;
}
ret = i2c_smbus_write_byte_data(client, AN30259A_REG_LEDON,
data->shadow_reg[AN30259A_REG_LEDON]);
if (ret < 0) {
dev_err(&client->adapter->dev,
"%s: failure on i2c byte write\n",
__func__);
goto exit;
}
mutex_unlock(&data->mutex);
return 0;
exit:
mutex_unlock(&data->mutex);
return ret;
}
static int silead_ts_load_fw(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct silead_ts_data *data = i2c_get_clientdata(client);
unsigned int fw_size, i;
const struct firmware *fw;
struct silead_fw_data *fw_data;
int ret;
ret = request_firmware(&fw, data->fw_name, dev);
if (ret) {
dev_err(dev, "Firmware request error %d\n", ret);
return ret;
}
fw_size = fw->size / sizeof(*fw_data);
fw_data = (struct silead_fw_data *)fw->data;
for (i = 0; i < fw_size; i++) {
ret = i2c_smbus_write_i2c_block_data(client, fw_data[i].offset,
4, (u8 *)&fw_data[i].val);
if (ret) {
dev_err(dev, "Firmware load error %d\n", ret);
goto release_fw_err;
}
}
release_firmware(fw);
return 0;
release_fw_err:
release_firmware(fw);
return ret;
}
int i2c_lcd_puts( char *str )
{
i2c_smbus_write_i2c_block_data( i2c_fd, LCD_RS_DATA_WRITE, strlen(str), (unsigned char *)str );
usleep(30);
return 1;
}
int get_fw_version()
{
__u8 READ_CMD[11]={0x0B,0x00,0x00,0x00,0x52,0x00,0x00,0x40,0x00,0x10, 0xAD};
__u8 FW_VER[2]={0};
int fw=0;
int ret=0;
int i=0;
ret=i2c_smbus_write_i2c_block_data(i2c_fd, 0x0B, 10, &READ_CMD[1]);
i2c_smbus_read_i2c_block_data(i2c_fd, FC_CMD_READ_ACK, &FC_RX_INFO[0]);
if (FC_RX_INFO[0]!=FC_CMD_READ_ACK ){//Check Return 0xFC
printf("FC_RX_INFO[0]=%x\n",FC_RX_INFO[0]);
return -1;
}
//printf("%s\n",&FC_RX_INFO[0]);
for(i=0;i<2;i++)
FW_VER[i]=FC_RX_INFO[i+1];
fw=(int)(FW_VER[0]*100)+(int)FW_VER[1];
return fw;
}
static ssize_t ds1682_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
struct i2c_client *client = to_i2c_client(dev);
u64 val;
__le32 val_le;
int rc;
dev_dbg(dev, "ds1682_store() called on %s\n", attr->attr.name);
/* Decode input */
rc = kstrtoull(buf, 0, &val);
if (rc < 0) {
dev_dbg(dev, "input string not a number\n");
return -EINVAL;
}
/* Special case: the 32 bit regs are time values with 1/4s
* resolution, scale input down to quarter-seconds */
if (sattr->nr == 4)
do_div(val, 250);
/* write out the value */
val_le = cpu_to_le32(val);
rc = i2c_smbus_write_i2c_block_data(client, sattr->index, sattr->nr,
(u8 *) & val_le);
if (rc < 0) {
dev_err(dev, "register write failed; reg=0x%x, size=%i\n",
sattr->index, sattr->nr);
return -EIO;
}
return count;
}
/**
* @brief Write a series of bytes to an I2c device using SMBus protocol.
*
*****************************************************************************/
halReturn_t HalSmbusWriteBlock(uint8_t command, uint8_t const *blockData,
uint8_t length)
{
halReturn_t retStatus;
int32_t status;
retStatus = I2cAccessCheck();
if (retStatus != HAL_RET_SUCCESS)
{
return retStatus;
}
if(length > I2C_SMBUS_BLOCK_MAX)
{
SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE,
"HalSmbusWriteBlock, bufferLen param too big (%d) max size (%d)!\n",
length, I2C_SMBUS_BLOCK_MAX);
return HAL_RET_PARAMETER_ERROR;
}
status = i2c_smbus_write_i2c_block_data(gMhlDevice.pI2cClient, command,
length, blockData);
if (status < 0)
{
SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE,
"i2c_smbus_write_i2c_block_data returned error: %d\n",status);
return HAL_RET_FAILURE;
}
return HAL_RET_SUCCESS;
}
static int lsm330dlc_gyro_resume(struct device *dev)
{
int err = 0;
struct i2c_client *client = to_i2c_client(dev);
struct lsm330dlc_gyro_data *data = i2c_get_clientdata(client);
if (data->enable) {
mutex_lock(&data->lock);
err = i2c_smbus_write_i2c_block_data(client,
CTRL_REG1 | AC, sizeof(data->ctrl_regs),
data->ctrl_regs);
if (data->interruptible) {
enable_irq(data->client->irq);
lsm330dlc_gyro_restart_fifo(data);
}
if (!data->interruptible)
hrtimer_start(&data->timer,
data->polling_delay, HRTIMER_MODE_REL);
mutex_unlock(&data->lock);
}
return err;
}
static int silead_ts_load_fw(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct silead_ts_data *data = i2c_get_clientdata(client);
unsigned int fw_size, i;
const struct firmware *fw;
struct silead_fw_data *fw_data;
int error;
dev_dbg(dev, "Firmware file name: %s", data->fw_name);
error = request_firmware(&fw, data->fw_name, dev);
if (error) {
dev_err(dev, "Firmware request error %d\n", error);
return error;
}
fw_size = fw->size / sizeof(*fw_data);
fw_data = (struct silead_fw_data *)fw->data;
for (i = 0; i < fw_size; i++) {
error = i2c_smbus_write_i2c_block_data(client,
fw_data[i].offset,
4,
(u8 *)&fw_data[i].val);
if (error) {
dev_err(dev, "Firmware load error %d\n", error);
break;
}
}
release_firmware(fw);
return error ?: 0;
}
/* [email protected], 2014/03/10 Modify for 14001 */ static int bq27541_batt_type_detect(struct i2c_client *client) { char blockA_cmd_buf[1] = {0x01}; char rc = 0; char recv_buf[TYPE_INFO_LEN] = {0x0}; int i = 0; rc = i2c_smbus_write_i2c_block_data(client,DATAFLASHBLOCK,1,&blockA_cmd_buf[0]); if( rc < 0 ) { pr_info("%s i2c write error\n",__func__); return 0; } msleep(30); //it is needed i2c_smbus_read_i2c_block_data(client,AUTHENDATA,TYPE_INFO_LEN,&recv_buf[0]); if((recv_buf[0] == 0x01) && (recv_buf[1] == 0x09) && (recv_buf[2] == 0x08) && (recv_buf[3] == 0x06)) rc = BATTERY_2700MA; else if((recv_buf[0] == 0x02) && (recv_buf[1] == 0x00) && (recv_buf[2] == 0x01) && (recv_buf[3] == 0x03)) rc = BATTERY_3000MA; else { for(i = 0; i < TYPE_INFO_LEN; i++) pr_info("%s error,recv_buf[%d]:0x%x\n",__func__,i,recv_buf[i]); rc = BATTERY_2700MA; } pr_info("%s battery_type:%d\n",__func__,rc); return rc; }
// -----------------------------------------------------------------------------
int
iI2cWriteRegBlock (int fd, uint8_t reg, const uint8_t * values, uint8_t len) {
int i = i2c_smbus_write_i2c_block_data (fd, reg, len, values);
vI2cPrintDebug (i, __func__);
return i;
}
//清除eeprom data
//因為目前不會用到後面的儲存空間, 只從 0x00 清到 0xbf
int EarseEEPROMData()
{
int fd, r, returnValue;
unsigned char eraseArray[32];
memset(eraseArray, 0, sizeof(char)*32);
fd = open(I2CDEVICEADDR, O_RDWR);
if(fd < 0)
{
perror("Open Fail");
return 1;
}
r = ioctl(fd, I2C_SLAVE, EEPROMADDRESS);
if(r < 0)
{
perror("Selecting i2c device");
return 1;
}
printf("[%s|%d]", __func__, __LINE__);
i2c_smbus_write_byte_data(fd, 0x00, 0x00);
eraseArray[0] = 0x00;
returnValue = i2c_smbus_write_i2c_block_data(fd, 0x00, 0x20, &eraseArray[0]);
printf("%d ", returnValue);
nanosleep((const struct timespec[]){{0, 5000000L}}, NULL);
static int asuspec_dockram_write_storageinfo(int cmd, int length)
{
int ret = 0;
if (ec_chip->ec_ram_init != ASUSPEC_MAGIC_NUM){
ASUSPEC_ERR("DockRam is not ready.\n");
return -1;
}
if (ec_chip->op_mode){
ASUSPEC_ERR("It's not allowed to access dockram under FW update mode.\n");
return -2;
}
if (ec_chip->i2c_err_count > ASUSPEC_I2C_ERR_TOLERANCE){
return -3;
}
ret = i2c_smbus_write_i2c_block_data(&dockram_client, cmd, length, ec_chip->i2c_dm_storage);
if (ret < 0) {
ASUSPEC_ERR("Fail to write dockram data, status %d\n", ret);
} else {
ec_chip->i2c_err_count = 0;
}
return ret;
}
static int leds_i2c_write_all(struct i2c_client *client)
{
struct ktd2026_data *data = i2c_get_clientdata(client);
int ret = 0;
int retry = 0;
mutex_lock(&data->mutex);
do
{
ret = i2c_smbus_write_i2c_block_data(client,
KTD2026_REG_EN_RST, KTD2026_REG_MAX,
&data->shadow_reg[KTD2026_REG_EN_RST]);
if (ret < 0) {
dev_err(&client->adapter->dev,
"%s: failure on i2c block write\n",
__func__);
retry++;
if(retry > 10)
{
dev_err(&client->adapter->dev,
"%s: retry > 10 : Fatal i2c error\n",
__func__);
break;
}
msleep(100);
}
} while(ret < 0);
mutex_unlock(&data->mutex);
return ret;
}
static int ds3232_set_time(struct device *dev, struct rtc_time *time)
{
struct i2c_client *client = to_i2c_client(dev);
u8 buf[7];
buf[0] = bin2bcd(time->tm_sec);
buf[1] = bin2bcd(time->tm_min);
buf[2] = bin2bcd(time->tm_hour);
buf[3] = bin2bcd(time->tm_wday + 1);
buf[4] = bin2bcd(time->tm_mday);
buf[5] = bin2bcd(time->tm_mon + 1);
if (time->tm_year >= 100) {
buf[5] |= 0x80;
buf[6] = bin2bcd(time->tm_year - 100);
} else {
buf[6] = bin2bcd(time->tm_year);
}
return i2c_smbus_write_i2c_block_data(client,
DS3232_REG_SECONDS, 7, buf);
}
static int arduino_write(arduino_t* arduino,
unsigned long value,
int reg, int nbytes)
{
unsigned char buf[4];
int i;
int err;
if (nbytes > 4) {
return -1;
}
for (i = nbytes - 1; i >= 0; i--) {
buf[i] = value & 0xff;
value >>= 8;
}
err = i2c_smbus_write_i2c_block_data(arduino->fd, reg, nbytes, buf);
if (err != 0) {
log_err("Arduino: Failed to write the data");
}
usleep(10000);
return err;
}
/**
* inv_read_fifo() - Transfer data from FIFO to ring buffer.
*/
int inv_read_ami306_fifo(struct iio_dev *indio_dev)
{
struct inv_ami306_state_s *st = iio_priv(indio_dev);
struct iio_buffer *ring = indio_dev->buffer;
int result, status, d_ind;
char b;
char *tmp;
s64 tmp_buf[2];
result = i2c_smbus_read_i2c_block_data(st->i2c, REG_AMI_STA1, 1, &b);
if (result < 0)
goto end_session;
if (b & AMI_STA1_DRDY_BIT) {
status = ami306_read_raw_data(st, st->compass_data);
if (status) {
pr_err("error reading raw\n");
goto end_session;
}
tmp = (unsigned char *)tmp_buf;
d_ind = put_scan_to_buf(indio_dev, tmp, st->compass_data,
INV_AMI306_SCAN_MAGN_X);
if (ring->scan_timestamp)
tmp_buf[(d_ind + 7)/8] = st->timestamp;
ring->access->store_to(indio_dev->buffer, tmp);
} else if (b & AMI_STA1_DOR_BIT)
pr_err("not ready\n");
end_session:
b = AMI_CTRL3_FORCE_BIT;
result = i2c_smbus_write_i2c_block_data(st->i2c, REG_AMI_CTRL3, 1, &b);
return IRQ_HANDLED;
}
static ssize_t ds1682_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
struct i2c_client *client = to_i2c_client(dev);
char *endp;
u64 val;
__le32 val_le;
int rc;
dev_dbg(dev, "ds1682_store() called on %s\n", attr->attr.name);
val = simple_strtoull(buf, &endp, 0);
if (buf == endp) {
dev_dbg(dev, "input string not a number\n");
return -EINVAL;
}
if (sattr->nr == 4)
do_div(val, 250);
val_le = cpu_to_le32(val);
rc = i2c_smbus_write_i2c_block_data(client, sattr->index, sattr->nr,
(u8 *) & val_le);
if (rc < 0) {
dev_err(dev, "register write failed; reg=0x%x, size=%i\n",
sattr->index, sattr->nr);
return -EIO;
}
return count;
}
static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
struct rs5c372 *rs5c = i2c_get_clientdata(client);
unsigned char buf[7];
int addr;
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
"mday=%d, mon=%d, year=%d, wday=%d\n",
__func__,
tm->tm_sec, tm->tm_min, tm->tm_hour,
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
addr = RS5C_ADDR(RS5C372_REG_SECS);
buf[0] = bin2bcd(tm->tm_sec);
buf[1] = bin2bcd(tm->tm_min);
buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
buf[3] = bin2bcd(tm->tm_wday);
buf[4] = bin2bcd(tm->tm_mday);
buf[5] = bin2bcd(tm->tm_mon + 1);
buf[6] = bin2bcd(tm->tm_year - 100);
if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
dev_err(&client->dev, "%s: write error\n", __func__);
return -EIO;
}
return 0;
}
/**
* inv_serial_single_write() - Write a byte to a device register.
* @st: Device driver instance.
* @reg: Device register to be written to.
* @data: Byte to write to device.
*/
int inv_serial_single_write(struct inv_ak89xx_state_s *st, u8 reg, u8 data)
{
u8 d[1];
d[0] = data;
INV_I2C_INC_COMPASSWRITE(3);
return i2c_smbus_write_i2c_block_data(st->i2c, reg, 1, d);
}
