static int max14656_read_block_reg(struct i2c_client *client, u8 reg, u8 length, u8 *val) { int ret; ret = i2c_smbus_read_i2c_block_data(client, reg, length, val); if (ret < 0) { dev_err(&client->dev, "failed to block read reg 0x%x: %d\n", reg, ret); return ret; } return 0; }
static int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value) { struct i2c_client *client = core->client; u8 b[2]; int r; r = i2c_smbus_read_i2c_block_data(client, reg, sizeof(b), b); if (r != 2) { dev_err(&client->dev, "%s: Read: %d fails.\n", __func__, reg); return -EREMOTEIO; } *value = (u16)b[0] << 8 | b[1]; return 0; }
int max77693_bulk_read(struct i2c_client *i2c, u8 reg, int count, u8 *buf) { struct max77693_dev *max77693 = i2c_get_clientdata(i2c); int ret; mutex_lock(&max77693->iolock); ret = i2c_smbus_read_i2c_block_data(i2c, reg, count, buf); mutex_unlock(&max77693->iolock); if (unlikely(ret < 0)) { dev_err(max77693->dev, "%s failed: reg=0x%x\n", __func__, reg); return ret; } return 0; }
static int bcmpmu_i2c_read_device_direct_bulk(struct bcmpmu59xxx *bcmpmu, u32 reg, u8 *val, int len) { int err = 0; struct i2c_client *clt; if ((DEC_REG_ADD(reg) + len) >= PMU_REG_MAX) return -ENODEV; clt = bcmpmu_get_client(bcmpmu, reg); bcmpmu_i2c_lock(bcmpmu); err = i2c_smbus_read_i2c_block_data(clt, (u8) DEC_REG_ADD(reg), len, val); bcmpmu_i2c_unlock(bcmpmu); return (err < 0 ? err : 0); }
static ssize_t ak8975_adc(struct device *dev, struct device_attribute *attr, char *strbuf) { struct akm8975_data *ak_data = dev_get_drvdata(dev); u8 buf[8]; s16 x, y, z; int err, success; printk("ak8975_adc\n"); mutex_lock(&ak_data->lock); /* start ADC conversion */ err = i2c_smbus_write_byte_data(ak_data->this_client, AK8975_REG_CNTL, REG_CNTL_MODE_ONCE); printk("ak8975_adc write err:%d\n", err); /* wait for ADC conversion to complete */ err = akm8975_wait_for_data_ready(ak_data); if (err) { pr_err("%s: wait for data ready failed\n", __func__); return; } msleep(10); /* get the value and report it */ err = i2c_smbus_read_i2c_block_data(ak_data->this_client, AK8975_REG_ST1, sizeof(buf), buf); //printk("ak8975_adc read err:%d\n", err); if (err != sizeof(buf)) { pr_err("%s: read data over i2c failed\n", __func__); return; } mutex_unlock(&ak_data->lock); /* buf[0] is status1, buf[7] is status2 */ if ((buf[0] == 0) | (buf[7] == 1)) success = 0; else success = 1; x = buf[1] | (buf[2] << 8); y = buf[3] | (buf[4] << 8); z = buf[5] | (buf[6] << 8); pr_info("%s: raw x = %d, y = %d, z = %d\n", __func__, x, y, z); return sprintf(strbuf, "%s, %d, %d, %d\n", (success ? "OK" : "NG"), x, y, z); }
static void silead_ts_read_data(struct i2c_client *client) { struct silead_ts_data *data = i2c_get_clientdata(client); struct input_dev *input = data->input; struct device *dev = &client->dev; u8 *bufp, buf[SILEAD_TS_DATA_LEN]; int touch_nr, error, i; error = i2c_smbus_read_i2c_block_data(client, SILEAD_REG_DATA, SILEAD_TS_DATA_LEN, buf); if (error < 0) { dev_err(dev, "Data read error %d\n", error); return; } touch_nr = buf[0]; if (touch_nr > data->max_fingers) { dev_warn(dev, "More touches reported then supported %d > %d\n", touch_nr, data->max_fingers); touch_nr = data->max_fingers; } bufp = buf + SILEAD_POINT_DATA_LEN; for (i = 0; i < touch_nr; i++, bufp += SILEAD_POINT_DATA_LEN) { /* Bits 4-7 are the touch id */ data->id[i] = (bufp[SILEAD_POINT_X_MSB_OFF] & SILEAD_TOUCH_ID_MASK) >> 4; touchscreen_set_mt_pos(&data->pos[i], &data->prop, get_unaligned_le16(&bufp[SILEAD_POINT_X_OFF]) & 0xfff, get_unaligned_le16(&bufp[SILEAD_POINT_Y_OFF]) & 0xfff); } input_mt_assign_slots(input, data->slots, data->pos, touch_nr, 0); for (i = 0; i < touch_nr; i++) { input_mt_slot(input, data->slots[i]); input_mt_report_slot_state(input, MT_TOOL_FINGER, true); input_report_abs(input, ABS_MT_POSITION_X, data->pos[i].x); input_report_abs(input, ABS_MT_POSITION_Y, data->pos[i].y); dev_dbg(dev, "x=%d y=%d hw_id=%d sw_id=%d\n", data->pos[i].x, data->pos[i].y, data->id[i], data->slots[i]); } input_mt_sync_frame(input); input_sync(input); }
// Reads the 3 gyro channels and stores them in vector g void L3G4200D::read() { // Specify the address of the slave device. if (ioctl(file, I2C_SLAVE, GYR_ADDRESS) < 0) { printf("Failed to acquire bus access and/or talk to slave %x", GYR_ADDRESS); exit(1); } __s32 res; __u8 reg, val; reg = L3G4200D_OUT_X_L | (1 << 7) ; __u8 buf[6]; res = i2c_smbus_read_i2c_block_data(file, reg, 6, (__u8 *)buf); if (res != 6) { printf("Failed to read acc data in read()\n"); exit(1); } for (int i = 0; i < 6; i++) { buf[i] = ~buf[i]; buf[i] += 0x01; } printf("g: "); for (int i = 0; i < 6; i++) printf("%02x ", buf[i]); printf("\n"); __u8 xla = buf[0]; __u8 xha = buf[1]; __u8 yla = buf[2]; __u8 yha = buf[3]; __u8 zla = buf[4]; __u8 zha = buf[5]; __s16 x = xha << 8 | xla; __s16 y = yha << 8 | yla; __s16 z = zha << 8 | zla; g.x = x; g.y = y; g.z = z; }
static void get_fw_ver_ic(void *device_data) { struct mms_info *info = (struct mms_info *)device_data; struct mms_fac_data *fac_data = info->fac_data; struct i2c_client *client = info->client; char buff[TSP_CMD_FULL_VER_LEN] = {0,}; int ret; set_default_result(fac_data); ret = i2c_smbus_read_i2c_block_data(client, MMS_VENDOR_ID, 2, buff); if (ret < 0) { dev_err(&client->dev, "Failed to read vendor ID(%d)\n", ret); goto out; } ret = i2c_smbus_read_byte_data(client, MMS_HW_ID); if (ret < 0) { dev_err(&client->dev, "Failed to read HW ID(%d)\n", ret); goto out; } sprintf(buff + 2, "%02X", ret); ret = i2c_smbus_read_byte_data(client, MMS_CONFIG_VERSION); if (ret < 0) { dev_err(&client->dev, "Failed to read FW ver (%d)\n", ret); goto out; } sprintf(buff + 4, "%04X", ret); fac_data->cmd_state = CMD_STATUS_OK; sprintf(fac_data->cmd_buff, "%s", buff); set_cmd_result(fac_data, fac_data->cmd_buff, strlen(fac_data->cmd_buff)); dev_info(&client->dev, "%s : %s\n", __func__, fac_data->cmd_buff); return; out: fac_data->cmd_state = CMD_STATUS_FAIL; sprintf(fac_data->cmd_buff, "NG"); set_cmd_result(fac_data, fac_data->cmd_buff, strlen(fac_data->cmd_buff)); return ; }
static void an30259a_debug(struct i2c_client *client) { struct an30259a_data *data = i2c_get_clientdata(client); int ret; u8 buff[21] = {0,}; ret = i2c_smbus_read_i2c_block_data(client, AN30259A_REG_SRESET|AN30259A_CTN_RW_FLG, sizeof(buff), buff); if (ret != sizeof(buff)) { dev_err(&data->client->dev, "%s: failure on i2c_smbus_read_i2c_block_data\n", __func__); } print_hex_dump(KERN_ERR, "an30259a: ", DUMP_PREFIX_OFFSET, 32, 1, buff, sizeof(buff), false); }
static int nastech_set_int_mode(struct i2c_client *client, int data) { unsigned char datareg; int ret = 0; datareg = data; ret = i2c_smbus_write_i2c_block_data(client, NAS_INT_MODE, 1, &datareg); if (ret < 0) { printk(KERN_ERR "%s: Failed to set INT MODE\n", __func__); return ret; } else { ret = i2c_smbus_read_i2c_block_data(client, NAS_INT_MODE, 1, &datareg); printk(KERN_DEBUG "%s: Success to set INT MODE, INT MODE =0x%x\n",__func__, datareg); } return ret; }
static int cs42l51_fill_cache(struct snd_soc_codec *codec) { u8 *cache = codec->reg_cache + 1; struct i2c_client *i2c_client = to_i2c_client(codec->dev); s32 length; length = i2c_smbus_read_i2c_block_data(i2c_client, CS42L51_FIRSTREG | 0x80, CS42L51_NUMREGS, cache); if (length != CS42L51_NUMREGS) { dev_err(&i2c_client->dev, "I2C read failure, addr=0x%x (ret=%d vs %d)\n", i2c_client->addr, length, CS42L51_NUMREGS); return -EIO; } return 0; }
static int mma8x5x_read_data(struct i2c_client *client, struct mma8x5x_data_axis *data) { u8 tmp_data[MMA8X5X_BUF_SIZE]; int ret; ret = i2c_smbus_read_i2c_block_data(client, MMA8X5X_OUT_X_MSB, 7, tmp_data); if (ret < MMA8X5X_BUF_SIZE) { dev_err(&client->dev, "i2c block read failed\n"); return -EIO; } data->x = ((tmp_data[0] << 8) & 0xff00) | tmp_data[1]; data->y = ((tmp_data[2] << 8) & 0xff00) | tmp_data[3]; data->z = ((tmp_data[4] << 8) & 0xff00) | tmp_data[5]; return 0; }
static inline int __ricoh61x_bulk_reads(struct i2c_client *client, u8 reg, int len, uint8_t *val) { int ret; int i; ret = i2c_smbus_read_i2c_block_data(client, reg, len, val); if (ret < 0) { dev_err(&client->dev, "failed reading from 0x%02x\n", reg); return ret; } for (i = 0; i < len; ++i) { dev_dbg(&client->dev, "ricoh61x: reg read reg=%x, val=%x\n", reg + i, *(val + i)); } return 0; }
/* * Pre-fill the CS4270 register cache. * * We use the auto-increment feature of the CS4270 to read all registers in * one shot. */ static int cs4270_fill_cache(struct snd_soc_codec *codec) { u8 *cache = codec->reg_cache; struct i2c_client *i2c_client = codec->control_data; s32 length; length = i2c_smbus_read_i2c_block_data(i2c_client, CS4270_FIRSTREG | 0x80, CS4270_NUMREGS, cache); if (length != CS4270_NUMREGS) { printk(KERN_ERR "cs4270: I2C read failure, addr=0x%x\n", i2c_client->addr); return -EIO; } return 0; }
/** * cs4270_fill_cache - pre-fill the CS4270 register cache. * @codec: the codec for this CS4270 * * This function fills in the CS4270 register cache by reading the register * values from the hardware. * * This CS4270 registers are cached to avoid excessive I2C I/O operations. * After the initial read to pre-fill the cache, the CS4270 never updates * the register values, so we won't have a cache coherency problem. * * We use the auto-increment feature of the CS4270 to read all registers in * one shot. */ static int cs4270_fill_cache(struct snd_soc_codec *codec) { u8 *cache = codec->reg_cache; struct i2c_client *i2c_client = codec->control_data; s32 length; length = i2c_smbus_read_i2c_block_data(i2c_client, CS4270_FIRSTREG | CS4270_I2C_INCR, CS4270_NUMREGS, cache); if (length != CS4270_NUMREGS) { dev_err(codec->dev, "i2c read failure, addr=0x%x\n", i2c_client->addr); return -EIO; } return 0; }
/* * User data attribute */ static ssize_t ds1682_eeprom_read(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct i2c_client *client = kobj_to_i2c_client(kobj); int rc; dev_dbg(&client->dev, "ds1682_eeprom_read(p=%p, off=%lli, c=%zi)\n", buf, off, count); rc = i2c_smbus_read_i2c_block_data(client, DS1682_REG_EEPROM + off, count, buf); if (rc < 0) return -EIO; return count; }
static int rv3029c2_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf, unsigned len) { int ret; if ((reg > RV3029C2_USR1_RAM_PAGE + 7) || (reg + len > RV3029C2_USR1_RAM_PAGE + 8)) return -EINVAL; ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf); if (ret < 0) return ret; if (ret < len) return -EIO; return 0; }
static int as5812_54x_psu_read_block(struct i2c_client *client, u8 command, u8 *data, int data_len) { int result = i2c_smbus_read_i2c_block_data(client, command, data_len, data); if (unlikely(result < 0)) goto abort; if (unlikely(result != data_len)) { result = -EIO; goto abort; } result = 0; abort: return result; }
void nxt_i2c_sensor_poll_work(struct work_struct *work) { struct nxt_i2c_sensor_data *data = container_of(work, struct nxt_i2c_sensor_data, poll_work); const struct nxt_i2c_sensor_mode_info *i2c_mode_info = &data->info->i2c_mode_info[data->sensor.mode]; struct lego_sensor_mode_info *mode_info = &data->sensor.mode_info[data->sensor.mode]; if (data->info->ops && data->info->ops->poll_cb) data->info->ops->poll_cb(data); else i2c_smbus_read_i2c_block_data(data->client, i2c_mode_info->read_data_reg, lego_sensor_get_raw_data_size(mode_info), mode_info->raw_data); }
static int zopt2201_read(struct zopt2201_data *data, u8 reg) { struct i2c_client *client = data->client; int tries = 10; u8 buf[3]; int ret; mutex_lock(&data->lock); ret = zopt2201_enable_mode(data, reg == ZOPT2201_UVB_DATA); if (ret < 0) goto fail; while (tries--) { unsigned long t = zopt2201_resolution[data->res].us; if (t <= 20000) usleep_range(t, t + 1000); else msleep(t / 1000); ret = i2c_smbus_read_byte_data(client, ZOPT2201_MAIN_STATUS); if (ret < 0) goto fail; if (ret & ZOPT2201_MAIN_STATUS_DRDY) break; } if (tries < 0) { ret = -ETIMEDOUT; goto fail; } ret = i2c_smbus_read_i2c_block_data(client, reg, sizeof(buf), buf); if (ret < 0) goto fail; ret = i2c_smbus_write_byte_data(client, ZOPT2201_MAIN_CTRL, 0x00); if (ret < 0) goto fail; mutex_unlock(&data->lock); return (buf[2] << 16) | (buf[1] << 8) | buf[0]; fail: mutex_unlock(&data->lock); return ret; }
static int backlight_i2c_read(struct i2c_client *client, u8 reg, u8 *val, unsigned int len) { int err = 0; int retry = 3; while (retry--) { err = i2c_smbus_read_i2c_block_data(client, reg, len, val); if (err >= 0) return err; dev_info(&client->dev, "%s: i2c transfer error.\n", __func__); } return err; }
static int clearpad_i2c_read(struct device *dev, u8 reg, u8 *buf, u8 len) { s32 rc = 0; int rsize = I2C_SMBUS_BLOCK_MAX; int off; for (off = 0; off < len; off += rsize) { if (len < off + I2C_SMBUS_BLOCK_MAX) rsize = len - off; rc = i2c_smbus_read_i2c_block_data(to_i2c_client(dev), reg + off, rsize, &buf[off]); if (rc != rsize) { dev_err(dev, "%s: rc = %d\n", __func__, rc); return rc; } } return 0; }
inline static int sm5703_read_device(struct i2c_client *i2c, int reg, int bytes, void *dest) { int ret; if (bytes > 1) { ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest); } else { ret = i2c_smbus_read_byte_data(i2c, reg); if (ret < 0) return ret; *(unsigned char *)dest = (unsigned char)ret; pr_debug("%s : ret = 0x%x, reg = 0x%d, dest = 0x%d\n", __func__, ret, reg, *(unsigned char *)dest); } return ret; }
static int mma8452_read(struct mma8452_data *data, __be16 buf[3]) { int ret = mma8452_drdy(data); if (ret < 0) return ret; ret = mma8452_set_runtime_pm_state(data->client, true); if (ret) return ret; ret = i2c_smbus_read_i2c_block_data(data->client, MMA8452_OUT_X, 3 * sizeof(__be16), (u8 *)buf); ret = mma8452_set_runtime_pm_state(data->client, false); return ret; }
int hook() { __u8 HOOK_CMD[6]={0x06,0x00,0x00,0x00,0x02,0x08}; int ret=0; int i=0; ret=i2c_smbus_write_i2c_block_data(i2c_fd, 0x06, 5, &HOOK_CMD[1]); i2c_smbus_read_i2c_block_data(i2c_fd, FC_CMD_HOOK_ACK, &FC_RX_INFO[0]); //printf("i2c_smbus_read_i2c_block_data ret=%d\n",ret); if (FC_RX_INFO[0]!=FC_CMD_HOOK_ACK || FC_RX_INFO[1]!=FC_CMD_ACK){//Check Return 0xFC printf("FC_RX_INFO[0]=%x, FC_RX_INFO[1]=%x\n",FC_RX_INFO[0],FC_RX_INFO[1]); return -1; } return ret; }
static int pm2xxx_reg_read(struct pm2xxx_charger *pm2, int reg, u8 *val) { int ret; /* wake up the device */ pm_runtime_get_sync(pm2->dev); ret = i2c_smbus_read_i2c_block_data(pm2->config.pm2xxx_i2c, reg, 1, val); if (ret < 0) dev_err(pm2->dev, "Error reading register at 0x%x\n", reg); else ret = 0; pm_runtime_put_sync(pm2->dev); return ret; }
static int hmc5843_detect(struct i2c_client *client, struct i2c_board_info *info) { unsigned char id_str[HMC5843_ID_REG_LENGTH]; if (client->addr != HMC5843_I2C_ADDRESS) return -ENODEV; if (i2c_smbus_read_i2c_block_data(client, HMC5843_ID_REG_A, HMC5843_ID_REG_LENGTH, id_str) != HMC5843_ID_REG_LENGTH) return -ENODEV; if (0 != strncmp(id_str, HMC5843_ID_STRING, HMC5843_ID_REG_LENGTH)) return -ENODEV; return 0; }
static int silead_ts_get_id(struct i2c_client *client) { struct silead_ts_data *data = i2c_get_clientdata(client); __le32 chip_id; int error; error = i2c_smbus_read_i2c_block_data(client, SILEAD_REG_ID, sizeof(chip_id), (u8 *)&chip_id); if (error < 0) { dev_err(&client->dev, "Chip ID read error %d\n", error); return error; } data->chip_id = le32_to_cpu(chip_id); dev_info(&client->dev, "Silead chip ID: 0x%8X", data->chip_id); return 0; }
static int rs5c_get_regs(struct rs5c372 *rs5c) { struct i2c_client *client = rs5c->client; struct i2c_msg msgs[] = { { client->addr, I2C_M_RD, sizeof rs5c->buf, rs5c->buf }, }; /* This implements the third reading method from the datasheet, using * an internal address that's reset after each transaction (by STOP) * to 0x0f ... so we read extra registers, and skip the first one. * * The first method doesn't work with the iop3xx adapter driver, on at * least 80219 chips; this works around that bug. * * The third method on the other hand doesn't work for the SMBus-only * configurations, so we use the the first method there, stripping off * the extra register in the process. */ if (rs5c->smbus) { int addr = RS5C_ADDR(RS5C372_REG_SECS); int size = sizeof(rs5c->buf) - 1; if (i2c_smbus_read_i2c_block_data(client, addr, size, rs5c->buf + 1) != size) { dev_warn(&client->dev, "can't read registers\n"); return -EIO; } } else { if ((i2c_transfer(client->adapter, msgs, 1)) != 1) { dev_warn(&client->dev, "can't read registers\n"); return -EIO; } } dev_dbg(&client->dev, "%02x %02x %02x (%02x) %02x %02x %02x (%02x), " "%02x %02x %02x, %02x %02x %02x; %02x %02x\n", rs5c->regs[0], rs5c->regs[1], rs5c->regs[2], rs5c->regs[3], rs5c->regs[4], rs5c->regs[5], rs5c->regs[6], rs5c->regs[7], rs5c->regs[8], rs5c->regs[9], rs5c->regs[10], rs5c->regs[11], rs5c->regs[12], rs5c->regs[13], rs5c->regs[14], rs5c->regs[15]); return 0; }
static int lm3561_set_reg_data(struct lm3561_drv_data *data, u8 addr, u8 mask, u8 value) { u8 current_value; s32 result; u8 reg = reg_map[addr]; if (mask != 0xFF) { result = i2c_smbus_read_i2c_block_data( data->client, reg, 1, ¤t_value); if (result < 0) { dev_err(&data->client->dev, "%s(): Failed to read register(0x%02x)" ". errno=%d\n", __func__, reg, result); return -EIO; } value = (current_value & ~mask) | value; } /* For debug-purpose, get info on what is written to chip */ dev_dbg(&data->client->dev, "%s write register(0x%02x) data(0x%02x)\n", __func__, reg, value); result = i2c_smbus_write_i2c_block_data( data->client, reg, 1, &value); if (result < 0) { dev_err(&data->client->dev, "%s(): Failed to write register(0x%02x). " "errno=%d\n", __func__, reg, result); return -EIO; } data->shadow[addr].val = value; data->shadow[addr].updated = 1; return 0; }