自学教程：C++ to_iio_dev_attr函数代码示例

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

/** * 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 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 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 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){//.........这里部分代码省略.........

/** * 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());}