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

static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,			   const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);	struct lm78_data *data = dev_get_drvdata(dev);	int nr = attr->index;	unsigned long val;	int err;	err = kstrtoul(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));	lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_pwm_en(struct device *dev, struct device_attribute			  *devattr, const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct smsc47m1_data *data = dev_get_drvdata(dev);	int nr = attr->index;	long val = simple_strtol(buf, NULL, 10);		if (val != 0 && val != 1)		return -EINVAL;	mutex_lock(&data->update_lock);	data->pwm[nr] &= 0xFE; /* preserve the other bits */	data->pwm[nr] |= !val;	smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],			     data->pwm[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t tmp102_show_temp(struct device *dev,				struct device_attribute *attr,				char *buf){	struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);	struct tmp102 *tmp102 = dev_get_drvdata(dev);	int regaddr = sda->index;	unsigned int reg;	int err;	if (regaddr == TMP102_TEMP_REG &&	    time_before(jiffies, tmp102->ready_time))		return -EAGAIN;	err = regmap_read(tmp102->regmap, regaddr, &reg);	if (err < 0)		return err;	return sprintf(buf, "%d/n", tmp102_reg_to_mC(reg));}

static ssize_t set_temp(struct device *dev, struct device_attribute *da,			const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);	struct i2c_client *client = to_i2c_client(dev);	struct ds1621_data *data = i2c_get_clientdata(client);	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp[attr->index] = LM75_TEMP_TO_REG(val);	i2c_smbus_write_word_swapped(client, DS1621_REG_TEMP[attr->index],				     data->temp[attr->index]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_max_hyst(struct device *dev,			    struct device_attribute *devattr,			    const char *buf, size_t count){	unsigned long val;	struct abx500_temp *data = dev_get_drvdata(dev);	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	int res = kstrtoul(buf, 10, &val);	if (res < 0)		return res;	val = clamp_val(val, 0, DEFAULT_MAX_TEMP);	mutex_lock(&data->lock);	data->max_hyst[attr->index] = val;	threshold_updated(data);	mutex_unlock(&data->lock);	return count;}

static ssize_t set_pwm_enable(struct device *dev, struct device_attribute			      *devattr, const char *buf, size_t count){	struct pc87427_data *data = dev_get_drvdata(dev);	int nr = to_sensor_dev_attr(devattr)->index;	unsigned long val;	if (kstrtoul(buf, 10, &val) < 0 || val > 2)		return -EINVAL;	/* Can't go to automatic mode if it isn't configured */	if (val == 2 && !(data->pwm_auto_ok & (1 << nr)))		return -EINVAL;	mutex_lock(&data->lock);	pc87427_readall_pwm(data, nr);	update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));	mutex_unlock(&data->lock);	return count;}

static ssize_t show_status(struct device *dev, struct device_attribute *da,             char *buf){    struct sensor_device_attribute *attr = to_sensor_dev_attr(da);    struct as5812_54x_psu_data *data = as5812_54x_psu_update_device(dev);    u8 status = 0;    if (!data->valid) {        return sprintf(buf, "0/n");    }    if (attr->index == PSU_PRESENT) {        status = IS_PRESENT(data->index, data->status);    }    else { /* PSU_POWER_GOOD */        status = IS_POWER_GOOD(data->index, data->status);    }    return sprintf(buf, "%d/n", status);}

static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute				 *attr, const char *buf, size_t count){	struct i2c_client *client = to_i2c_client(dev);	struct gl520_data *data = i2c_get_clientdata(client);	int n = to_sensor_dev_attr(attr)->index;	long v;	int err;	err = kstrtol(buf, 10, &v);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp_max_hyst[n] = TEMP_TO_REG(v);	gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],			  data->temp_max_hyst[n]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_temp_hyst(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 *attr = to_sensor_dev_attr(devattr);	int nr = attr->index;	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp_hyst[nr] = temp_to_reg(val);	f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t show_temp(struct device *dev,			struct device_attribute *devattr, char *buf){	u32 eax, edx;	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct platform_data *pdata = dev_get_drvdata(dev);	struct temp_data *tdata = pdata->core_data[attr->index];	mutex_lock(&tdata->update_lock);	/* Check whether the time interval has elapsed */	if (!tdata->valid || time_after(jiffies, tdata->last_updated + HZ)) {		rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);		tdata->valid = 0;		/* Check whether the data is valid */		if (eax & 0x80000000) {			tdata->temp = tdata->tjmax -					((eax >> 16) & 0x7f) * 1000;			tdata->valid = 1;		}

static ssize_t set_pwm_freq(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 *attr = to_sensor_dev_attr(devattr);	int nr = attr->index;	unsigned long val;	int err;	err = kstrtoul(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->pwm_freq[nr] = pwm_freq_to_reg(val);	f71805f_write8(data, F71805F_REG_PWM_FREQ(nr), data->pwm_freq[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_pwm(struct device *dev, struct device_attribute		       *devattr, const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct smsc47m1_data *data = dev_get_drvdata(dev);	int nr = attr->index;	long val = simple_strtol(buf, NULL, 10);	if (val < 0 || val > 255)		return -EINVAL;	mutex_lock(&data->update_lock);	data->pwm[nr] &= 0x81; /* Preserve additional bits */	data->pwm[nr] |= PWM_TO_REG(val);	smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],			     data->pwm[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t maxmin_alarm_show(struct device *dev,				 struct device_attribute *da, char *buf){	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);	struct lm73_data *data = dev_get_drvdata(dev);	s32 ctrl;	mutex_lock(&data->lock);	ctrl = i2c_smbus_read_byte_data(data->client, LM73_REG_CTRL);	if (ctrl < 0)		goto abort;	data->ctrl = ctrl;	mutex_unlock(&data->lock);	return scnprintf(buf, PAGE_SIZE, "%d/n", (ctrl >> attr->index) & 1);abort:	mutex_unlock(&data->lock);	return ctrl;}

static ssize_t set_w_member_data(struct device *dev, struct device_attribute /				*dev_attr, const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);	long data;	int error;	if (attr->index == PSU_SELECT_MEMBER) {		error = kstrtol(buf, 16, &data);		if (error)			return error;		if (SELECT_PSU1_EEPROM == data) {			psu_member_data = SELECT_PSU1_EEPROM;		} else if (SELECT_PSU2_EEPROM == data) {			psu_member_data = SELECT_PSU2_EEPROM;		} else {			return -EINVAL;		}	}	return count;}

static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,			   const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct lm92_data *data = dev_get_drvdata(dev);	struct i2c_client *client = data->client;	int nr = attr->index;	long val;	int err;		err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp[nr] = TEMP_TO_REG(val);	i2c_smbus_write_word_swapped(client, regs[nr], data->temp[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,			  const char *buf, size_t count){	int index = to_sensor_dev_attr(attr)->index;	struct i2c_client *client = to_i2c_client(dev);	struct adm1025_data *data = i2c_get_clientdata(client);	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->in_max[index] = IN_TO_REG(val, in_scale[index]);	i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(index),				  data->in_max[index]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,	const char *buf, size_t count){	int index = to_sensor_dev_attr(attr)->index;	struct adm1025_data *data = dev_get_drvdata(dev);	struct i2c_client *client = data->client;	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp_max[index] = TEMP_TO_REG(val);	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),				  data->temp_max[index]);	mutex_unlock(&data->update_lock);	return count;}

static s32 show_power2(struct device *dev,		struct device_attribute *devattr,		char *buf){	struct i2c_client *client = to_i2c_client(dev);	struct ina3221_data *data = i2c_get_clientdata(client);	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	u8 index, bus_volt_reg_addr, shunt_volt_reg_addr;	s32 power_mW;	s32 ret;	mutex_lock(&data->mutex);	if (data->shutdown_complete) {		ret = -ENODEV;		goto error;	}	/*return 0 if INA is off*/	if (data->mode == TRIGGERED) {		mutex_unlock(&data->mutex);		return sprintf(buf, "%d mW/n", 0);	}	index = attr->index;	bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));	shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));	power_mW = __locked_calculate_power(client, shunt_volt_reg_addr,						bus_volt_reg_addr, index);	if (power_mW < 0) {		ret = power_mW;		goto error;	}	DEBUG_INA3221(("%s power = %d/n", __func__, power_mW));	mutex_unlock(&data->mutex);	return sprintf(buf, "%d mW/n", power_mW);error:	mutex_unlock(&data->mutex);	dev_err(dev, "%s: failed/n", __func__);	return ret;}

static ssize_t set_fan_div(struct device *dev,	    struct device_attribute *devattr, const char *buf, size_t count){	struct i2c_client *client = to_i2c_client(dev);	struct adm1029_data *data = i2c_get_clientdata(client);	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	long val = simple_strtol(buf, NULL, 10);	u8 reg;	mutex_lock(&data->update_lock);	/*Read actual config */	reg = i2c_smbus_read_byte_data(client,				       ADM1029_REG_FAN_DIV[attr->index]);	switch (val) {	case 1:		val = 1;		break;	case 2:		val = 2;		break;	case 4:		val = 3;		break;	default:		mutex_unlock(&data->update_lock);		dev_err(&client->dev, "fan_div value %ld not "			"supported. Choose one of 1, 2 or 4!/n", val);		return -EINVAL;	}	/* Update the value */	reg = (reg & 0x3F) | (val << 6);	/* Write value */	i2c_smbus_write_byte_data(client,				  ADM1029_REG_FAN_DIV[attr->index], reg);	mutex_unlock(&data->update_lock);	return count;}

static ssize_tstore_pwm_enable(struct device *dev, struct device_attribute *attr,		 const char *buf, size_t count){	struct imanager_hwmon_data *data = imanager_hwmon_update_device(dev);	int nr = to_sensor_dev_attr(attr)->index - 1;	struct hwm_smartfan *fan = &data->hwm.fan[nr];	unsigned long mode = 0;	int err;	err = kstrtoul(buf, 10, &mode);	if (err < 0)		return err;	if (mode > MODE_AUTO)		return -EINVAL;	mutex_lock(&data->ec->lock);	switch (mode) {	case 0:		if (mode != 0)			hwm_core_fan_set_ctrl(nr, MODE_FULL, CTRL_PWM, 100,					      fan->pulse, NULL, NULL);		break;	case 1:		if (mode != 1)			hwm_core_fan_set_ctrl(nr, MODE_MANUAL, CTRL_PWM, 0,					      fan->pulse, NULL, NULL);		break;	case 2:		if (mode != 2)			hwm_core_fan_set_ctrl(nr, MODE_AUTO, fan->type, 0,					      fan->pulse, &fan->limit, NULL);		break;	}	mutex_unlock(&data->ec->lock);	return count;}

/* Sysfs stuff */static ssize_t show_input(struct device *dev, struct device_attribute *attr,			  char *buf){	struct lm95245_data *data = lm95245_update_device(dev);	int temp;	int index = to_sensor_dev_attr(attr)->index;	/*	 * Index 0 (Local temp) is always signed	 * Index 2 (Remote temp) has both signed and unsigned data	 * use signed calculation for remote if signed bit is set	 */	if (index == 0 || data->regs[index] & 0x80)		temp = temp_from_reg_signed(data->regs[index],			    data->regs[index + 1]);	else		temp = temp_from_reg_unsigned(data->regs[index + 2],			    data->regs[index + 3]);	return snprintf(buf, PAGE_SIZE - 1, "%d/n", temp);}

static ssize_t tmp102_set_temp(struct device *dev,			       struct device_attribute *attr,			       const char *buf, size_t count){	struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);	struct i2c_client *client = to_i2c_client(dev);	struct tmp102 *tmp102 = i2c_get_clientdata(client);	long val;	int status;	if (kstrtol(buf, 10, &val) < 0)		return -EINVAL;	val = clamp_val(val, -256000, 255000);	mutex_lock(&tmp102->lock);	tmp102->temp[sda->index] = val;	status = i2c_smbus_write_word_swapped(client, tmp102_reg[sda->index],					      tmp102_mC_to_reg(val));	mutex_unlock(&tmp102->lock);	return status ? : count;}

static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,		const char *buf, size_t count){	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);	int nr = sensor_attr->index;	struct smsc47m192_data *data = dev_get_drvdata(dev);	struct i2c_client *client = data->client;	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp_max[nr] = TEMP_TO_REG(val);	i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],						data->temp_max[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,		const char *buf, size_t count){	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);	int nr = sensor_attr->index;	struct smsc47m192_data *data = dev_get_drvdata(dev);	struct i2c_client *client = data->client;	unsigned long val;	int err;	err = kstrtoul(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->in_min[nr] = IN_TO_REG(val, nr);	i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),							data->in_min[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,			const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct i2c_client *client = to_i2c_client(dev);	struct lm83_data *data = i2c_get_clientdata(client);	long val;	int nr = attr->index;	int err;	err = kstrtol(buf, 10, &val);	if (err < 0)		return err;	mutex_lock(&data->update_lock);	data->temp[nr] = TEMP_TO_REG(val);	i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr - 4],				  data->temp[nr]);	mutex_unlock(&data->update_lock);	return count;}

static ssize_t set_temp_hyst(struct device *dev,			     struct device_attribute *devattr,			     const char *buf, size_t count){	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	struct lm92_data *data = dev_get_drvdata(dev);	struct i2c_client *client = data->client;	long val;	int err;	err = kstrtol(buf, 10, &val);	if (err)		return err;	mutex_lock(&data->update_lock);	data->temp[t_hyst] = TEMP_FROM_REG(data->temp[attr->index]) - val;	i2c_smbus_write_word_swapped(client, LM92_REG_TEMP_HYST,				     TEMP_TO_REG(data->temp[t_hyst]));	mutex_unlock(&data->update_lock);	return count;}

static ssize_t show_pwm_enable(struct device *dev, struct device_attribute			       *devattr, char *buf){	struct f71805f_data *data = f71805f_update_device(dev);	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);	int nr = attr->index;	int mode;	switch (data->fan_ctrl[nr] & FAN_CTRL_MODE_MASK) {	case FAN_CTRL_MODE_SPEED:		mode = 3;		break;	case FAN_CTRL_MODE_TEMPERATURE:		mode = 2;		break;	default: /* MANUAL */		mode = 1;	}	return sprintf(buf, "%d/n", mode);}

static ssize_t ina3221_shunt_store(struct device *dev,				   struct device_attribute *attr,				   const char *buf, size_t count){	struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);	struct ina3221_data *ina = dev_get_drvdata(dev);	unsigned int channel = sd_attr->index;	struct ina3221_input *input = &ina->inputs[channel];	int val;	int ret;	ret = kstrtoint(buf, 0, &val);	if (ret)		return ret;	val = clamp_val(val, 1, INT_MAX);	input->shunt_resistor = val;	return count;}

/** * s3c_hwmon_ch_show - show value of a given channel * @dev: The device that the attribute belongs to. * @attr: The attribute being read. * @buf: The result buffer. * * Read a value from the ADC and scale it before returning it to the * caller. The scale factor is gained from the channel configuration * passed via the platform data when the device was registered. */static ssize_t s3c_hwmon_ch_show(struct device *dev,                                 struct device_attribute *attr,                                 char *buf){    struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr);    struct s3c_hwmon *hwmon = platform_get_drvdata(to_platform_device(dev));    struct s3c_hwmon_pdata *pdata = dev->platform_data;    struct s3c_hwmon_chcfg *cfg;    int ret;    cfg = pdata->in[sen_attr->index];    ret = s3c_hwmon_read_ch(dev, hwmon, sen_attr->index);    if (ret < 0)        return ret;    ret *= cfg->mult;    ret = DIV_ROUND_CLOSEST(ret, cfg->div);    return snprintf(buf, PAGE_SIZE, "%d/n", ret);}

static ssize_t bcm2835_get_temp(struct device *dev, struct device_attribute *attr, char *buf){	struct vc_msg msg;	int result;	uint temp = 0;	int index = ((struct sensor_device_attribute*)to_sensor_dev_attr(attr))->index;	print_debug("IN");	/* wipe all previous message data */	memset(&msg, 0, sizeof msg);	/* determine the message type */	if(index == TEMP)		msg.tag.tag_id = VC_TAG_GET_TEMP;	else if (index == MAX_TEMP)		msg.tag.tag_id = VC_TAG_GET_MAX_TEMP;	else	{		print_debug("Unknown temperature message!");		return -EINVAL;	}	msg.msg_size = sizeof msg;	msg.tag.buffer_size = 8;	/* send the message */	result = bcm_mailbox_property(&msg, sizeof msg);	/* check if it was all ok and return the rate in milli degrees C */	if (result == 0 && (msg.request_code & 0x80000000))		temp = (uint)msg.tag.val;	#ifdef HWMON_DEBUG_ENABLE	else		print_debug("Failed to get temperature!");	#endif	print_debug("Got temperature as %u",temp);	print_debug("OUT");	return sprintf(buf, "%u/n", temp);}