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, ®); 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_t store_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); }