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

/* * Generic counter attributes */static ssize_t ds1682_show(struct device *dev, struct device_attribute *attr,			   char *buf){	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);	struct i2c_client *client = to_i2c_client(dev);	__le32 val = 0;	int rc;	dev_dbg(dev, "ds1682_show() called on %s/n", attr->attr.name);	/* Read the register */	rc = i2c_smbus_read_i2c_block_data(client, sattr->index, sattr->nr,					   (u8 *) & val);	if (rc < 0)		return -EIO;	/* Special case: the 32 bit regs are time values with 1/4s	 * resolution, scale them up to milliseconds */	if (sattr->nr == 4)		return sprintf(buf, "%llu/n",			((unsigned long long)le32_to_cpu(val)) * 250);	/* Format the output string and return # of bytes */	return sprintf(buf, "%li/n", (long)le32_to_cpu(val));}

/* Function called on read access on in{0,1,2,3,4,5,6,7}_{min,max} */static ssize_t max197_show_range(struct device *dev,				 struct device_attribute *devattr, char *buf){	struct max197_data *data = dev_get_drvdata(dev);	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);	int channel = attr->index;	bool is_min = attr->nr;	int range;	if (mutex_lock_interruptible(&data->lock))		return -ERESTARTSYS;	range = max197_is_full_range(data, channel) ?		data->limit : data->limit / 2;	if (is_min) {		if (max197_is_bipolar(data, channel))			range = -range;		else			range = 0;	}	mutex_unlock(&data->lock);	return sprintf(buf, "%d/n", range);}

static ssize_t store_bit(struct device *dev,		struct device_attribute *attr, const char *buf, size_t count){	struct i2c_client *client = to_i2c_client(dev);	struct thermal_data *data = i2c_get_clientdata(client);	struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);	unsigned long val;	int retval;	if (kstrtoul(buf, 10, &val))		return -EINVAL;	mutex_lock(&data->mutex);	retval = i2c_smbus_read_byte_data(client, sda->nr);	if (retval < 0)		goto fail;	retval &= ~sda->index;	if (val)		retval |= sda->index;	retval = i2c_smbus_write_byte_data(client, sda->index, retval);	if (retval == 0)		retval = count;fail:	mutex_unlock(&data->mutex);	return retval;}

static ssize_t store_bank2_setting(struct device *dev, struct device_attribute                                   *devattr, const char *buf, size_t count){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    unsigned long val;    ssize_t ret;    ret = kstrtoul(buf, 10, &val);    if (ret)        return ret;    ret = count;    val = (val * 255 + ABIT_UGURU_FAN_MAX / 2) / ABIT_UGURU_FAN_MAX;    if (val < abituguru_bank2_min_threshold ||            val > abituguru_bank2_max_threshold)        return -EINVAL;    mutex_lock(&data->update_lock);    if (data->bank2_settings[attr->index][attr->nr] != val) {        u8 orig_val = data->bank2_settings[attr->index][attr->nr];        data->bank2_settings[attr->index][attr->nr] = val;        if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2,                            attr->index, data->bank2_settings[attr->index],                            2) <= attr->nr) {            data->bank2_settings[attr->index][attr->nr] = orig_val;            ret = -EIO;        }    }    mutex_unlock(&data->update_lock);    return ret;}

static ssize_t show_pwm_setting(struct device *dev,                                struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    return sprintf(buf, "%d/n", data->pwm_settings[attr->index][attr->nr] *                   abituguru_pwm_settings_multiplier[attr->nr]);}

static ssize_t show_bank2_setting(struct device *dev,                                  struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    return sprintf(buf, "%d/n",                   (data->bank2_settings[attr->index][attr->nr] *                    ABIT_UGURU_FAN_MAX + 128) / 255);}

static ssize_tshow_pwm(struct device *dev, struct device_attribute *attr, char *buf){	struct nct6683_data *data = nct6683_update_device(dev);	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);	int index = sattr->index;	return sprintf(buf, "%d/n", data->pwm[index]);}

static ssize_tshow_temp8(struct device *dev, struct device_attribute *attr, char *buf){	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);	struct nct6683_data *data = nct6683_update_device(dev);	int index = sattr->index;	int nr = sattr->nr;	return sprintf(buf, "%d/n", data->temp[index][nr] * 1000);}

static ssize_t show_bank2_value(struct device *dev,                                struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = abituguru_update_device(dev);    if (!data)        return -EIO;    return sprintf(buf, "%d/n", (data->bank2_value[attr->index] *                                 ABIT_UGURU_FAN_MAX + 128) / 255);}

static ssize_t show_pwm_enable(struct device *dev,                               struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    int res = 0;    if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE)        res = 2;    return sprintf(buf, "%d/n", res);}

static ssize_t show_bank2_mask(struct device *dev,                               struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    if (data->bank2_settings[attr->index][0] & attr->nr)        return sprintf(buf, "1/n");    else        return sprintf(buf, "0/n");}

static ssize_tshow_in_reg(struct device *dev, struct device_attribute *attr, char *buf){	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);	struct nct6683_data *data = nct6683_update_device(dev);	int index = sattr->index;	int nr = sattr->nr;	return sprintf(buf, "%ld/n",		       in_from_reg(data->in[index][nr], data->in_index[index]));}

static ssize_t show_pwm_auto_point_fan(struct device *dev,				       struct device_attribute *devattr,				       char* buf){	struct f71805f_data *data = dev_get_drvdata(dev);	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);	int pwmnr = attr->nr;	int apnr = attr->index;	return sprintf(buf, "%ld/n",		       fan_from_reg(data->auto_points[pwmnr].fan[apnr]));}

/* Function called on write access on in{0,1,2,3,4,5,6,7}_{min,max} */static ssize_t max197_store_range(struct device *dev,				  struct device_attribute *devattr,				  const char *buf, size_t count){	struct max197_data *data = dev_get_drvdata(dev);	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);	int channel = attr->index;	bool is_min = attr->nr;	long value;	int half = data->limit / 2;	int full = data->limit;	if (kstrtol(buf, 10, &value))		return -EINVAL;	if (is_min) {		if (value <= -full)			value = -full;		else if (value < 0)			value = -half;		else			value = 0;	} else {		if (value >= full)			value = full;		else			value = half;	}	if (mutex_lock_interruptible(&data->lock))		return -ERESTARTSYS;	if (value == 0) {		/* We can deduce only the polarity */		max197_set_unipolarity(data, channel);	} else if (value == -half) {		max197_set_bipolarity(data, channel);		max197_set_half_range(data, channel);	} else if (value == -full) {		max197_set_bipolarity(data, channel);		max197_set_full_range(data, channel);	} else if (value == half) {		/* We can deduce only the range */		max197_set_half_range(data, channel);	} else if (value == full) {		/* We can deduce only the range */		max197_set_full_range(data, channel);	}	mutex_unlock(&data->lock);	return count;}

static ssize_t show_bit(struct device *dev,			struct device_attribute *attr, char *buf){	struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);	struct thermal_data *data = dev_get_drvdata(dev);	int retval;	retval = i2c_smbus_read_byte_data(data->client, sda->nr);	if (retval < 0)		return retval;	return sprintf(buf, "%d/n", !!(retval & sda->index));}

static ssize_t show_bit(struct device *dev,			struct device_attribute *attr, char *buf){	struct i2c_client *client = to_i2c_client(dev);	struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);	int retval = i2c_smbus_read_byte_data(client, sda->nr);	if (retval < 0)		return retval;	retval &= sda->index;	return sprintf(buf, "%d/n", retval ? 1 : 0);}

static ssize_t show_bank2_alarm(struct device *dev,                                struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = abituguru_update_device(dev);    if (!data)        return -EIO;    if (data->alarms[2] & (0x01 << attr->index))        return sprintf(buf, "1/n");    else        return sprintf(buf, "0/n");}

/* * Show boolean, either a fault or an alarm. * .nr points to the register, .index is the bit mask to check */static ssize_t pem_show_bool(struct device *dev,			     struct device_attribute *da, char *buf){	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);	struct pem_data *data = pem_update_device(dev);	u8 status;	if (IS_ERR(data))		return PTR_ERR(data);	status = data->data_string[attr->nr] & attr->index;	return snprintf(buf, PAGE_SIZE, "%d/n", !!status);}

static ssize_t show_pwm_sensor(struct device *dev,                               struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    int i;    for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++)        if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] ==                (data->pwm_settings[attr->index][0] & 0x0F))            return sprintf(buf, "%d/n", i+1);    return -ENXIO;}

static ssize_t show_bank1_alarm(struct device *dev,                                struct device_attribute *devattr, char *buf){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = abituguru_update_device(dev);    if (!data)        return -EIO;    if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) &&            (data->bank1_settings[attr->index][0] & attr->nr))        return sprintf(buf, "1/n");    else        return sprintf(buf, "0/n");}

static ssize_t store_pwm_setting(struct device *dev, struct device_attribute                                 *devattr, const char *buf, size_t count){    struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);    struct abituguru_data *data = dev_get_drvdata(dev);    u8 min;    unsigned long val;    ssize_t ret;    ret = kstrtoul(buf, 10, &val);    if (ret)        return ret;    ret = count;    val = (val + abituguru_pwm_settings_multiplier[attr->nr] / 2) /          abituguru_pwm_settings_multiplier[attr->nr];    if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))        min = 77;    else        min = abituguru_pwm_min[attr->nr];    if (val < min || val > abituguru_pwm_max[attr->nr])        return -EINVAL;    mutex_lock(&data->update_lock);    if ((attr->nr & 1) &&            (val >= data->pwm_settings[attr->index][attr->nr + 1]))        ret = -EINVAL;    else if (!(attr->nr & 1) &&             (val <= data->pwm_settings[attr->index][attr->nr - 1]))        ret = -EINVAL;    else if (data->pwm_settings[attr->index][attr->nr] != val) {        u8 orig_val = data->pwm_settings[attr->index][attr->nr];        data->pwm_settings[attr->index][attr->nr] = val;        if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,                            attr->index, data->pwm_settings[attr->index],                            5) <= attr->nr) {            data->pwm_settings[attr->index][attr->nr] =                orig_val;            ret = -EIO;        }    }    mutex_unlock(&data->update_lock);    return ret;}

static ssize_t ltc4222_bool_show(struct device *dev,				 struct device_attribute *da, char *buf){	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);	struct regmap *regmap = dev_get_drvdata(dev);	unsigned int fault;	int ret;	ret = regmap_read(regmap, attr->nr, &fault);	if (ret < 0)		return ret;	fault &= attr->index;	if (fault)		/* Clear reported faults in chip register */		regmap_update_bits(regmap, attr->nr, attr->index, 0);	return snprintf(buf, PAGE_SIZE, "%d/n", !!fault);}

static ssize_t set_pwm_auto_point_fan(struct device *dev,				      struct device_attribute *devattr,				      const char* buf, size_t count){	struct f71805f_data *data = dev_get_drvdata(dev);	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);	int pwmnr = attr->nr;	int apnr = attr->index;	unsigned long val = simple_strtoul(buf, NULL, 10);	mutex_lock(&data->update_lock);	data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val);	f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr),		        data->auto_points[pwmnr].fan[apnr]);	mutex_unlock(&data->update_lock);	return count;}

/* * Generic counter attributes */static ssize_t ds1682_show(struct device *dev, struct device_attribute *attr,			   char *buf){	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);	struct i2c_client *client = to_i2c_client(dev);	unsigned long long val, check;	__le32 val_le = 0;	int rc;	dev_dbg(dev, "ds1682_show() called on %s/n", attr->attr.name);	/* Read the register */	rc = i2c_smbus_read_i2c_block_data(client, sattr->index, sattr->nr,					   (u8 *)&val_le);	if (rc < 0)		return -EIO;	val = le32_to_cpu(val_le);	if (sattr->index == DS1682_REG_ELAPSED) {		int retries = 5;		/* Detect and retry when a tick occurs mid-read */		do {			rc = i2c_smbus_read_i2c_block_data(client, sattr->index,							   sattr->nr,							   (u8 *)&val_le);			if (rc < 0 || retries <= 0)				return -EIO;			check = val;			val = le32_to_cpu(val_le);			retries--;		} while (val != check && val != (check + 1));	}	/* Format the output string and return # of bytes	 * Special case: the 32 bit regs are time values with 1/4s	 * resolution, scale them up to milliseconds	 */	return sprintf(buf, "%llu/n", (sattr->nr == 4) ? (val * 250) : val);}