static ssize_t show_alarm(struct device *dev, struct device_attribute *da, char *buf) { struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct ds620_data *data = ds620_update_client(dev); struct i2c_client *client = to_i2c_client(dev); u16 conf, new_conf; int res; if (IS_ERR(data)) return PTR_ERR(data); /* reset alarms if necessary */ res = i2c_smbus_read_word_swapped(client, DS620_REG_CONF); if (res < 0) return res; new_conf = conf = res; new_conf &= ~attr->index; if (conf != new_conf) { res = i2c_smbus_write_word_swapped(client, DS620_REG_CONF, new_conf); if (res < 0) return res; } return sprintf(buf, "%d\n", !!(conf & attr->index)); }
static void ds620_init_client(struct i2c_client *client) { struct ds620_platform_data *ds620_info = client->dev.platform_data; u16 conf, new_conf; new_conf = conf = i2c_smbus_read_word_swapped(client, DS620_REG_CONF); new_conf &= ~DS620_REG_CONFIG_1SHOT; new_conf |= DS620_REG_CONFIG_PO2; if (ds620_info && ds620_info->pomode == 1) new_conf &= ~DS620_REG_CONFIG_PO1; else if (ds620_info && ds620_info->pomode == 2) new_conf |= DS620_REG_CONFIG_PO1; else new_conf &= ~DS620_REG_CONFIG_PO2; new_conf |= DS620_REG_CONFIG_R1 | DS620_REG_CONFIG_R0; if (conf != new_conf) i2c_smbus_write_word_swapped(client, DS620_REG_CONF, new_conf); i2c_smbus_write_byte(client, DS620_COM_START); }
static int ad5593r_reg_write(struct ad5592r_state *st, u8 reg, u16 value) { struct i2c_client *i2c = to_i2c_client(st->dev); return i2c_smbus_write_word_swapped(i2c, AD5593R_MODE_CONF | reg, value); }
static void ds620_init_client(struct i2c_client *client) { struct ds620_platform_data *ds620_info = client->dev.platform_data; u16 conf, new_conf; new_conf = conf = i2c_smbus_read_word_swapped(client, DS620_REG_CONF); /* switch to continuous conversion mode */ new_conf &= ~DS620_REG_CONFIG_1SHOT; /* already high at power-on, but don't trust the BIOS! */ new_conf |= DS620_REG_CONFIG_PO2; /* thermostat mode according to platform data */ if (ds620_info && ds620_info->pomode == 1) new_conf &= ~DS620_REG_CONFIG_PO1; /* PO_LOW */ else if (ds620_info && ds620_info->pomode == 2) new_conf |= DS620_REG_CONFIG_PO1; /* PO_HIGH */ else new_conf &= ~DS620_REG_CONFIG_PO2; /* always low */ /* with highest precision */ new_conf |= DS620_REG_CONFIG_R1 | DS620_REG_CONFIG_R0; if (conf != new_conf) i2c_smbus_write_word_swapped(client, DS620_REG_CONF, new_conf); /* start conversion */ i2c_smbus_write_byte(client, DS620_COM_START); }
static int ad5593r_write_dac(struct ad5592r_state *st, unsigned chan, u16 value) { struct i2c_client *i2c = to_i2c_client(st->dev); return i2c_smbus_write_word_swapped(i2c, AD5593R_MODE_DAC_WRITE | chan, value); }
static int mag3110_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask) { struct mag3110_data *data = iio_priv(indio_dev); int rate; if (iio_buffer_enabled(indio_dev)) return -EBUSY; switch (mask) { case IIO_CHAN_INFO_SAMP_FREQ: rate = mag3110_get_samp_freq_index(data, val, val2); if (rate < 0) return -EINVAL; data->ctrl_reg1 &= ~MAG3110_CTRL_DR_MASK; data->ctrl_reg1 |= rate << MAG3110_CTRL_DR_SHIFT; return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1, data->ctrl_reg1); case IIO_CHAN_INFO_CALIBBIAS: if (val < -10000 || val > 10000) return -EINVAL; return i2c_smbus_write_word_swapped(data->client, MAG3110_OFF_X + 2 * chan->scan_index, val << 1); default: return -EINVAL; } }
static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value) { if ((reg >= 0x07) && (reg <= 0x0c)) return i2c_smbus_write_word_swapped(client, reg, value); else return i2c_smbus_write_byte_data(client, reg, value); }
static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value) { if (reg == LM77_REG_CONF) return i2c_smbus_write_byte_data(client, reg, value); else return i2c_smbus_write_word_swapped(client, reg, value); }
static int jc42_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct jc42_data *data = i2c_get_clientdata(client); data->config &= ~JC42_CFG_SHUTDOWN; i2c_smbus_write_word_swapped(client, JC42_REG_CONFIG, data->config); return 0; }
static int jc42_remove(struct i2c_client *client) { struct jc42_data *data = i2c_get_clientdata(client); hwmon_device_unregister(data->hwmon_dev); sysfs_remove_group(&client->dev.kobj, &jc42_group); if (data->config != data->orig_config) i2c_smbus_write_word_swapped(client, JC42_REG_CONFIG, data->orig_config); return 0; }
static int regmap_smbus_word_write_swapped(void *context, unsigned int reg, unsigned int val) { struct device *dev = context; struct i2c_client *i2c = to_i2c_client(dev); if (val > 0xffff || reg > 0xff) return -EINVAL; return i2c_smbus_write_word_swapped(i2c, reg, val); }
static int max17040_write_reg(struct i2c_client *client, int reg, u16 value) { int ret; ret = i2c_smbus_write_word_swapped(client, reg, value); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); return ret; }
static int tmp102_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); int config; config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG); if (config < 0) return config; config &= ~TMP102_CONF_SD; return i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, config); }
static int max31790_write_pwm(struct device *dev, u32 attr, int channel, long val) { struct max31790_data *data = dev_get_drvdata(dev); struct i2c_client *client = data->client; u8 fan_config; int err = 0; mutex_lock(&data->update_lock); switch (attr) { case hwmon_pwm_input: if (val < 0 || val > 255) { err = -EINVAL; break; } data->pwm[channel] = val << 8; err = i2c_smbus_write_word_swapped(client, MAX31790_REG_PWMOUT(channel), data->pwm[channel]); break; case hwmon_pwm_enable: fan_config = data->fan_config[channel]; if (val == 0) { fan_config &= ~(MAX31790_FAN_CFG_TACH_INPUT_EN | MAX31790_FAN_CFG_RPM_MODE); } else if (val == 1) { fan_config = (fan_config | MAX31790_FAN_CFG_TACH_INPUT_EN) & ~MAX31790_FAN_CFG_RPM_MODE; } else if (val == 2) { fan_config |= MAX31790_FAN_CFG_TACH_INPUT_EN | MAX31790_FAN_CFG_RPM_MODE; } else { err = -EINVAL; break; } data->fan_config[channel] = fan_config; err = i2c_smbus_write_byte_data(client, MAX31790_REG_FAN_CONFIG(channel), fan_config); break; default: err = -EOPNOTSUPP; break; } mutex_unlock(&data->update_lock); return err; }
static ssize_t set_temp1_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct lm92_data *data = i2c_get_clientdata(client); long val = simple_strtol(buf, NULL, 10); val = clamp_val(val, -120000, 220000); mutex_lock(&data->update_lock); data->temp1_hyst = TEMP_TO_REG(TEMP_FROM_REG(data->temp1_crit) - val); i2c_smbus_write_word_swapped(client, LM92_REG_TEMP_HYST, data->temp1_hyst); mutex_unlock(&data->update_lock); return count; }
static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct jc42_data *data; int config, cap, err; struct device *dev = &client->dev; data = devm_kzalloc(dev, sizeof(struct jc42_data), GFP_KERNEL); if (!data) return -ENOMEM; i2c_set_clientdata(client, data); mutex_init(&data->update_lock); cap = i2c_smbus_read_word_swapped(client, JC42_REG_CAP); if (cap < 0) return cap; data->extended = !!(cap & JC42_CAP_RANGE); config = i2c_smbus_read_word_swapped(client, JC42_REG_CONFIG); if (config < 0) return config; data->orig_config = config; if (config & JC42_CFG_SHUTDOWN) { config &= ~JC42_CFG_SHUTDOWN; i2c_smbus_write_word_swapped(client, JC42_REG_CONFIG, config); } data->config = config; /* Register sysfs hooks */ err = sysfs_create_group(&dev->kobj, &jc42_group); if (err) return err; data->hwmon_dev = hwmon_device_register(dev); if (IS_ERR(data->hwmon_dev)) { err = PTR_ERR(data->hwmon_dev); goto exit_remove; } return 0; exit_remove: sysfs_remove_group(&dev->kobj, &jc42_group); return err; }
static int max31790_write_fan(struct device *dev, u32 attr, int channel, long val) { struct max31790_data *data = dev_get_drvdata(dev); struct i2c_client *client = data->client; int target_count; int err = 0; u8 bits; int sr; mutex_lock(&data->update_lock); switch (attr) { case hwmon_fan_target: val = clamp_val(val, FAN_RPM_MIN, FAN_RPM_MAX); bits = bits_for_tach_period(val); data->fan_dynamics[channel] = ((data->fan_dynamics[channel] & ~MAX31790_FAN_DYN_SR_MASK) | (bits << MAX31790_FAN_DYN_SR_SHIFT)); err = i2c_smbus_write_byte_data(client, MAX31790_REG_FAN_DYNAMICS(channel), data->fan_dynamics[channel]); if (err < 0) break; sr = get_tach_period(data->fan_dynamics[channel]); target_count = RPM_TO_REG(val, sr); target_count = clamp_val(target_count, 0x1, 0x7FF); data->target_count[channel] = target_count << 5; err = i2c_smbus_write_word_swapped(client, MAX31790_REG_TARGET_COUNT(channel), data->target_count[channel]); break; default: err = -EOPNOTSUPP; break; } mutex_unlock(&data->update_lock); return err; }
static ssize_t temp_store(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct lm73_data *data = dev_get_drvdata(dev); long temp; short value; s32 err; int status = kstrtol(buf, 10, &temp); if (status < 0) return status; /* Write value */ value = clamp_val(temp / 250, LM73_TEMP_MIN, LM73_TEMP_MAX) << 5; err = i2c_smbus_write_word_swapped(data->client, attr->index, value); return (err < 0) ? err : count; }
static int ad5593r_read_adc(struct ad5592r_state *st, unsigned chan, u16 *value) { struct i2c_client *i2c = to_i2c_client(st->dev); s32 val; val = i2c_smbus_write_word_swapped(i2c, AD5593R_MODE_CONF | AD5592R_REG_ADC_SEQ, BIT(chan)); if (val < 0) return (int) val; val = i2c_smbus_read_word_swapped(i2c, AD5593R_MODE_ADC_READBACK); if (val < 0) return (int) val; *value = (u16) val; return 0; }
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); long temp; short value; s32 err; int status = kstrtol(buf, 10, &temp); if (status < 0) return status; /* Write value */ value = (short) SENSORS_LIMIT(temp/250, (LM73_TEMP_MIN*4), (LM73_TEMP_MAX*4)) << 5; err = i2c_smbus_write_word_swapped(client, attr->index, value); return (err < 0) ? err : count; }
static int tmp102_remove(struct i2c_client *client) { struct tmp102 *tmp102 = i2c_get_clientdata(client); thermal_zone_of_sensor_unregister(tmp102->hwmon_dev, tmp102->tz); hwmon_device_unregister(tmp102->hwmon_dev); /* Stop monitoring if device was stopped originally */ if (tmp102->config_orig & TMP102_CONF_SD) { int config; config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG); if (config >= 0) i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, config | TMP102_CONF_SD); } return 0; }
static ssize_t set_temp1_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct lm92_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->temp1_hyst = TEMP_FROM_REG(data->temp1_crit) - val; i2c_smbus_write_word_swapped(client, LM92_REG_TEMP_HYST, TEMP_TO_REG(data->temp1_hyst)); 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 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_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 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 int __devexit tmp102_remove(struct i2c_client *client) { struct tmp102 *tmp102 = i2c_get_clientdata(client); hwmon_device_unregister(tmp102->hwmon_dev); sysfs_remove_group(&client->dev.kobj, &tmp102_attr_group); /* */ if (tmp102->config_orig & TMP102_CONF_SD) { int config; config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG); if (config >= 0) i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, config | TMP102_CONF_SD); } kfree(tmp102); return 0; }
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 set_temp(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { int res; long val; struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct i2c_client *client = to_i2c_client(dev); struct ds620_data *data = i2c_get_clientdata(client); res = kstrtol(buf, 10, &val); if (res) return res; val = (val * 10 / 625) * 8; mutex_lock(&data->update_lock); data->temp[attr->index] = val; i2c_smbus_write_word_swapped(client, DS620_REG_TEMP[attr->index], data->temp[attr->index]); mutex_unlock(&data->update_lock); return count; }
/* * JC42.4 compliant chips only support four hysteresis values. * Pick best choice and go from there. */ static ssize_t set_temp_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct jc42_data *data = i2c_get_clientdata(client); unsigned long val; int diff, hyst; int err; int ret = count; if (kstrtoul(buf, 10, &val) < 0) return -EINVAL; diff = jc42_temp_from_reg(data->temp_crit) - val; hyst = 0; if (diff > 0) { if (diff < 2250) hyst = 1; /* 1.5 degrees C */ else if (diff < 4500) hyst = 2; /* 3.0 degrees C */ else hyst = 3; /* 6.0 degrees C */ } mutex_lock(&data->update_lock); data->config = (data->config & ~(JC42_CFG_HYST_MASK << JC42_CFG_HYST_SHIFT)) | (hyst << JC42_CFG_HYST_SHIFT); err = i2c_smbus_write_word_swapped(client, JC42_REG_CONFIG, data->config); if (err < 0) ret = err; mutex_unlock(&data->update_lock); return ret; }
static int tmp102_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct tmp102 *tmp102; int status; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { dev_err(&client->dev, "adapter doesn't support SMBus word transactions\n"); return -ENODEV; } tmp102 = devm_kzalloc(&client->dev, sizeof(*tmp102), GFP_KERNEL); if (!tmp102) return -ENOMEM; i2c_set_clientdata(client, tmp102); status = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG); if (status < 0) { dev_err(&client->dev, "error reading config register\n"); return status; } tmp102->config_orig = status; status = i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, TMP102_CONFIG); if (status < 0) { dev_err(&client->dev, "error writing config register\n"); goto fail_restore_config; } status = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG); if (status < 0) { dev_err(&client->dev, "error reading config register\n"); goto fail_restore_config; } status &= ~TMP102_CONFIG_RD_ONLY; if (status != TMP102_CONFIG) { dev_err(&client->dev, "config settings did not stick\n"); status = -ENODEV; goto fail_restore_config; } tmp102->last_update = jiffies - HZ; mutex_init(&tmp102->lock); status = sysfs_create_group(&client->dev.kobj, &tmp102_attr_group); if (status) { dev_dbg(&client->dev, "could not create sysfs files\n"); goto fail_restore_config; } tmp102->hwmon_dev = hwmon_device_register(&client->dev); if (IS_ERR(tmp102->hwmon_dev)) { dev_dbg(&client->dev, "unable to register hwmon device\n"); status = PTR_ERR(tmp102->hwmon_dev); goto fail_remove_sysfs; } tmp102->tz = thermal_zone_of_sensor_register(&client->dev, 0, &client->dev, tmp102_read_temp, NULL); if (IS_ERR(tmp102->tz)) tmp102->tz = NULL; dev_info(&client->dev, "initialized\n"); return 0; fail_remove_sysfs: sysfs_remove_group(&client->dev.kobj, &tmp102_attr_group); fail_restore_config: i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, tmp102->config_orig); return status; }