On 07/01/11 10:37, Jonathan Cameron wrote:
> On 07/01/11 00:44, Lucas Stach wrote:
>> From 94262a505a888fdb04cb1f37ffb33e240a58484f Mon Sep 17 00:00:00 2001
>> From: Lucas Stach <dev@xxxxxxxxxx>
>> Date: Fri, 1 Jul 2011 00:55:30 +0200
>> Subject: [PATCH 1/2] hwmon: add hwmon-core interface
>>
>> This adds an interface to easily access attributes from hwmon drivers and
>> a way to generically build sysfs entries for supported attributes.
> In principal this is quite similar to what we did recently with IIO_CHAN_SPEC
> in iio, but clearly your approach is somewhat different. Perhaps it is worth
> us both reading each others code to see if we can make suggestions.
>
> Based on an initial look my main suggestion is to set it up so these capabilities
> can be specified as static const structure in the drivers. Makes for easier to read
> and smaller code. Actually I can see no reason why you can't do this in your
> example driver. As far as I can tell these are shared across multiple instances
> of the driver anyway.
>
> Various comments inline. Basically they boil down to the fact this code could
> be much shorter with a few minor tweaks to how things are configured.
>
>
>> ---
>> drivers/hwmon/hwmon-core.c | 656 ++++++++++++++++++++++++++++++++++++++++++++
>> include/linux/hwmon-core.h | 211 ++++++++++++++
>> 2 files changed, 867 insertions(+), 0 deletions(-)
>> create mode 100644 drivers/hwmon/hwmon-core.c
>> create mode 100644 include/linux/hwmon-core.h
>>
>> diff --git a/drivers/hwmon/hwmon-core.c b/drivers/hwmon/hwmon-core.c
>> new file mode 100644
>> index 0000000..eb39a45
>> --- /dev/null
>> +++ b/drivers/hwmon/hwmon-core.c
>> @@ -0,0 +1,656 @@
>> +/*
>> + * hwmon-core.c
>> + * Copyright (C) 2011 Lucas Stach
>> + *
>> + * hwmon-core interface implementation
>> + *
>> + * Provides functions to create/destroy a sysfs interface out of a
>> + * hwmon_device_instance.
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License version 2 as
>> + * published by the Free Software Foundation.
>> + */
>> +
>> +#include <linux/module.h>
>> +#include <linux/kernel.h>
>> +#include <linux/device.h>
>> +#include <linux/slab.h>
>> +#include <linux/list.h>
>> +#include <linux/hwmon-core.h>
>> +#include <linux/hwmon-sysfs.h>
>> +
>> +#define HWMON_NAME_SIZE 32
>> +
>> +struct hwmon_device_attribute {
>> + struct sensor_device_attribute sensor_dev;
>> + struct hwmon_device_instance *hw_dev_inst;
>> + char name[HWMON_NAME_SIZE];
>> + struct list_head node;
>> +};
>> +
>> +#define to_hwmon_device_attr(_sensor_attr) \
>> + container_of(_sensor_attr, struct hwmon_device_attribute, sensor_dev)
>> +
>> +#define HWMON_GET_TEXT_ACCESSOR(_name, _enum) \
>> + static ssize_t _name(struct device *dev, \
>> + struct device_attribute *devattr, char *buf) \
>> + { \
>> + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); \
>> + struct hwmon_device_attribute *hw_attr = to_hwmon_device_attr(attr); \
>> + struct hwmon_device_instance *hw_dev = hw_attr->hw_dev_inst; \
>> + return hw_dev->get_text_attr(hw_dev->inst_data, \
>> + _enum, attr->index, buf); \
>> + }
>> +
>> +#define HWMON_GET_NUM_ACCESSOR(_name, _enum) \
>> + static ssize_t _name(struct device *dev, \
>> + struct device_attribute *devattr, char *buf) \
>> + { \
>> + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); \
>> + struct hwmon_device_attribute *hw_attr = to_hwmon_device_attr(attr); \
>> + struct hwmon_device_instance *hw_dev = hw_attr->hw_dev_inst; \
>> + int value, ret; \
>> + ret = hw_dev->get_numeric_attr(hw_dev->inst_data, \
>> + _enum, attr->index, &value); \
>> + if(ret) \
>> + return ret; \
>> + ret = snprintf(buf, PAGE_SIZE, "%u\n", value); \
>> + return ret; \
>> + }
>> +
>> +#define HWMON_SET_NUM_ACCESSOR(_name, _enum) \
>> + static ssize_t _name(struct device *dev, \
>> + struct device_attribute *devattr, const char *buf, size_t count) \
>> + { \
>> + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); \
>> + struct hwmon_device_attribute *hw_attr = to_hwmon_device_attr(attr); \
>> + struct hwmon_device_instance *hw_dev = hw_attr->hw_dev_inst; \
>> + long value; \
>> + if(strict_strtol(buf, 10, &value)) \
>> + return -EINVAL; \
>> + hw_dev->set_numeric_attr(hw_dev->inst_data, \
>> + _enum, attr->index, value); \
>> + return count; \
>> + }
>> +
> Why not just encapsulate the enum into a structure then you will only need one accessor
> for each type of reading? Just use a sensor_device_attribute and put it in the index
> field. Lots less code and same result. Also means you can drop the function pointers
> in my suggestion below. Whilst you currently pass on the attr->index value I can't
> see any where it is actually set?
Sorry, I see you are using that for channel index.
Use the two parameter form of sensor_device_attribute_2 instead and the point still holds.
>
>
>> +/* accessor functions to route sysfs to hwmon core api */
>> +
>> +HWMON_GET_TEXT_ACCESSOR(show_name, hwmon_attr_name)
>> +HWMON_GET_NUM_ACCESSOR(show_update_interval, hwmon_attr_update_interval)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_in_min, hwmon_attr_volt_min)
>> +HWMON_SET_NUM_ACCESSOR(set_in_min, hwmon_attr_volt_min)
>> +HWMON_GET_NUM_ACCESSOR(show_in_lcrit, hwmon_attr_volt_lcrit)
>> +HWMON_SET_NUM_ACCESSOR(set_in_lcrit, hwmon_attr_volt_lcrit)
>> +HWMON_GET_NUM_ACCESSOR(show_in_max, hwmon_attr_volt_max)
>> +HWMON_SET_NUM_ACCESSOR(set_in_max, hwmon_attr_volt_max)
>> +HWMON_GET_NUM_ACCESSOR(show_in_crit, hwmon_attr_volt_crit)
>> +HWMON_SET_NUM_ACCESSOR(set_in_crit, hwmon_attr_volt_crit)
>> +HWMON_GET_NUM_ACCESSOR(show_in_vid, hwmon_attr_volt_vid)
>> +HWMON_GET_TEXT_ACCESSOR(show_in_label, hwmon_attr_volt_label)
>> +HWMON_GET_NUM_ACCESSOR(show_in_input, hwmon_attr_volt_input)
>> +HWMON_GET_NUM_ACCESSOR(show_in_vrm, hwmon_attr_volt_vrm)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_fan_min, hwmon_attr_fan_min)
>> +HWMON_SET_NUM_ACCESSOR(set_fan_min, hwmon_attr_fan_min)
>> +HWMON_GET_NUM_ACCESSOR(show_fan_max, hwmon_attr_fan_max)
>> +HWMON_SET_NUM_ACCESSOR(set_fan_max, hwmon_attr_fan_max)
>> +HWMON_GET_NUM_ACCESSOR(show_fan_div, hwmon_attr_fan_div)
>> +HWMON_SET_NUM_ACCESSOR(set_fan_div, hwmon_attr_fan_div)
>> +HWMON_GET_NUM_ACCESSOR(show_fan_pulses, hwmon_attr_fan_pulses)
>> +HWMON_SET_NUM_ACCESSOR(set_fan_pulses, hwmon_attr_fan_pulses)
>> +HWMON_GET_NUM_ACCESSOR(show_fan_target, hwmon_attr_fan_target)
>> +HWMON_SET_NUM_ACCESSOR(set_fan_target, hwmon_attr_fan_target)
>> +HWMON_GET_TEXT_ACCESSOR(show_fan_label, hwmon_attr_fan_label)
>> +HWMON_GET_NUM_ACCESSOR(show_fan_input, hwmon_attr_fan_input)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_pwm, hwmon_attr_pwm)
>> +HWMON_SET_NUM_ACCESSOR(set_pwm, hwmon_attr_pwm)
>> +HWMON_GET_NUM_ACCESSOR(show_pwm_enable, hwmon_attr_pwm_enable)
>> +HWMON_SET_NUM_ACCESSOR(set_pwm_enable, hwmon_attr_pwm_enable)
>> +HWMON_GET_NUM_ACCESSOR(show_pwm_mode, hwmon_attr_pwm_mode)
>> +HWMON_SET_NUM_ACCESSOR(set_pwm_mode, hwmon_attr_pwm_mode)
>> +HWMON_GET_NUM_ACCESSOR(show_pwm_freq, hwmon_attr_pwm_freq)
>> +HWMON_SET_NUM_ACCESSOR(set_pwm_freq, hwmon_attr_pwm_freq)
>> +HWMON_GET_NUM_ACCESSOR(show_pwm_auto_ct, hwmon_attr_pwm_auto_channels_temp)
>> +HWMON_SET_NUM_ACCESSOR(set_pwm_auto_ct, hwmon_attr_pwm_auto_channels_temp)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_temp_input, hwmon_attr_temp_input)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_type, hwmon_attr_temp_type)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_type, hwmon_attr_temp_type)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_max, hwmon_attr_temp_max)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_max, hwmon_attr_temp_max)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_min, hwmon_attr_temp_min)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_min, hwmon_attr_temp_min)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_max_hyst, hwmon_attr_temp_max_hyst)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_max_hyst, hwmon_attr_temp_max_hyst)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_crit, hwmon_attr_temp_crit)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_crit, hwmon_attr_temp_crit)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_crit_hyst, hwmon_attr_temp_crit_hyst)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_crit_hyst, hwmon_attr_temp_crit_hyst)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_emergency, hwmon_attr_temp_emergency)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_emergency, hwmon_attr_temp_emergency)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_emergency_hyst, hwmon_attr_temp_emergency_hyst)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_emergency_hyst, hwmon_attr_temp_emergency_hyst)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_lcrit, hwmon_attr_temp_lcrit)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_lcrit, hwmon_attr_temp_lcrit)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_offset, hwmon_attr_temp_offset)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_offset, hwmon_attr_temp_offset)
>> +HWMON_GET_TEXT_ACCESSOR(show_temp_label, hwmon_attr_temp_label)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_lowest, hwmon_attr_temp_lowest)
>> +HWMON_GET_NUM_ACCESSOR(show_temp_highest, hwmon_attr_temp_highest)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_reset_hist, hwmon_attr_temp_reset_history)
>> +HWMON_SET_NUM_ACCESSOR(set_temp_reset_hist_glob,
>> + hwmon_attr_temp_reset_history_glob)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_curr_max, hwmon_attr_curr_max)
>> +HWMON_SET_NUM_ACCESSOR(set_curr_max, hwmon_attr_curr_max)
>> +HWMON_GET_NUM_ACCESSOR(show_curr_min, hwmon_attr_curr_min)
>> +HWMON_SET_NUM_ACCESSOR(set_curr_min, hwmon_attr_curr_min)
>> +HWMON_GET_NUM_ACCESSOR(show_curr_lcrit, hwmon_attr_curr_lcrit)
>> +HWMON_SET_NUM_ACCESSOR(set_curr_lcrit, hwmon_attr_curr_lcrit)
>> +HWMON_GET_NUM_ACCESSOR(show_curr_crit, hwmon_attr_curr_crit)
>> +HWMON_SET_NUM_ACCESSOR(set_curr_crit, hwmon_attr_curr_crit)
>> +HWMON_GET_NUM_ACCESSOR(show_curr_input, hwmon_attr_curr_input)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average, hwmon_attr_pow_average)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_int, hwmon_attr_pow_average_interval)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_average_int, hwmon_attr_pow_average_interval)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_int_max,
>> + hwmon_attr_pow_average_interval_max)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_int_min,
>> + hwmon_attr_pow_average_interval_min)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_highest,
>> + hwmon_attr_pow_average_highest)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_lowest,
>> + hwmon_attr_pow_average_lowest)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_max, hwmon_attr_pow_average_max)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_average_max, hwmon_attr_pow_average_max)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_average_min, hwmon_attr_pow_average_min)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_average_min, hwmon_attr_pow_average_min)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_input, hwmon_attr_pow_input)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_input_highest, hwmon_attr_pow_input_highest)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_input_lowest, hwmon_attr_pow_input_lowest)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_reset_history, hwmon_attr_pow_reset_history)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_accuracy, hwmon_attr_pow_accuracy)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_cap, hwmon_attr_pow_cap)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_cap, hwmon_attr_pow_cap)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_cap_hyst, hwmon_attr_pow_cap_hyst)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_cap_hyst, hwmon_attr_pow_cap_hyst)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_cap_max, hwmon_attr_pow_cap_max)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_cap_min, hwmon_attr_pow_cap_min)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_max, hwmon_attr_pow_max)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_max, hwmon_attr_pow_max)
>> +HWMON_GET_NUM_ACCESSOR(show_pow_crit, hwmon_attr_pow_crit)
>> +HWMON_SET_NUM_ACCESSOR(set_pow_crit, hwmon_attr_pow_crit)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_energy_input, hwmon_attr_ener_input)
>> +
>> +HWMON_GET_NUM_ACCESSOR(show_humidity_input, hwmon_attr_humi_input)
>> +
>> +/* functions to build/destroy sysfs entries from given hwmon caps */
>> +
>> +static int new_sysfs_entry(const char *name, mode_t mode,
>> + ssize_t (*show)(struct device *, struct device_attribute *, char *),
>> + ssize_t (*store)(struct device *, struct device_attribute *,
>> + const char *, size_t),
>> + int index, struct list_head *list, struct device *dev)
>> +{
>> + struct hwmon_device_attribute *hw_dev_attr;
>> + int ret = 0;
>> +
>> + hw_dev_attr = kzalloc(sizeof(struct hwmon_device_attribute), GFP_KERNEL);
>> + if(!hw_dev_attr)
>> + return -ENOMEM;
>> +
>> + strlcpy(hw_dev_attr->name, name, 32);
>> +
>> + hw_dev_attr->sensor_dev.dev_attr.attr.name = hw_dev_attr->name;
>> + hw_dev_attr->sensor_dev.dev_attr.attr.mode = mode;
>> + hw_dev_attr->sensor_dev.dev_attr.show = show;
>> + hw_dev_attr->sensor_dev.dev_attr.store = store;
>> + hw_dev_attr->sensor_dev.index = index;
>> + hw_dev_attr->hw_dev_inst = dev_get_drvdata(dev);
>> + sysfs_attr_init(&hw_dev_attr->sensor_dev.dev_attr.attr);
>> +
>> + ret = device_create_file(dev->parent, &hw_dev_attr->sensor_dev.dev_attr);
>> + if(ret) {
>> + kfree(hw_dev_attr);
>> + return ret;
>> + }
>> +
>> + list_add(&hw_dev_attr->node, list);
>> +
>> + return 0;
>> +}
>> +
>> +int hwmon_create_sysfs(struct device *dev)
>> +{
>> + struct hwmon_device_instance *hw_dev = dev_get_drvdata(dev);
>> + struct hwmon_device_caps *caps = &hw_dev->caps;
>> + char attr_name[HWMON_NAME_SIZE];
>> + int i;
>> +
>> + INIT_LIST_HEAD(&hw_dev->sysfs_node);
>> +
>> + new_sysfs_entry("name", S_IRUGO, &show_name, NULL, 0,
>> + &hw_dev->sysfs_node, dev);
>> + new_sysfs_entry("update_interval", S_IRUGO, &show_update_interval, NULL, 0,
>> + &hw_dev->sysfs_node, dev);
>> +
>> + /* voltage sysfs entries */
>> + for(i = 1; i <= caps->num_voltage; i++) {
>
> Hmm. the approach of lots of separate bit fields you have used in hwmon_device_caps
> does make this code overly repetative. Perhaps having
> a single voltage capabilities field, and using a bit mask would allow you to do
> this as a trivial use of a magic table.
>
> Say we have
>
> unsigned int volt_caps:8;
> enum {
> min,
> lcrit,
> max,
> crit,
> label,
> vid,
> vrm,
> } volt_caps;
>
> enum {
> text,
> value,
> } cap_type;
> struct cap_info {
> const char *format_string;
> enum cap_type;
> /* some function pointers */
> }
>
> struct cap_info[] = {
> [min] = { "in%u_min", value, &show_in_min, &set_in_min },
> [lcrit] = { "in%u_lcrit", value, &show_in_lcrit, &set_in_lcrit },
> ...
> };
>
> The the following just becomes a for_each_bit_set() against that structure.
>
> With a little extension of this principal, all the different channel types
> can be handled as well.
>
>
>> + if(caps->volt_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_in_min,
>> + &set_in_min, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->volt_lcrit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_lcrit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_in_lcrit,
>> + &set_in_lcrit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->volt_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_in_max,
>> + &set_in_max, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->volt_crit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_crit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_in_crit,
>> + &set_in_crit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->volt_vid) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "cpu%u_vid", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_in_vid,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->volt_label) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_label", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_in_label,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + snprintf(attr_name, HWMON_NAME_SIZE, "in%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_in_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->num_voltage && caps->volt_vrm) {
>> + if(new_sysfs_entry("in_vrm", S_IRUGO, &show_in_vrm,
>> + NULL, 0, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* fan sysfs entries */
>> + for(i = 1; i <= caps->num_fan; i++) {
>> + if(caps->fan_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_fan_min,
>> + &set_fan_min, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->fan_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_fan_max,
>> + &set_fan_max, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->fan_div) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_div", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_fan_div,
>> + &set_fan_div, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->fan_pulses) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_pulses", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_fan_pulses,
>> + &set_fan_pulses, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->fan_target) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_target", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_fan_target,
>> + &set_fan_target, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->fan_label) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_label", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_fan_label,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + snprintf(attr_name, HWMON_NAME_SIZE, "fan%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_fan_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* pwm sysfs entries */
>> + for(i = 1; i <= caps->num_pwm; i++) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "pwm%u", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pwm,
>> + &set_pwm, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + snprintf(attr_name, HWMON_NAME_SIZE, "pwm%u_enable", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pwm_enable,
>> + &set_pwm_enable, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + snprintf(attr_name, HWMON_NAME_SIZE, "pwm%u_mode", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pwm_mode,
>> + &set_pwm_mode, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + if(caps->pwm_freq) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "pwm%u_freq", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pwm_freq,
>> + &set_pwm_freq, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pwm_auto_channels_temp) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "pwm%u_auto_channels_temp", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pwm_auto_ct,
>> + &set_pwm_auto_ct, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + }
>> +
>> + /* temp sysfs entries */
>> + for(i = 1; i <= caps->num_temp; i++) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_temp_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + if(caps->temp_type) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_type", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_type,
>> + &set_temp_type, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_max,
>> + &set_temp_max, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_min,
>> + &set_temp_min, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_max_hyst) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_max_hyst", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_max_hyst,
>> + &set_temp_max_hyst, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_crit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_crit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_crit,
>> + &set_temp_crit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_crit_hyst) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_crit_hyst", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_temp_crit_hyst, &set_temp_crit_hyst, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_emergency) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_emergency", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_temp_emergency, &set_temp_emergency, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_emergency_hyst) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_emergency_hyst", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_temp_emergency_hyst, &set_temp_emergency_hyst, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_lcrit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_lcrit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_lcrit,
>> + &set_temp_lcrit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_offset) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_offset", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_temp_offset,
>> + &set_temp_offset, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_label) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_label", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_temp_label,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_lowest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_lowest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_temp_lowest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_highest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_highest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_temp_highest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->temp_reset_history) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "temp%u_reset_history", i);
>> + if(new_sysfs_entry(attr_name, S_IWUGO, NULL,
>> + &set_temp_reset_hist, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + }
>> + if(caps->num_temp && caps->temp_reset_history) {
>> + if(new_sysfs_entry("temp_reset_history", S_IWUGO, NULL,
>> + &set_temp_reset_hist_glob, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* current sysfs entries */
>> + for(i = 1; i <= caps->num_current; i++) {
>> + if(caps->curr_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "curr%u_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_curr_max,
>> + &set_curr_max, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->curr_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "curr%u_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_curr_min,
>> + &set_curr_min, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->curr_lcrit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "curr%u_lcrit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_curr_lcrit,
>> + &set_curr_lcrit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->curr_crit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "curr%u_crit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_curr_crit,
>> + &set_curr_crit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + snprintf(attr_name, HWMON_NAME_SIZE, "curr%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_curr_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* power sysfs entries */
>> + for(i = 1; i <= caps->num_power; i++) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + if(caps->pow_average) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_average,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_interval) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average_interval", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_pow_average_int, &set_pow_average_int, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_interval_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE,
>> + "power%u_average_interval_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_average_int_max,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_interval_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE,
>> + "power%u_average_interval_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_average_int_min,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_highest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average_highest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_average_highest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_lowest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average_lowest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_average_lowest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_pow_average_max, &set_pow_average_max, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_average_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_average_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO,
>> + &show_pow_average_min, &set_pow_average_min, i,
>> + &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_input_highest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_input_highest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_input_highest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_input_lowest) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_input_lowest", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_input_lowest,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_reset_history) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_reset_history", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, NULL,
>> + &set_pow_reset_history, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_accuracy) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_accuracy", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_accuracy,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_cap) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_cap", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pow_cap,
>> + &set_pow_cap, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_cap_hyst) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_cap_hyst", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pow_cap_hyst,
>> + &set_pow_cap_hyst, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_cap_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_cap_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_cap_max,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_cap_min) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_cap_min", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_pow_cap_min,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_max) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_max", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pow_max,
>> + &set_pow_max, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + if(caps->pow_crit) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "power%u_crit", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO|S_IWUGO, &show_pow_crit,
>> + &set_pow_crit, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* energy sysfs entries */
>> + for(i = 1; i <= caps->num_energy; i++) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "energy%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_energy_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> +
>> + /* humidity sysfs entries */
>> + for(i = 1; i <= caps->num_humidity; i++) {
>> + snprintf(attr_name, HWMON_NAME_SIZE, "humidity%u_input", i);
>> + if(new_sysfs_entry(attr_name, S_IRUGO, &show_humidity_input,
>> + NULL, i, &hw_dev->sysfs_node, dev))
>> + goto fail;
>> + }
>> + }
>> +
>> + return 0;
>> +
>> +fail:
>> + hwmon_destroy_sysfs(dev);
>> + return -EAGAIN;
>> +}
>> +
>> +void hwmon_destroy_sysfs(struct device *dev)
>> +{
>> + struct hwmon_device_instance *hw_dev = dev_get_drvdata(dev);
>> + struct hwmon_device_attribute *hw_dev_attr, *tmp;
>> +
>> + list_for_each_entry_safe(hw_dev_attr, tmp, &hw_dev->sysfs_node, node) {
>> + device_remove_file(dev, &hw_dev_attr->sensor_dev.dev_attr);
>> + list_del(&hw_dev_attr->node);
>> + kfree(hw_dev_attr);
>> + }
>> +}
>> +
>> +EXPORT_SYMBOL_GPL(hwmon_create_sysfs);
>> +EXPORT_SYMBOL_GPL(hwmon_destroy_sysfs);
>> +
>> +MODULE_AUTHOR("Lucas Stach <dev@xxxxxxxxxx>");
>> +MODULE_DESCRIPTION("hardware monitoring core api support");
>> +MODULE_LICENSE("GPL");
>> diff --git a/include/linux/hwmon-core.h b/include/linux/hwmon-core.h
>> new file mode 100644
>> index 0000000..270ad67
>> --- /dev/null
>> +++ b/include/linux/hwmon-core.h
>> @@ -0,0 +1,211 @@
>> +/**
>> + * hwmon-core.h
>> + * Copyright (C) 2011 Lucas Stach
>> + *
>> + * hwmon-core interface definitions
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License version 2 as
>> + * published by the Free Software Foundation.
>> + */
>> +
>> +#ifndef HWMON_CORE_H_
>> +#define HWMON_CORE_H_
>> +
>> +struct hwmon_device;
>> +
>> +int hwmon_create_sysfs(struct device *dev);
>> +
>> +void hwmon_destroy_sysfs(struct device *dev);
>> +
>> +enum hwmon_numeric_attr {
>> + hwmon_attr_volt_min,
>> + hwmon_attr_volt_lcrit,
>> + hwmon_attr_volt_max,
>> + hwmon_attr_volt_crit,
>> + hwmon_attr_volt_input,
>> + hwmon_attr_volt_vid,
>> + hwmon_attr_volt_vrm,
>> +
>> + hwmon_attr_fan_min,
>> + hwmon_attr_fan_max,
>> + hwmon_attr_fan_input,
>> + hwmon_attr_fan_div,
>> + hwmon_attr_fan_pulses,
>> + hwmon_attr_fan_target,
>> +
>> + hwmon_attr_pwm,
>> + hwmon_attr_pwm_enable,
>> + hwmon_attr_pwm_mode,
>> + hwmon_attr_pwm_freq,
>> + hwmon_attr_pwm_auto_channels_temp,
>> + hwmon_attr_pwm_auto_point_pwm,
>> + hwmon_attr_pwm_auto_point_temp,
>> + hwmon_attr_pwm_auto_point_temp_hyst,
>> +
>> + hwmon_attr_temp_type,
>> + hwmon_attr_temp_max,
>> + hwmon_attr_temp_max_hyst,
>> + hwmon_attr_temp_min,
>> + hwmon_attr_temp_input,
>> + hwmon_attr_temp_crit,
>> + hwmon_attr_temp_crit_hyst,
>> + hwmon_attr_temp_emergency,
>> + hwmon_attr_temp_emergency_hyst,
>> + hwmon_attr_temp_lcrit,
>> + hwmon_attr_temp_offset,
>> + hwmon_attr_temp_lowest,
>> + hwmon_attr_temp_highest,
>> + hwmon_attr_temp_reset_history,
>> + hwmon_attr_temp_reset_history_glob,
>> + hwmon_attr_temp_auto_point_pwm,
>> + hwmon_attr_temp_auto_point_temp,
>> + hwmon_attr_temp_auto_point_hyst,
>> +
>> + hwmon_attr_curr_max,
>> + hwmon_attr_curr_min,
>> + hwmon_attr_curr_lcrit,
>> + hwmon_attr_curr_crit,
>> + hwmon_attr_curr_input,
>> +
>> + hwmon_attr_pow_average,
>> + hwmon_attr_pow_average_interval,
>> + hwmon_attr_pow_average_interval_max,
>> + hwmon_attr_pow_average_interval_min,
>> + hwmon_attr_pow_average_highest,
>> + hwmon_attr_pow_average_lowest,
>> + hwmon_attr_pow_average_max,
>> + hwmon_attr_pow_average_min,
>> + hwmon_attr_pow_input,
>> + hwmon_attr_pow_input_highest,
>> + hwmon_attr_pow_input_lowest,
>> + hwmon_attr_pow_reset_history,
>> + hwmon_attr_pow_accuracy,
>> + hwmon_attr_pow_cap,
>> + hwmon_attr_pow_cap_hyst,
>> + hwmon_attr_pow_cap_min,
>> + hwmon_attr_pow_cap_max,
>> + hwmon_attr_pow_max,
>> + hwmon_attr_pow_crit,
>> +
>> + hwmon_attr_ener_input,
>> +
>> + hwmon_attr_humi_input,
>> +
>> + hwmon_attr_intr_alarm,
>> + hwmon_attr_intr_beep,
>> +
>> + hwmon_attr_beep,
>> +
>> + hwmon_attr_update_interval
>> +};
>> +
>> +enum hwmon_text_attr {
>> + hwmon_attr_name,
>> + hwmon_attr_volt_label,
>> + hwmon_attr_fan_label,
>> + hwmon_attr_temp_label,
>> +};
>> +
> This structure is rather complex, and as far as I can tell
> puts lots of arbitary limits on numbers of channels.
>
>> +struct hwmon_device_caps {
>> + /* number of inputs */
>> + unsigned int num_voltage:4;
>> + unsigned int num_fan:4;
>> + unsigned int num_pwm:4;
>> + unsigned int num_temp:4;
>> + unsigned int num_current:4;
>> + unsigned int num_power:4;
>> + unsigned int num_energy:4;
>> + unsigned int num_humidity:4;
>> + unsigned int num_intrusion:4;
>> +
>> + unsigned int num_trip_points:4;
>> +
>> + /* voltage caps */
>> + unsigned int volt_min:1;
>> + unsigned int volt_lcrit:1;
>> + unsigned int volt_max:1;
>> + unsigned int volt_crit:1;
>> + unsigned int volt_label:1;
>> + unsigned int volt_vid:1;
>> + unsigned int volt_vrm:1;
>> +
>> + /* fan caps */
>> + unsigned int fan_min:1;
>> + unsigned int fan_max:1;
>> + unsigned int fan_div:1;
>> + unsigned int fan_pulses:1;
>> + unsigned int fan_target:1;
>> + unsigned int fan_label:1;
>> +
>> + /* pwm caps */
>> + unsigned int pwm_freq:1;
>> + unsigned int pwm_auto_channels_temp:1;
>> + unsigned int pwm_auto_point_pwm:1;
>> + unsigned int pwm_auto_point_temp:1;
>> + unsigned int pwm_auto_point_temp_hyst:1;
>> +
>> + /* temp caps */
>> + unsigned int temp_type:1;
>> + unsigned int temp_min:1;
>> + unsigned int temp_max:1;
>> + unsigned int temp_max_hyst:1;
>> + unsigned int temp_crit:1;
>> + unsigned int temp_crit_hyst:1;
>> + unsigned int temp_emergency:1;
>> + unsigned int temp_emergency_hyst:1;
>> + unsigned int temp_lcrit:1;
>> + unsigned int temp_offset:1;
>> + unsigned int temp_label:1;
>> + unsigned int temp_lowest:1;
>> + unsigned int temp_highest:1;
>> + unsigned int temp_reset_history:1;
>> + unsigned int temp_auto_point_pwm:1;
>> + unsigned int temp_auto_point_temp:1;
>> + unsigned int temp_auto_point_temp_hyst:1;
>> +
>> + /* current caps */
>> + unsigned int curr_max:1;
>> + unsigned int curr_min:1;
>> + unsigned int curr_lcrit:1;
>> + unsigned int curr_crit:1;
>> +
>> + /* power caps */
>> + unsigned int pow_average:1;
>> + unsigned int pow_average_interval:1;
>> + unsigned int pow_average_interval_min:1;
>> + unsigned int pow_average_interval_max:1;
>> + unsigned int pow_average_min:1;
>> + unsigned int pow_average_max:1;
>> + unsigned int pow_average_lowest:1;
>> + unsigned int pow_average_highest:1;
>> + unsigned int pow_input_lowest:1;
>> + unsigned int pow_input_highest:1;
>> + unsigned int pow_reset_history:1;
>> + unsigned int pow_accuracy:1;
>> + unsigned int pow_cap:1;
>> + unsigned int pow_cap_hyst:1;
>> + unsigned int pow_cap_min:1;
>> + unsigned int pow_cap_max:1;
>> + unsigned int pow_max:1;
>> + unsigned int pow_crit:1;
>> +
>> + /* alarm caps */
>> + unsigned int alarm_channel:1;
>> + unsigned int alarm_limit:1;
>> +};
>> +
>> +
>> +struct hwmon_device_instance {
>> + struct hwmon_device_caps caps;
>> + int (*get_numeric_attr) (void * inst_data, enum hwmon_numeric_attr attr,
>> + unsigned int index, int *value);
>> + int (*get_text_attr) (void * inst_data, enum hwmon_text_attr attr,
>> + unsigned int index, char *buf);
>> + int (*set_numeric_attr) (void * inst_data, enum hwmon_numeric_attr attr,
>> + unsigned int index, int value);
>> + struct list_head sysfs_node;
>> + void *inst_data;
>> +};
>> +
>> +#endif /* HWMON_CORE_H_ */
>
>
> _______________________________________________
> lm-sensors mailing list
> lm-sensors@xxxxxxxxxxxxxx
> http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
>
_______________________________________________
lm-sensors mailing list
lm-sensors@xxxxxxxxxxxxxx
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
