Lines Matching refs:data
176 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
179 static inline int adt7470_read_word_data(struct adt7470_data *data, unsigned int reg,
185 err = regmap_bulk_read(data->regmap, reg, ®val, 2);
194 static inline int adt7470_write_word_data(struct adt7470_data *data, unsigned int reg,
202 return regmap_bulk_write(data->regmap, reg, ®val, 2);
206 static int adt7470_read_temperatures(struct adt7470_data *data)
215 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(0), &pwm_cfg[0]);
218 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(2), &pwm_cfg[1]);
223 err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
229 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(0),
233 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(2),
239 err = regmap_bulk_write(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
245 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
251 res = msleep_interruptible((data->num_temp_sensors >= 0 ?
252 data->num_temp_sensors * 200 :
256 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
262 err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
265 err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
273 if (data->num_temp_sensors >= 0)
276 err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
281 if (data->temp[i])
282 data->num_temp_sensors = i + 1;
284 data->temperatures_probed = 1;
291 struct adt7470_data *data = i2c_get_clientdata(client);
294 mutex_lock(&data->lock);
295 adt7470_read_temperatures(data);
296 mutex_unlock(&data->lock);
301 schedule_timeout_interruptible(msecs_to_jiffies(data->auto_update_interval));
307 static int adt7470_update_sensors(struct adt7470_data *data)
313 if (!data->temperatures_probed)
314 err = adt7470_read_temperatures(data);
316 err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
322 err = adt7470_read_word_data(data, ADT7470_REG_FAN(i), &val);
325 data->fan[i] = val;
328 err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &data->pwm[0], ADT7470_PWM_COUNT);
340 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(i), &val);
343 data->pwm_automatic[i] = !!(val & mask);
345 err = regmap_read(data->regmap, ADT7470_REG_PWM_AUTO_TEMP(i), &val);
349 data->pwm_auto_temp[i] = val >> 4;
351 data->pwm_auto_temp[i] = val & 0xF;
354 err = regmap_read(data->regmap, ADT7470_REG_CFG, &val);
357 data->force_pwm_max = !!(val & ADT7470_FSPD_MASK);
359 err = regmap_read(data->regmap, ADT7470_REG_ALARM1, &val);
362 data->alarm = val;
363 if (data->alarm & ADT7470_OOL_ALARM) {
364 err = regmap_read(data->regmap, ADT7470_REG_ALARM2, &val);
367 data->alarm |= ALARM2(val);
370 err = adt7470_read_word_data(data, ADT7470_REG_ALARM1_MASK, &val);
373 data->alarms_mask = val;
378 static int adt7470_update_limits(struct adt7470_data *data)
385 err = regmap_read(data->regmap, ADT7470_TEMP_MIN_REG(i), &val);
388 data->temp_min[i] = (s8)val;
389 err = regmap_read(data->regmap, ADT7470_TEMP_MAX_REG(i), &val);
392 data->temp_max[i] = (s8)val;
396 err = adt7470_read_word_data(data, ADT7470_REG_FAN_MIN(i), &val);
399 data->fan_min[i] = val;
400 err = adt7470_read_word_data(data, ADT7470_REG_FAN_MAX(i), &val);
403 data->fan_max[i] = val;
407 err = regmap_read(data->regmap, ADT7470_REG_PWM_MAX(i), &val);
410 data->pwm_max[i] = val;
411 err = regmap_read(data->regmap, ADT7470_REG_PWM_MIN(i), &val);
414 data->pwm_min[i] = val;
415 err = regmap_read(data->regmap, ADT7470_REG_PWM_TMIN(i), &val);
418 data->pwm_tmin[i] = (s8)val;
426 struct adt7470_data *data = dev_get_drvdata(dev);
435 * date data.
437 if (time_before(local_jiffies, data->sensors_last_updated +
439 data->sensors_valid)
442 if (time_before(local_jiffies, data->limits_last_updated +
444 data->limits_valid)
448 return data;
450 mutex_lock(&data->lock);
452 err = adt7470_update_sensors(data);
455 data->sensors_last_updated = local_jiffies;
456 data->sensors_valid = 1;
460 err = adt7470_update_limits(data);
463 data->limits_last_updated = local_jiffies;
464 data->limits_valid = 1;
467 mutex_unlock(&data->lock);
469 return err < 0 ? ERR_PTR(err) : data;
476 struct adt7470_data *data = adt7470_update_device(dev);
478 if (IS_ERR(data))
479 return PTR_ERR(data);
481 return sprintf(buf, "%d\n", data->auto_update_interval);
488 struct adt7470_data *data = dev_get_drvdata(dev);
496 mutex_lock(&data->lock);
497 data->auto_update_interval = temp;
498 mutex_unlock(&data->lock);
507 struct adt7470_data *data = adt7470_update_device(dev);
509 if (IS_ERR(data))
510 return PTR_ERR(data);
512 return sprintf(buf, "%d\n", data->num_temp_sensors);
519 struct adt7470_data *data = dev_get_drvdata(dev);
527 mutex_lock(&data->lock);
528 data->num_temp_sensors = temp;
530 data->temperatures_probed = 0;
531 mutex_unlock(&data->lock);
538 struct adt7470_data *data = adt7470_update_device(dev);
540 if (IS_ERR(data))
541 return PTR_ERR(data);
545 *val = 1000 * data->temp[channel];
548 *val = 1000 * data->temp_min[channel];
551 *val = 1000 * data->temp_max[channel];
554 *val = !!(data->alarm & channel);
565 struct adt7470_data *data = dev_get_drvdata(dev);
573 mutex_lock(&data->lock);
574 data->temp_min[channel] = val;
575 err = regmap_write(data->regmap, ADT7470_TEMP_MIN_REG(channel), val);
576 mutex_unlock(&data->lock);
579 mutex_lock(&data->lock);
580 data->temp_max[channel] = val;
581 err = regmap_write(data->regmap, ADT7470_TEMP_MAX_REG(channel), val);
582 mutex_unlock(&data->lock);
594 struct adt7470_data *data = adt7470_update_device(dev);
596 if (IS_ERR(data))
597 return PTR_ERR(data);
599 return sprintf(buf, "%x\n", data->alarms_mask);
606 struct adt7470_data *data = dev_get_drvdata(dev);
616 mutex_lock(&data->lock);
617 data->alarms_mask = mask;
618 err = adt7470_write_word_data(data, ADT7470_REG_ALARM1_MASK, mask);
619 mutex_unlock(&data->lock);
626 struct adt7470_data *data = adt7470_update_device(dev);
628 if (IS_ERR(data))
629 return PTR_ERR(data);
633 if (FAN_DATA_VALID(data->fan[channel]))
634 *val = FAN_PERIOD_TO_RPM(data->fan[channel]);
639 if (FAN_DATA_VALID(data->fan_min[channel]))
640 *val = FAN_PERIOD_TO_RPM(data->fan_min[channel]);
645 if (FAN_DATA_VALID(data->fan_max[channel]))
646 *val = FAN_PERIOD_TO_RPM(data->fan_max[channel]);
651 *val = !!(data->alarm & (1 << (12 + channel)));
662 struct adt7470_data *data = dev_get_drvdata(dev);
673 mutex_lock(&data->lock);
674 data->fan_min[channel] = val;
675 err = adt7470_write_word_data(data, ADT7470_REG_FAN_MIN(channel), val);
676 mutex_unlock(&data->lock);
679 mutex_lock(&data->lock);
680 data->fan_max[channel] = val;
681 err = adt7470_write_word_data(data, ADT7470_REG_FAN_MAX(channel), val);
682 mutex_unlock(&data->lock);
694 struct adt7470_data *data = adt7470_update_device(dev);
696 if (IS_ERR(data))
697 return PTR_ERR(data);
699 return sprintf(buf, "%d\n", data->force_pwm_max);
706 struct adt7470_data *data = dev_get_drvdata(dev);
713 mutex_lock(&data->lock);
714 data->force_pwm_max = temp;
715 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
718 mutex_unlock(&data->lock);
730 struct adt7470_data *data = dev_get_drvdata(dev);
735 mutex_lock(&data->lock);
736 err = regmap_read(data->regmap, ADT7470_REG_CFG, &cfg_reg_1);
739 err = regmap_read(data->regmap, ADT7470_REG_CFG_2, &cfg_reg_2);
742 mutex_unlock(&data->lock);
753 mutex_unlock(&data->lock);
759 struct adt7470_data *data = adt7470_update_device(dev);
761 if (IS_ERR(data))
762 return PTR_ERR(data);
766 *val = data->pwm[channel];
769 *val = 1 + data->pwm_automatic[channel];
783 struct adt7470_data *data = dev_get_drvdata(dev);
797 mutex_lock(&data->lock);
799 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
805 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG_2,
809 mutex_unlock(&data->lock);
816 struct adt7470_data *data = dev_get_drvdata(dev);
823 mutex_lock(&data->lock);
824 data->pwm[channel] = val;
825 err = regmap_write(data->regmap, ADT7470_REG_PWM(channel),
826 data->pwm[channel]);
827 mutex_unlock(&data->lock);
839 mutex_lock(&data->lock);
840 data->pwm_automatic[channel] = val;
841 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(channel),
844 mutex_unlock(&data->lock);
860 struct adt7470_data *data = adt7470_update_device(dev);
862 if (IS_ERR(data))
863 return PTR_ERR(data);
865 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
873 struct adt7470_data *data = dev_get_drvdata(dev);
882 mutex_lock(&data->lock);
883 data->pwm_max[attr->index] = temp;
884 err = regmap_write(data->regmap, ADT7470_REG_PWM_MAX(attr->index),
886 mutex_unlock(&data->lock);
895 struct adt7470_data *data = adt7470_update_device(dev);
897 if (IS_ERR(data))
898 return PTR_ERR(data);
900 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
908 struct adt7470_data *data = dev_get_drvdata(dev);
917 mutex_lock(&data->lock);
918 data->pwm_min[attr->index] = temp;
919 err = regmap_write(data->regmap, ADT7470_REG_PWM_MIN(attr->index),
921 mutex_unlock(&data->lock);
930 struct adt7470_data *data = adt7470_update_device(dev);
932 if (IS_ERR(data))
933 return PTR_ERR(data);
936 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
943 struct adt7470_data *data = adt7470_update_device(dev);
945 if (IS_ERR(data))
946 return PTR_ERR(data);
948 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
956 struct adt7470_data *data = dev_get_drvdata(dev);
966 mutex_lock(&data->lock);
967 data->pwm_tmin[attr->index] = temp;
968 err = regmap_write(data->regmap, ADT7470_REG_PWM_TMIN(attr->index),
970 mutex_unlock(&data->lock);
979 struct adt7470_data *data = adt7470_update_device(dev);
982 if (IS_ERR(data))
983 return PTR_ERR(data);
985 ctrl = data->pwm_auto_temp[attr->index];
1006 struct adt7470_data *data = dev_get_drvdata(dev);
1019 mutex_lock(&data->lock);
1020 data->pwm_automatic[attr->index] = temp;
1030 err = regmap_update_bits(data->regmap, pwm_auto_reg, mask, val);
1031 mutex_unlock(&data->lock);
1257 struct adt7470_data *data;
1261 data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);
1262 if (!data)
1265 data->num_temp_sensors = -1;
1266 data->auto_update_interval = AUTO_UPDATE_INTERVAL;
1267 data->regmap = devm_regmap_init_i2c(client, &adt7470_regmap_config);
1268 if (IS_ERR(data->regmap))
1269 return PTR_ERR(data->regmap);
1271 i2c_set_clientdata(client, data);
1272 mutex_init(&data->lock);
1277 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
1284 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
1291 data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
1293 if (IS_ERR(data->auto_update))
1294 return PTR_ERR(data->auto_update);
1301 struct adt7470_data *data = i2c_get_clientdata(client);
1303 kthread_stop(data->auto_update);