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); }