static ssize_t set_range(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct hmc5843_data *data = iio_priv(indio_dev); unsigned long range = 0; int error; mutex_lock(&data->lock); error = strict_strtoul(buf, 10, &range); if (error) { count = error; goto exit; } dev_dbg(dev, "set range to %lu\n", range); if (range > RANGE_6_5) { count = -EINVAL; goto exit; } data->range = range; range = range << RANGE_GAIN_OFFSET; if (i2c_smbus_write_byte_data(client, this_attr->address, range)) count = -EINVAL; exit: mutex_unlock(&data->lock); return count; }
/* Return the measurement value from the specified channel */ static ssize_t hmc5843_read_measurement(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); s16 coordinate_val; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct hmc5843_data *data = indio_dev->dev_data; s32 result; mutex_lock(&data->lock); result = i2c_smbus_read_byte_data(client, HMC5843_STATUS_REG); while (!(result & DATA_READY)) result = i2c_smbus_read_byte_data(client, HMC5843_STATUS_REG); result = i2c_smbus_read_word_data(client, this_attr->address); mutex_unlock(&data->lock); if (result < 0) return -EINVAL; coordinate_val = (s16)swab16((u16)result); return sprintf(buf, "%d\n", coordinate_val); }
static ssize_t ad5624r_write_dac_powerdown(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { long readin; int ret; struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5624r_state *st = iio_dev_get_devdata(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); ret = strict_strtol(buf, 10, &readin); if (ret) return ret; if (readin == 1) st->pwr_down_mask |= (1 << this_attr->address); else if (!readin) st->pwr_down_mask &= ~(1 << this_attr->address); else ret = -EINVAL; ret = ad5624r_spi_write(st->us, AD5624R_CMD_POWERDOWN_DAC, 0, (st->pwr_down_mode << 4) | st->pwr_down_mask, 16); return ret ? ret : len; }
static ssize_t ad9834_store_wavetype(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad9834_state *st = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); int ret = 0; bool is_ad9833_7 = (st->devid == ID_AD9833) || (st->devid == ID_AD9837); mutex_lock(&indio_dev->mlock); switch ((u32) this_attr->address) { case 0: if (sysfs_streq(buf, "sine")) { st->control &= ~AD9834_MODE; if (is_ad9833_7) st->control &= ~AD9834_OPBITEN; } else if (sysfs_streq(buf, "triangle")) { if (is_ad9833_7) { st->control &= ~AD9834_OPBITEN; st->control |= AD9834_MODE; } else if (st->control & AD9834_OPBITEN) { ret = -EINVAL; /* AD9843 reserved mode */ } else { st->control |= AD9834_MODE; } } else if (is_ad9833_7 && sysfs_streq(buf, "square")) { st->control &= ~AD9834_MODE; st->control |= AD9834_OPBITEN; } else { ret = -EINVAL; } break; case 1: if (sysfs_streq(buf, "square") && !(st->control & AD9834_MODE)) { st->control &= ~AD9834_MODE; st->control |= AD9834_OPBITEN; } else { ret = -EINVAL; } break; default: ret = -EINVAL; break; } if (!ret) { st->data = cpu_to_be16(AD9834_REG_CMD | st->control); ret = spi_sync(st->spi, &st->msg); } mutex_unlock(&indio_dev->mlock); return ret ? ret : len; }
/* * Emits the scale factor to bring the raw value into Gauss units. * * This scale factor is axis-dependent, and is derived from 3 calibration * factors ASA(x), ASA(y), and ASA(z). * * These ASA values are read from the sensor device at start of day, and * cached in the device context struct. * * Adjusting the flux value with the sensitivity adjustment value should be * done via the following formula: * * Hadj = H * ( ( ( (ASA-128)*0.5 ) / 128 ) + 1 ) * * where H is the raw value, ASA is the sensitivity adjustment, and Hadj * is the resultant adjusted value. * * We reduce the formula to: * * Hadj = H * (ASA + 128) / 256 * * H is in the range of -4096 to 4095. The magnetometer has a range of * +-1229uT. To go from the raw value to uT is: * * HuT = H * 1229/4096, or roughly, 3/10. * * Since 1uT = 100 gauss, our final scale factor becomes: * * Hadj = H * ((ASA + 128) / 256) * 3/10 * 100 * Hadj = H * ((ASA + 128) * 30 / 256 * * Since ASA doesn't change, we cache the resultant scale factor into the * device context in ak8975_setup(). */ static ssize_t show_scale(struct device *dev, struct device_attribute *devattr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ak8975_data *data = indio_dev->dev_data; struct iio_dev_attr *this_attr = to_iio_dev_attr(devattr); return sprintf(buf, "%ld\n", data->raw_to_gauss[this_attr->address]); }
static ssize_t ad5624r_read_dac_powerdown(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5624r_state *st = iio_dev_get_devdata(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); return sprintf(buf, "%d\n", !!(st->pwr_down_mask & (1 << this_attr->address))); }
/** * lis3l02dq_read_accel_from_ring() individual acceleration read from ring **/ ssize_t lis3l02dq_read_accel_from_ring(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_scan_el *el = NULL; int ret, len = 0, i = 0; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *dev_info = dev_get_drvdata(dev); struct iio_ring_buffer *ring = dev_info->ring; struct attribute_group *scan_el_attrs = ring->scan_el_attrs; s16 *data; while (scan_el_attrs->attrs[i]) { el = to_iio_scan_el((struct device_attribute *) (scan_el_attrs->attrs[i])); /* label is in fact the address */ if (el->label == this_attr->address) break; i++; } if (!scan_el_attrs->attrs[i]) { ret = -EINVAL; goto error_ret; } /* If this element is in the scan mask */ ret = iio_scan_mask_query(ring, el->number); if (ret < 0) goto error_ret; if (ret) { data = kmalloc(ring->access.get_bytes_per_datum(ring), GFP_KERNEL); if (data == NULL) return -ENOMEM; ret = ring->access.read_last(ring, (u8 *)data); if (ret) goto error_free_data; } else { ret = -EINVAL; goto error_ret; } len = iio_scan_mask_count_to_right(ring, el->number); if (len < 0) { ret = len; goto error_free_data; } len = sprintf(buf, "ring %d\n", data[len]); error_free_data: kfree(data); error_ret: return ret ? ret : len; }
static ssize_t set_range(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct lsm303dlh_m_data *data = indio_dev->dev_data; struct i2c_client *client = data->client; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); unsigned long range = 0; int error; /* * Perform read/write operation, only when device is active */ if (data->device_status != DEVICE_ON) { dev_info(&client->dev, "device is switched off,make it ON using MODE"); return -EINVAL; } mutex_lock(&data->lock); error = strict_strtoul(buf, 10, &range); if (error) { count = error; goto exit; } dev_dbg(dev, "setting range to %lu\n", range); if (range > RANGE_8_1G || range < RANGE_1_3G) { dev_err(dev, "wrong range %lu\n", range); count = -EINVAL; goto exit; } data->range = range; range <<= CRB_GN_BIT; if (i2c_smbus_write_byte_data(client, this_attr->address, range)) { count = -EINVAL; goto exit; } /* check if chip is DLH/DLHC */ if (data->pdata->chip_id == LSM303DLHC_CHIP_ID) set_gain_dlhc(data); else set_gain_dlh(data); exit: mutex_unlock(&data->lock); return count; }
static ssize_t iio_scan_el_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct iio_dev *indio_dev = dev_get_drvdata(dev); ret = iio_scan_mask_query(indio_dev->buffer, to_iio_dev_attr(attr)->address); if (ret < 0) return ret; return sprintf(buf, "%d\n", ret); }
static ssize_t ad774x_show_dac_value(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *dev_info = dev_get_drvdata(dev); struct ad774x_chip_info *chip = dev_info->dev_data; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); u8 data; ad774x_i2c_read(chip, this_attr->address, &data, 1); return sprintf(buf, "%02x\n", data & 0x7F); }
static ssize_t show_sampling_frequency(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); s32 rate; rate = i2c_smbus_read_byte_data(client, this_attr->address); if (rate < 0) return rate; rate = (rate & RATE_BITMASK) >> RATE_OFFSET; return sprintf(buf, "%s\n", regval_to_samp_freq[rate]); }
/** * To read output x/y/z data register, in this case x,y and z are not * mapped w.r.t board orientation. Reading just raw data from device **/ static ssize_t lsm303dlh_a_xyz_read(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct lsm303dlh_a_data *data = indio_dev->dev_data; struct i2c_client *client = data->client; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); int lsb , msb; int ret; s16 val; /* * Perform read/write operation, only when device is active */ if (data->device_status != DEVICE_ON) { dev_dbg(&client->dev, "device is switched off,make it ON using MODE"); return -EINVAL; } mutex_lock(&data->lock); ret = i2c_smbus_read_byte_data(client, SR_REG_A); /* wait till data is written to all six registers */ while (!(ret & XYZ_DATA_RDY_MASK)) ret = i2c_smbus_read_byte_data(client, SR_REG_A); lsb = i2c_smbus_read_byte_data(client, this_attr->address); if (ret < 0) { dev_err(&client->dev, "reading xyz failed\n"); mutex_unlock(&data->lock); return -EINVAL; } msb = i2c_smbus_read_byte_data(client, (this_attr->address + 1)); if (ret < 0) { dev_err(&client->dev, "reading xyz failed\n"); mutex_unlock(&data->lock); return -EINVAL; } val = ((msb << 8) | lsb); mutex_unlock(&data->lock); val >>= data->shift_adjust; return sprintf(buf, "%d:%lld\n", val, iio_get_time_ns()); }
static ssize_t hmc5843_show_sampling_frequency(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct hmc5843_data *data = iio_priv(indio_dev); s32 rate; rate = i2c_smbus_read_byte_data(client, this_attr->address); if (rate < 0) return rate; rate = (rate & HMC5843_RATE_BITMASK) >> HMC5843_RATE_OFFSET; return sprintf(buf, "%s\n", data->variant->regval_to_sample_freq[rate]); }
static ssize_t ade7854_read_32bit(struct device *dev, struct device_attribute *attr, char *buf) { int ret; u32 val = 0; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ade7854_state *st = iio_dev_get_devdata(indio_dev); ret = st->read_reg_32(dev, this_attr->address, &val); if (ret) return ret; return sprintf(buf, "%u\n", val); }
static ssize_t hx711_scale_available_show(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev_attr *iio_attr = to_iio_dev_attr(attr); int channel = iio_attr->address; int i, len = 0; for (i = 0; i < HX711_GAIN_MAX; i++) if (hx711_gain_to_scale[i].channel == channel) len += sprintf(buf + len, "0.%09d ", hx711_gain_to_scale[i].scale); len += sprintf(buf + len, "\n"); return len; }
static ssize_t adis16130_val_read(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *indio_dev = dev_get_drvdata(dev); u32 val; ssize_t ret; /* Take the iio_dev status lock */ mutex_lock(&indio_dev->mlock); ret = adis16130_spi_read(dev, this_attr->address, &val); mutex_unlock(&indio_dev->mlock); if (ret == 0) return sprintf(buf, "%d\n", val); else return ret; }
static inline ssize_t ad7152_start_calib(struct device *dev, struct device_attribute *attr, const char *buf, size_t len, u8 regval) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7152_chip_info *chip = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); bool doit; int ret, timeout = 10; ret = strtobool(buf, &doit); if (ret < 0) return ret; if (!doit) return 0; if (this_attr->address == 0) regval |= AD7152_CONF_CH1EN; else regval |= AD7152_CONF_CH2EN; mutex_lock(&indio_dev->mlock); ret = i2c_smbus_write_byte_data(chip->client, AD7152_REG_CFG, regval); if (ret < 0) { mutex_unlock(&indio_dev->mlock); return ret; } do { mdelay(20); ret = i2c_smbus_read_byte_data(chip->client, AD7152_REG_CFG); if (ret < 0) { mutex_unlock(&indio_dev->mlock); return ret; } } while ((ret == regval) && timeout--); mutex_unlock(&indio_dev->mlock); return len; }
static ssize_t ad5624r_write_dac(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { long readin; int ret; struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5624r_state *st = iio_dev_get_devdata(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); ret = strict_strtol(buf, 10, &readin); if (ret) return ret; ret = ad5624r_spi_write(st->us, AD5624R_CMD_WRITE_INPUT_N_UPDATE_N, this_attr->address, readin, st->chip_info->bits); return ret ? ret : len; }
static ssize_t ade7854_write_8bit(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ade7854_state *st = iio_dev_get_devdata(indio_dev); int ret; long val; ret = strict_strtol(buf, 10, &val); if (ret) goto error_ret; ret = st->write_reg_8(dev, this_attr->address, val); error_ret: return ret ? ret : len; }
static ssize_t ade7854_write_32bit(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ade7854_state *st = iio_priv(indio_dev); int ret; u32 val; ret = kstrtou32(buf, 10, &val); if (ret) goto error_ret; ret = st->write_reg_32(dev, this_attr->address, val); error_ret: return ret ? ret : len; }
static ssize_t iio_show_fixed_type(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); u8 type = this_attr->c->scan_type.endianness; if (type == IIO_CPU) { #ifdef __LITTLE_ENDIAN type = IIO_LE; #else type = IIO_BE; #endif } return sprintf(buf, "%s:%c%d/%d>>%u\n", iio_endian_prefix[type], this_attr->c->scan_type.sign, this_attr->c->scan_type.realbits, this_attr->c->scan_type.storagebits, this_attr->c->scan_type.shift); }
static ssize_t ad7606_scan(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *dev_info = dev_get_drvdata(dev); struct ad7606_state *st = dev_info->dev_data; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); int ret; mutex_lock(&dev_info->mlock); if (iio_ring_enabled(dev_info)) ret = ad7606_scan_from_ring(st, this_attr->address); else ret = ad7606_scan_direct(st, this_attr->address); mutex_unlock(&dev_info->mlock); if (ret < 0) return ret; return sprintf(buf, "%d\n", (short) ret); }
static ssize_t ad774x_store_dac_value(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *dev_info = dev_get_drvdata(dev); struct ad774x_chip_info *chip = dev_info->dev_data; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); unsigned long data; int ret; ret = strict_strtoul(buf, 10, &data); if (!ret) { ad774x_i2c_write(chip, this_attr->address, (data ? AD774X_CAPDAC_EN : 0) | (data & 0x7F)); return len; } return -EINVAL; }
static ssize_t ad7887_scan(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *dev_info = dev_get_drvdata(dev); struct ad7887_state *st = dev_info->dev_data; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); int ret; mutex_lock(&dev_info->mlock); if (iio_ring_enabled(dev_info)) ret = ad7887_scan_from_ring(st, 1 << this_attr->address); else ret = ad7887_scan_direct(st, this_attr->address); mutex_unlock(&dev_info->mlock); if (ret < 0) return ret; return sprintf(buf, "%d\n", (ret >> st->chip_info->left_shift) & RES_MASK(st->chip_info->bits)); }
static ssize_t hmc5843_set_operating_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); struct hmc5843_data *data = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); unsigned long operating_mode = 0; s32 status; int error; mutex_lock(&data->lock); error = kstrtoul(buf, 10, &operating_mode); if (error) { count = error; goto exit; } dev_dbg(dev, "set conversion mode to %lu\n", operating_mode); if (operating_mode > HMC5843_MODE_SLEEP) { count = -EINVAL; goto exit; } status = i2c_smbus_write_byte_data(client, this_attr->address, operating_mode); if (status) { count = -EINVAL; goto exit; } data->operating_mode = operating_mode; exit: mutex_unlock(&data->lock); return count; }
static ssize_t iio_scan_el_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { int ret = 0; bool state; struct iio_dev *indio_dev = dev_get_drvdata(dev); struct iio_buffer *buffer = indio_dev->buffer; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); state = !(buf[0] == '0'); mutex_lock(&indio_dev->mlock); if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) { ret = -EBUSY; goto error_ret; } ret = iio_scan_mask_query(buffer, this_attr->address); if (ret < 0) goto error_ret; if (!state && ret) { ret = iio_scan_mask_clear(buffer, this_attr->address); if (ret) goto error_ret; } else if (state && !ret) { ret = iio_scan_mask_set(buffer, this_attr->address); if (ret) goto error_ret; } error_ret: mutex_unlock(&indio_dev->mlock); return ret ? ret : len; }
static ssize_t adis16080_read(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); struct iio_dev *indio_dev = dev_get_drvdata(dev); u16 val = 0; ssize_t ret; /* Take the iio_dev status lock */ mutex_lock(&indio_dev->mlock); ret = adis16080_spi_write(dev, this_attr->address | ADIS16080_DIN_WRITE); if (ret < 0) goto error_ret; ret = adis16080_spi_read(dev, &val); error_ret: mutex_unlock(&indio_dev->mlock); if (ret == 0) return sprintf(buf, "%d\n", val); else return ret; }
static int ad5504_spi_read(struct spi_device *spi, u8 addr, u16 *val) { u16 tmp = cpu_to_be16(AD5504_CMD_READ | AD5504_ADDR(addr)); int ret; struct spi_transfer t = { .tx_buf = &tmp, .rx_buf = val, .len = 2, }; struct spi_message m; spi_message_init(&m); spi_message_add_tail(&t, &m); ret = spi_sync(spi, &m); *val = be16_to_cpu(*val) & AD5504_RES_MASK; return ret; } static ssize_t ad5504_write_dac(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); long readin; int ret; ret = strict_strtol(buf, 10, &readin); if (ret) return ret; ret = ad5504_spi_write(st->spi, this_attr->address, readin); return ret ? ret : len; } static ssize_t ad5504_read_dac(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); int ret; u16 val; ret = ad5504_spi_read(st->spi, this_attr->address, &val); if (ret) return ret; return sprintf(buf, "%d\n", val); } static ssize_t ad5504_read_powerdown_mode(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); const char mode[][14] = {"20kohm_to_gnd", "three_state"}; return sprintf(buf, "%s\n", mode[st->pwr_down_mode]); } static ssize_t ad5504_write_powerdown_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); int ret; if (sysfs_streq(buf, "20kohm_to_gnd")) st->pwr_down_mode = AD5504_DAC_PWRDN_20K; else if (sysfs_streq(buf, "three_state")) st->pwr_down_mode = AD5504_DAC_PWRDN_3STATE; else ret = -EINVAL; return ret ? ret : len; } static ssize_t ad5504_read_dac_powerdown(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); return sprintf(buf, "%d\n", !(st->pwr_down_mask & (1 << this_attr->address))); } static ssize_t ad5504_write_dac_powerdown(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { long readin; int ret; struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ad5504_state *st = iio_priv(indio_dev); struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); ret = strict_strtol(buf, 10, &readin); if (ret) return ret; if (readin == 0) st->pwr_down_mask |= (1 << this_attr->address); else if (readin == 1) st->pwr_down_mask &= ~(1 << this_attr->address); else ret = -EINVAL; ret = ad5504_spi_write(st->spi, AD5504_ADDR_CTRL, AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) | AD5504_DAC_PWR(st->pwr_down_mask)); /* writes to the CTRL register must be followed by a NOOP */ ad5504_spi_write(st->spi, AD5504_ADDR_NOOP, 0); return ret ? ret : len; }
/* * Emits the raw flux value for the x, y, or z axis. */ static ssize_t show_raw(struct device *dev, struct device_attribute *devattr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct ak8975_data *data = indio_dev->dev_data; struct i2c_client *client = data->client; struct iio_dev_attr *this_attr = to_iio_dev_attr(devattr); u16 meas_reg; s16 raw; u8 read_status; int ret; mutex_lock(&data->lock); if (data->mode == 0) { dev_err(&client->dev, "Operating mode is in power down mode\n"); ret = -EBUSY; goto exit; } /* Set up the device for taking a sample. */ ret = ak8975_write_data(client, AK8975_REG_CNTL, AK8975_REG_CNTL_MODE_ONCE, AK8975_REG_CNTL_MODE_MASK, AK8975_REG_CNTL_MODE_SHIFT); if (ret < 0) { dev_err(&client->dev, "Error in setting operating mode\n"); goto exit; } /* Wait for the conversion to complete. */ if (data->eoc_gpio) ret = wait_conversion_complete_gpio(data); else ret = wait_conversion_complete_polled(data); if (ret < 0) goto exit; read_status = ret; if (read_status & AK8975_REG_ST1_DRDY_MASK) { ret = ak8975_read_data(client, AK8975_REG_ST2, 1, &read_status); if (ret < 0) { dev_err(&client->dev, "Error in reading ST2\n"); goto exit; } if (read_status & (AK8975_REG_ST2_DERR_MASK | AK8975_REG_ST2_HOFL_MASK)) { dev_err(&client->dev, "ST2 status error 0x%x\n", read_status); ret = -EINVAL; goto exit; } } /* Read the flux value from the appropriate register (the register is specified in the iio device attributes). */ ret = ak8975_read_data(client, this_attr->address, 2, (u8 *)&meas_reg); if (ret < 0) { dev_err(&client->dev, "Read axis data fails\n"); goto exit; } mutex_unlock(&data->lock); /* Endian conversion of the measured values. */ raw = (s16) (le16_to_cpu(meas_reg)); /* Clamp to valid range. */ raw = clamp_t(s16, raw, -4096, 4095); return sprintf(buf, "%d\n", raw); exit: mutex_unlock(&data->lock); return ret; }
/** * To read output x,y,z data register. After reading change x,y and z values * w.r.t the orientation of the device. **/ static ssize_t lsm303dlh_a_readdata(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct lsm303dlh_a_data *data = indio_dev->dev_data; struct lsm303dlh_platform_data *pdata = data->pdata; struct i2c_client *client = data->client; struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); u8 map_x = pdata->axis_map_x; u8 map_y = pdata->axis_map_y; u8 map_z = pdata->axis_map_z; int ret; unsigned char magn_data[6]; s16 val[3]; /* * Perform read/write operation, only when device is active */ if (data->device_status != DEVICE_ON) { dev_dbg(&client->dev, "device is switched off,make it ON using MODE"); return -EINVAL; } mutex_lock(&data->lock); ret = i2c_smbus_read_byte_data(client, SR_REG_A); /* wait till data is written to all six registers */ while (!((ret & XYZ_DATA_RDY_MASK))) ret = i2c_smbus_read_byte_data(client, SR_REG_A); ret = i2c_smbus_read_i2c_block_data(client, this_attr->address | MULTIPLE_I2C_TR, 6, magn_data); if (ret < 0) { dev_err(&client->dev, "reading xyz failed\n"); mutex_unlock(&data->lock); return -EINVAL; } /* MSB is at lower address */ val[0] = (s16) (((magn_data[1]) << 8) | magn_data[0]); val[1] = (s16) (((magn_data[3]) << 8) | magn_data[2]); val[2] = (s16) (((magn_data[5]) << 8) | magn_data[4]); val[0] >>= data->shift_adjust; val[1] >>= data->shift_adjust; val[2] >>= data->shift_adjust; /* modify the x,y and z values w.r.t orientation of device*/ if (pdata->negative_x) val[map_x] = -val[map_x]; if (pdata->negative_y) val[map_y] = -val[map_y]; if (pdata->negative_z) val[map_z] = -val[map_z]; mutex_unlock(&data->lock); return sprintf(buf, "%d:%d:%d:%lld\n", val[map_x], val[map_y], val[map_z], iio_get_time_ns()); }