提交 77b0a4aa 编写于 作者: L Linus Torvalds

Merge tag 'hwmon-for-linus-v4.9' of...

Merge tag 'hwmon-for-linus-v4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging

Pull hwmon updates from Guenter Roeck:

 - New hwmon registration API, including ports of several drivers to the
   new API

 - New hwmon driver for APM X-Gene SoC

 - Added support for UCD90160, DPS-460, DPS-800, and SGD009 PMBUs chips

 - Various cleanups, minor improvements, and fixes in several drivers

* tag 'hwmon-for-linus-v4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging: (54 commits)
  hwmon: (nct6775) Add support for multiple virtual temperature sources
  hwmon: (adt7470) No need for additional synchronization on kthread_stop()
  hwmon: (lm95241) Update module description to include LM95231
  hwmon: (lm95245) Select REGMAP_I2C
  hwmon: (ibmpowernv) Fix label for cores numbers not threads
  hwmon: (adt7470) Allow faster removal
  hwmon: (adt7470) Add write support to alarm_mask
  hwmon: (xgene) access mailbox as RAM
  hwmon: (lm95245) Use new hwmon registration API
  hwmon: (lm95241) Convert to use new hwmon registration API
  hwmon: (jc42) Convert to use new hwmon registration API
  hwmon: (max31790) Convert to use new hwmon registration API
  hwmon: (nct7904) Convert to use new hwmon registration API
  hwmon: (ltc4245) Convert to use new hwmon registration API
  hwmon: (tmp421) Convert to use new hwmon registration API
  hwmon: (tmp102) Convert to use new hwmon registration API
  hwmon: (lm90) Convert to use new hwmon registration API
  hwmon: (lm75) Convert to use new hwmon registration API
  hwmon: (xgene) Fix crash when alarm occurs before driver probe
  hwmon: (iio_hwmon) defer probe when no channel is found
  ...
LTC4151 High Voltage I2C Current and Voltage Monitor
Required properties:
- compatible: Must be "lltc,ltc4151"
- reg: I2C address
Optional properties:
- shunt-resistor-micro-ohms
Shunt resistor value in micro-Ohms
Defaults to <1000> if unset.
Example:
ltc4151@6e {
compatible = "lltc,ltc4151";
reg = <0x6e>;
shunt-resistor-micro-ohms = <1500>;
};
Bindings for MAX6651 and MAX6650 I2C fan controllers
Reference:
[1] https://datasheets.maximintegrated.com/en/ds/MAX6650-MAX6651.pdf
Required properties:
- compatible : One of "maxim,max6650" or "maxim,max6651"
- reg : I2C address, one of 0x1b, 0x1f, 0x4b, 0x48.
Optional properties, default is to retain the chip's current setting:
- maxim,fan-microvolt : The supply voltage of the fan, either 5000000 uV or
12000000 uV.
- maxim,fan-prescale : Pre-scaling value, as per datasheet [1]. Lower values
allow more fine-grained control of slower fans.
Valid: 1, 2, 4, 8, 16.
- maxim,fan-target-rpm: Initial requested fan rotation speed. If specified, the
driver selects closed-loop mode and the requested speed.
This ensures the fan is already running before userspace
takes over.
Example:
fan-max6650: max6650@1b {
reg = <0x1b>;
compatible = "maxim,max6650";
maxim,fan-microvolt = <12000000>;
maxim,fan-prescale = <4>;
maxim,fan-target-rpm = <1200>;
};
...@@ -65,6 +65,23 @@ from 0 (off) to 255 (full speed). Fan speed will be set to maximum when the ...@@ -65,6 +65,23 @@ from 0 (off) to 255 (full speed). Fan speed will be set to maximum when the
temperature sensor associated with the PWM control exceeds temperature sensor associated with the PWM control exceeds
pwm#_auto_point2_temp. pwm#_auto_point2_temp.
The driver also allows control of the PWM frequency:
* pwm1_freq
The PWM frequency is rounded to the nearest one of:
* 11.0 Hz
* 14.7 Hz
* 22.1 Hz
* 29.4 Hz
* 35.3 Hz
* 44.1 Hz
* 58.8 Hz
* 88.2 Hz
* 1.4 kHz
* 22.5 kHz
Notes Notes
----- -----
......
...@@ -34,6 +34,19 @@ devm_hwmon_device_register_with_groups(struct device *dev, ...@@ -34,6 +34,19 @@ devm_hwmon_device_register_with_groups(struct device *dev,
const char *name, void *drvdata, const char *name, void *drvdata,
const struct attribute_group **groups); const struct attribute_group **groups);
struct device *
hwmon_device_register_with_info(struct device *dev,
const char *name, void *drvdata,
const struct hwmon_chip_info *info,
const struct attribute_group **groups);
struct device *
devm_hwmon_device_register_with_info(struct device *dev,
const char *name,
void *drvdata,
const struct hwmon_chip_info *info,
const struct attribute_group **groups);
void hwmon_device_unregister(struct device *dev); void hwmon_device_unregister(struct device *dev);
void devm_hwmon_device_unregister(struct device *dev); void devm_hwmon_device_unregister(struct device *dev);
...@@ -60,15 +73,229 @@ devm_hwmon_device_register_with_groups is similar to ...@@ -60,15 +73,229 @@ devm_hwmon_device_register_with_groups is similar to
hwmon_device_register_with_groups. However, it is device managed, meaning the hwmon_device_register_with_groups. However, it is device managed, meaning the
hwmon device does not have to be removed explicitly by the removal function. hwmon device does not have to be removed explicitly by the removal function.
hwmon_device_register_with_info is the most comprehensive and preferred means
to register a hardware monitoring device. It creates the standard sysfs
attributes in the hardware monitoring core, letting the driver focus on reading
from and writing to the chip instead of having to bother with sysfs attributes.
Its parameters are described in more detail below.
devm_hwmon_device_register_with_info is similar to
hwmon_device_register_with_info. However, it is device managed, meaning the
hwmon device does not have to be removed explicitly by the removal function.
hwmon_device_unregister deregisters a registered hardware monitoring device. hwmon_device_unregister deregisters a registered hardware monitoring device.
The parameter of this function is the pointer to the registered hardware The parameter of this function is the pointer to the registered hardware
monitoring device structure. This function must be called from the driver monitoring device structure. This function must be called from the driver
remove function if the hardware monitoring device was registered with remove function if the hardware monitoring device was registered with
hwmon_device_register or with hwmon_device_register_with_groups. hwmon_device_register, hwmon_device_register_with_groups, or
hwmon_device_register_with_info.
devm_hwmon_device_unregister does not normally have to be called. It is only devm_hwmon_device_unregister does not normally have to be called. It is only
needed for error handling, and only needed if the driver probe fails after needed for error handling, and only needed if the driver probe fails after
the call to devm_hwmon_device_register_with_groups. the call to devm_hwmon_device_register_with_groups and if the automatic
(device managed) removal would be too late.
Using devm_hwmon_device_register_with_info()
--------------------------------------------
hwmon_device_register_with_info() registers a hardware monitoring device.
The parameters to this function are
struct device *dev Pointer to parent device
const char *name Device name
void *drvdata Driver private data
const struct hwmon_chip_info *info
Pointer to chip description.
const struct attribute_group **groups
Null-terminated list of additional sysfs attribute
groups.
This function returns a pointer to the created hardware monitoring device
on success and a negative error code for failure.
The hwmon_chip_info structure looks as follows.
struct hwmon_chip_info {
const struct hwmon_ops *ops;
const struct hwmon_channel_info **info;
};
It contains the following fields:
* ops: Pointer to device operations.
* info: NULL-terminated list of device channel descriptors.
The list of hwmon operations is defined as:
struct hwmon_ops {
umode_t (*is_visible)(const void *, enum hwmon_sensor_types type,
u32 attr, int);
int (*read)(struct device *, enum hwmon_sensor_types type,
u32 attr, int, long *);
int (*write)(struct device *, enum hwmon_sensor_types type,
u32 attr, int, long);
};
It defines the following operations.
* is_visible: Pointer to a function to return the file mode for each supported
attribute. This function is mandatory.
* read: Pointer to a function for reading a value from the chip. This function
is optional, but must be provided if any readable attributes exist.
* write: Pointer to a function for writing a value to the chip. This function is
optional, but must be provided if any writeable attributes exist.
Each sensor channel is described with struct hwmon_channel_info, which is
defined as follows.
struct hwmon_channel_info {
enum hwmon_sensor_types type;
u32 *config;
};
It contains following fields:
* type: The hardware monitoring sensor type.
Supported sensor types are
* hwmon_chip A virtual sensor type, used to describe attributes
which apply to the entire chip.
* hwmon_temp Temperature sensor
* hwmon_in Voltage sensor
* hwmon_curr Current sensor
* hwmon_power Power sensor
* hwmon_energy Energy sensor
* hwmon_humidity Humidity sensor
* hwmon_fan Fan speed sensor
* hwmon_pwm PWM control
* config: Pointer to a 0-terminated list of configuration values for each
sensor of the given type. Each value is a combination of bit values
describing the attributes supposed by a single sensor.
As an example, here is the complete description file for a LM75 compatible
sensor chip. The chip has a single temperature sensor. The driver wants to
register with the thermal subsystem (HWMON_C_REGISTER_TZ), and it supports
the update_interval attribute (HWMON_C_UPDATE_INTERVAL). The chip supports
reading the temperature (HWMON_T_INPUT), it has a maximum temperature
register (HWMON_T_MAX) as well as a maximum temperature hysteresis register
(HWMON_T_MAX_HYST).
static const u32 lm75_chip_config[] = {
HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
0
};
static const struct hwmon_channel_info lm75_chip = {
.type = hwmon_chip,
.config = lm75_chip_config,
};
static const u32 lm75_temp_config[] = {
HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
0
};
static const struct hwmon_channel_info lm75_temp = {
.type = hwmon_temp,
.config = lm75_temp_config,
};
static const struct hwmon_channel_info *lm75_info[] = {
&lm75_chip,
&lm75_temp,
NULL
};
static const struct hwmon_ops lm75_hwmon_ops = {
.is_visible = lm75_is_visible,
.read = lm75_read,
.write = lm75_write,
};
static const struct hwmon_chip_info lm75_chip_info = {
.ops = &lm75_hwmon_ops,
.info = lm75_info,
};
A complete list of bit values indicating individual attribute support
is defined in include/linux/hwmon.h. Definition prefixes are as follows.
HWMON_C_xxxx Chip attributes, for use with hwmon_chip.
HWMON_T_xxxx Temperature attributes, for use with hwmon_temp.
HWMON_I_xxxx Voltage attributes, for use with hwmon_in.
HWMON_C_xxxx Current attributes, for use with hwmon_curr.
Notice the prefix overlap with chip attributes.
HWMON_P_xxxx Power attributes, for use with hwmon_power.
HWMON_E_xxxx Energy attributes, for use with hwmon_energy.
HWMON_H_xxxx Humidity attributes, for use with hwmon_humidity.
HWMON_F_xxxx Fan speed attributes, for use with hwmon_fan.
HWMON_PWM_xxxx PWM control attributes, for use with hwmon_pwm.
Driver callback functions
-------------------------
Each driver provides is_visible, read, and write functions. Parameters
and return values for those functions are as follows.
umode_t is_visible_func(const void *data, enum hwmon_sensor_types type,
u32 attr, int channel)
Parameters:
data: Pointer to device private data structure.
type: The sensor type.
attr: Attribute identifier associated with a specific attribute.
For example, the attribute value for HWMON_T_INPUT would be
hwmon_temp_input. For complete mappings of bit fields to
attribute values please see include/linux/hwmon.h.
channel:The sensor channel number.
Return value:
The file mode for this attribute. Typically, this will be 0 (the
attribute will not be created), S_IRUGO, or 'S_IRUGO | S_IWUSR'.
int read_func(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long *val)
Parameters:
dev: Pointer to the hardware monitoring device.
type: The sensor type.
attr: Attribute identifier associated with a specific attribute.
For example, the attribute value for HWMON_T_INPUT would be
hwmon_temp_input. For complete mappings please see
include/linux/hwmon.h.
channel:The sensor channel number.
val: Pointer to attribute value.
Return value:
0 on success, a negative error number otherwise.
int write_func(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long val)
Parameters:
dev: Pointer to the hardware monitoring device.
type: The sensor type.
attr: Attribute identifier associated with a specific attribute.
For example, the attribute value for HWMON_T_INPUT would be
hwmon_temp_input. For complete mappings please see
include/linux/hwmon.h.
channel:The sensor channel number.
val: The value to write to the chip.
Return value:
0 on success, a negative error number otherwise.
Driver-provided sysfs attributes
--------------------------------
If the hardware monitoring device is registered with
hwmon_device_register_with_info or devm_hwmon_device_register_with_info,
it is most likely not necessary to provide sysfs attributes. Only non-standard
sysfs attributes need to be provided when one of those registration functions
is used.
The header file linux/hwmon-sysfs.h provides a number of useful macros to The header file linux/hwmon-sysfs.h provides a number of useful macros to
declare and use hardware monitoring sysfs attributes. declare and use hardware monitoring sysfs attributes.
......
...@@ -34,6 +34,7 @@ fan3_input ro " ...@@ -34,6 +34,7 @@ fan3_input ro "
fan4_input ro " fan4_input ro "
fan1_target rw desired fan speed in RPM (closed loop mode only) fan1_target rw desired fan speed in RPM (closed loop mode only)
pwm1_enable rw regulator mode, 0=full on, 1=open loop, 2=closed loop pwm1_enable rw regulator mode, 0=full on, 1=open loop, 2=closed loop
3=off
pwm1 rw relative speed (0-255), 255=max. speed. pwm1 rw relative speed (0-255), 255=max. speed.
Used in open loop mode only. Used in open loop mode only.
fan1_div rw sets the speed range the inputs can handle. Legal fan1_div rw sets the speed range the inputs can handle. Legal
......
...@@ -2,12 +2,13 @@ Kernel driver ucd9000 ...@@ -2,12 +2,13 @@ Kernel driver ucd9000
===================== =====================
Supported chips: Supported chips:
* TI UCD90120, UCD90124, UCD9090, and UCD90910 * TI UCD90120, UCD90124, UCD90160, UCD9090, and UCD90910
Prefixes: 'ucd90120', 'ucd90124', 'ucd9090', 'ucd90910' Prefixes: 'ucd90120', 'ucd90124', 'ucd90160', 'ucd9090', 'ucd90910'
Addresses scanned: - Addresses scanned: -
Datasheets: Datasheets:
http://focus.ti.com/lit/ds/symlink/ucd90120.pdf http://focus.ti.com/lit/ds/symlink/ucd90120.pdf
http://focus.ti.com/lit/ds/symlink/ucd90124.pdf http://focus.ti.com/lit/ds/symlink/ucd90124.pdf
http://focus.ti.com/lit/ds/symlink/ucd90160.pdf
http://focus.ti.com/lit/ds/symlink/ucd9090.pdf http://focus.ti.com/lit/ds/symlink/ucd9090.pdf
http://focus.ti.com/lit/ds/symlink/ucd90910.pdf http://focus.ti.com/lit/ds/symlink/ucd90910.pdf
...@@ -32,6 +33,13 @@ interrupts, cascading, or other system functions. Twelve of these pins offer PWM ...@@ -32,6 +33,13 @@ interrupts, cascading, or other system functions. Twelve of these pins offer PWM
functionality. Using these pins, the UCD90124 offers support for fan control, functionality. Using these pins, the UCD90124 offers support for fan control,
margining, and general-purpose PWM functions. margining, and general-purpose PWM functions.
The UCD90160 is a 16-rail PMBus/I2C addressable power-supply sequencer and
monitor. The device integrates a 12-bit ADC for monitoring up to 16 power-supply
voltage inputs. Twenty-six GPIO pins can be used for power supply enables,
power-on reset signals, external interrupts, cascading, or other system
functions. Twelve of these pins offer PWM functionality. Using these pins, the
UCD90160 offers support for margining, and general-purpose PWM functions.
The UCD9090 is a 10-rail PMBus/I2C addressable power-supply sequencer and The UCD9090 is a 10-rail PMBus/I2C addressable power-supply sequencer and
monitor. The device integrates a 12-bit ADC for monitoring up to 10 power-supply monitor. The device integrates a 12-bit ADC for monitoring up to 10 power-supply
voltage inputs. Twenty-three GPIO pins can be used for power supply enables, voltage inputs. Twenty-three GPIO pins can be used for power supply enables,
......
Kernel driver xgene-hwmon
========================
Supported chips:
* APM X-Gene SoC
Description
-----------
This driver adds hardware temperature and power reading support for
APM X-Gene SoC using the mailbox communication interface.
For device tree, it is the standard DT mailbox.
For ACPI, it is the PCC mailbox.
The following sensors are supported
* Temperature
- SoC on-die temperature in milli-degree C
- Alarm when high/over temperature occurs
* Power
- CPU power in uW
- IO power in uW
sysfs-Interface
---------------
temp0_input - SoC on-die temperature (milli-degree C)
temp0_critical_alarm - An 1 would indicates on-die temperature exceeded threshold
power0_input - CPU power in (uW)
power1_input - IO power in (uW)
...@@ -969,7 +969,6 @@ config SENSORS_LM73 ...@@ -969,7 +969,6 @@ config SENSORS_LM73
config SENSORS_LM75 config SENSORS_LM75
tristate "National Semiconductor LM75 and compatibles" tristate "National Semiconductor LM75 and compatibles"
depends on I2C depends on I2C
depends on THERMAL || !THERMAL_OF
select REGMAP_I2C select REGMAP_I2C
help help
If you say yes here you get support for one common type of If you say yes here you get support for one common type of
...@@ -1119,6 +1118,7 @@ config SENSORS_LM95241 ...@@ -1119,6 +1118,7 @@ config SENSORS_LM95241
config SENSORS_LM95245 config SENSORS_LM95245
tristate "National Semiconductor LM95245 and compatibles" tristate "National Semiconductor LM95245 and compatibles"
depends on I2C depends on I2C
select REGMAP_I2C
help help
If you say yes here you get support for LM95235 and LM95245 If you say yes here you get support for LM95235 and LM95245
temperature sensor chips. temperature sensor chips.
...@@ -1572,7 +1572,6 @@ config SENSORS_THMC50 ...@@ -1572,7 +1572,6 @@ config SENSORS_THMC50
config SENSORS_TMP102 config SENSORS_TMP102
tristate "Texas Instruments TMP102" tristate "Texas Instruments TMP102"
depends on I2C depends on I2C
depends on THERMAL || !THERMAL_OF
select REGMAP_I2C select REGMAP_I2C
help help
If you say yes here you get support for Texas Instruments TMP102 If you say yes here you get support for Texas Instruments TMP102
...@@ -1823,6 +1822,13 @@ config SENSORS_ULTRA45 ...@@ -1823,6 +1822,13 @@ config SENSORS_ULTRA45
This driver provides support for the Ultra45 workstation environmental This driver provides support for the Ultra45 workstation environmental
sensors. sensors.
config SENSORS_XGENE
tristate "APM X-Gene SoC hardware monitoring driver"
depends on XGENE_SLIMPRO_MBOX || PCC
help
If you say yes here you get support for the temperature
and power sensors for APM X-Gene SoC.
if ACPI if ACPI
comment "ACPI drivers" comment "ACPI drivers"
......
...@@ -165,6 +165,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o ...@@ -165,6 +165,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o
obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o
obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o
obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o
obj-$(CONFIG_SENSORS_XGENE) += xgene-hwmon.o
obj-$(CONFIG_PMBUS) += pmbus/ obj-$(CONFIG_PMBUS) += pmbus/
......
...@@ -7,8 +7,7 @@ ...@@ -7,8 +7,7 @@
* it under the terms of the GNU General Public License version 2 as * it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation. * published by the Free Software Foundation.
* *
* TODO: SPI, support for external temperature sensor * TODO: SPI, use power-down mode for suspend?, interrupt handling?
* use power-down mode for suspend?, interrupt handling?
*/ */
#include <linux/kernel.h> #include <linux/kernel.h>
...@@ -31,6 +30,7 @@ ...@@ -31,6 +30,7 @@
#define ADT7411_REG_CFG1 0x18 #define ADT7411_REG_CFG1 0x18
#define ADT7411_CFG1_START_MONITOR (1 << 0) #define ADT7411_CFG1_START_MONITOR (1 << 0)
#define ADT7411_CFG1_RESERVED_BIT1 (1 << 1) #define ADT7411_CFG1_RESERVED_BIT1 (1 << 1)
#define ADT7411_CFG1_EXT_TDM (1 << 2)
#define ADT7411_CFG1_RESERVED_BIT3 (1 << 3) #define ADT7411_CFG1_RESERVED_BIT3 (1 << 3)
#define ADT7411_REG_CFG2 0x19 #define ADT7411_REG_CFG2 0x19
...@@ -57,6 +57,7 @@ struct adt7411_data { ...@@ -57,6 +57,7 @@ struct adt7411_data {
unsigned long next_update; unsigned long next_update;
int vref_cached; int vref_cached;
struct i2c_client *client; struct i2c_client *client;
bool use_ext_temp;
}; };
/* /*
...@@ -127,11 +128,20 @@ static ssize_t adt7411_show_vdd(struct device *dev, ...@@ -127,11 +128,20 @@ static ssize_t adt7411_show_vdd(struct device *dev,
static ssize_t adt7411_show_temp(struct device *dev, static ssize_t adt7411_show_temp(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
int nr = to_sensor_dev_attr(attr)->index;
struct adt7411_data *data = dev_get_drvdata(dev); struct adt7411_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client; struct i2c_client *client = data->client;
int val = adt7411_read_10_bit(client, ADT7411_REG_INT_TEMP_VDD_LSB, int val;
ADT7411_REG_INT_TEMP_MSB, 0); struct {
u8 low;
u8 high;
} reg[2] = {
{ ADT7411_REG_INT_TEMP_VDD_LSB, ADT7411_REG_INT_TEMP_MSB },
{ ADT7411_REG_EXT_TEMP_AIN14_LSB,
ADT7411_REG_EXT_TEMP_AIN1_MSB },
};
val = adt7411_read_10_bit(client, reg[nr].low, reg[nr].high, 0);
if (val < 0) if (val < 0)
return val; return val;
...@@ -218,11 +228,13 @@ static ssize_t adt7411_set_bit(struct device *dev, ...@@ -218,11 +228,13 @@ static ssize_t adt7411_set_bit(struct device *dev,
return ret < 0 ? ret : count; return ret < 0 ? ret : count;
} }
#define ADT7411_BIT_ATTR(__name, __reg, __bit) \ #define ADT7411_BIT_ATTR(__name, __reg, __bit) \
SENSOR_DEVICE_ATTR_2(__name, S_IRUGO | S_IWUSR, adt7411_show_bit, \ SENSOR_DEVICE_ATTR_2(__name, S_IRUGO | S_IWUSR, adt7411_show_bit, \
adt7411_set_bit, __bit, __reg) adt7411_set_bit, __bit, __reg)
static DEVICE_ATTR(temp1_input, S_IRUGO, adt7411_show_temp, NULL); static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, adt7411_show_temp, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, adt7411_show_temp, NULL, 1);
static DEVICE_ATTR(in0_input, S_IRUGO, adt7411_show_vdd, NULL); static DEVICE_ATTR(in0_input, S_IRUGO, adt7411_show_vdd, NULL);
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, adt7411_show_input, NULL, 0); static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, adt7411_show_input, NULL, 0);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, adt7411_show_input, NULL, 1); static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, adt7411_show_input, NULL, 1);
...@@ -237,7 +249,8 @@ static ADT7411_BIT_ATTR(fast_sampling, ADT7411_REG_CFG3, ADT7411_CFG3_ADC_CLK_22 ...@@ -237,7 +249,8 @@ static ADT7411_BIT_ATTR(fast_sampling, ADT7411_REG_CFG3, ADT7411_CFG3_ADC_CLK_22
static ADT7411_BIT_ATTR(adc_ref_vdd, ADT7411_REG_CFG3, ADT7411_CFG3_REF_VDD); static ADT7411_BIT_ATTR(adc_ref_vdd, ADT7411_REG_CFG3, ADT7411_CFG3_REF_VDD);
static struct attribute *adt7411_attrs[] = { static struct attribute *adt7411_attrs[] = {
&dev_attr_temp1_input.attr, &sensor_dev_attr_temp1_input.dev_attr.attr,
&sensor_dev_attr_temp2_input.dev_attr.attr,
&dev_attr_in0_input.attr, &dev_attr_in0_input.attr,
&sensor_dev_attr_in1_input.dev_attr.attr, &sensor_dev_attr_in1_input.dev_attr.attr,
&sensor_dev_attr_in2_input.dev_attr.attr, &sensor_dev_attr_in2_input.dev_attr.attr,
...@@ -253,7 +266,27 @@ static struct attribute *adt7411_attrs[] = { ...@@ -253,7 +266,27 @@ static struct attribute *adt7411_attrs[] = {
NULL NULL
}; };
ATTRIBUTE_GROUPS(adt7411); static umode_t adt7411_attrs_visible(struct kobject *kobj,
struct attribute *attr, int index)
{
struct device *dev = container_of(kobj, struct device, kobj);
struct adt7411_data *data = dev_get_drvdata(dev);
bool visible = true;
if (attr == &sensor_dev_attr_temp2_input.dev_attr.attr)
visible = data->use_ext_temp;
else if (attr == &sensor_dev_attr_in1_input.dev_attr.attr ||
attr == &sensor_dev_attr_in2_input.dev_attr.attr)
visible = !data->use_ext_temp;
return visible ? attr->mode : 0;
}
static const struct attribute_group adt7411_group = {
.attrs = adt7411_attrs,
.is_visible = adt7411_attrs_visible,
};
__ATTRIBUTE_GROUPS(adt7411);
static int adt7411_detect(struct i2c_client *client, static int adt7411_detect(struct i2c_client *client,
struct i2c_board_info *info) struct i2c_board_info *info)
...@@ -309,6 +342,8 @@ static int adt7411_init_device(struct adt7411_data *data) ...@@ -309,6 +342,8 @@ static int adt7411_init_device(struct adt7411_data *data)
if (ret < 0) if (ret < 0)
return ret; return ret;
data->use_ext_temp = ret & ADT7411_CFG1_EXT_TDM;
/* /*
* We must only write zero to bit 1 and only one to bit 3 according to * We must only write zero to bit 1 and only one to bit 3 according to
* the datasheet. * the datasheet.
......
...@@ -32,6 +32,7 @@ ...@@ -32,6 +32,7 @@
#include <linux/log2.h> #include <linux/log2.h>
#include <linux/kthread.h> #include <linux/kthread.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/util_macros.h>
/* Addresses to scan */ /* Addresses to scan */
static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END }; static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
...@@ -83,6 +84,7 @@ static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END }; ...@@ -83,6 +84,7 @@ static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
#define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
#define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
#define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
#define ADT7470_REG_CFG_2 0x74
#define ADT7470_REG_ACOUSTICS12 0x75 #define ADT7470_REG_ACOUSTICS12 0x75
#define ADT7470_REG_ACOUSTICS34 0x76 #define ADT7470_REG_ACOUSTICS34 0x76
#define ADT7470_REG_DEVICE 0x3D #define ADT7470_REG_DEVICE 0x3D
...@@ -142,6 +144,11 @@ static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END }; ...@@ -142,6 +144,11 @@ static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
#define FAN_PERIOD_INVALID 65535 #define FAN_PERIOD_INVALID 65535
#define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID) #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
/* Config registers 1 and 2 include fields for selecting the PWM frequency */
#define ADT7470_CFG_LF 0x40
#define ADT7470_FREQ_MASK 0x70
#define ADT7470_FREQ_SHIFT 4
struct adt7470_data { struct adt7470_data {
struct i2c_client *client; struct i2c_client *client;
struct mutex lock; struct mutex lock;
...@@ -170,7 +177,6 @@ struct adt7470_data { ...@@ -170,7 +177,6 @@ struct adt7470_data {
u8 pwm_auto_temp[ADT7470_PWM_COUNT]; u8 pwm_auto_temp[ADT7470_PWM_COUNT];
struct task_struct *auto_update; struct task_struct *auto_update;
struct completion auto_update_stop;
unsigned int auto_update_interval; unsigned int auto_update_interval;
}; };
...@@ -266,12 +272,14 @@ static int adt7470_update_thread(void *p) ...@@ -266,12 +272,14 @@ static int adt7470_update_thread(void *p)
mutex_lock(&data->lock); mutex_lock(&data->lock);
adt7470_read_temperatures(client, data); adt7470_read_temperatures(client, data);
mutex_unlock(&data->lock); mutex_unlock(&data->lock);
set_current_state(TASK_INTERRUPTIBLE);
if (kthread_should_stop()) if (kthread_should_stop())
break; break;
msleep_interruptible(data->auto_update_interval);
schedule_timeout(msecs_to_jiffies(data->auto_update_interval));
} }
complete_all(&data->auto_update_stop);
return 0; return 0;
} }
...@@ -538,6 +546,28 @@ static ssize_t show_alarm_mask(struct device *dev, ...@@ -538,6 +546,28 @@ static ssize_t show_alarm_mask(struct device *dev,
return sprintf(buf, "%x\n", data->alarms_mask); return sprintf(buf, "%x\n", data->alarms_mask);
} }
static ssize_t set_alarm_mask(struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
struct adt7470_data *data = dev_get_drvdata(dev);
long mask;
if (kstrtoul(buf, 0, &mask))
return -EINVAL;
if (mask & ~0xffff)
return -EINVAL;
mutex_lock(&data->lock);
data->alarms_mask = mask;
adt7470_write_word_data(data->client, ADT7470_REG_ALARM1_MASK, mask);
mutex_unlock(&data->lock);
return count;
}
static ssize_t show_fan_max(struct device *dev, static ssize_t show_fan_max(struct device *dev,
struct device_attribute *devattr, struct device_attribute *devattr,
char *buf) char *buf)
...@@ -688,6 +718,70 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, ...@@ -688,6 +718,70 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
return count; return count;
} }
/* These are the valid PWM frequencies to the nearest Hz */
static const int adt7470_freq_map[] = {
11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500
};
static ssize_t show_pwm_freq(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct adt7470_data *data = adt7470_update_device(dev);
unsigned char cfg_reg_1;
unsigned char cfg_reg_2;
int index;
mutex_lock(&data->lock);
cfg_reg_1 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG);
cfg_reg_2 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG_2);
mutex_unlock(&data->lock);
index = (cfg_reg_2 & ADT7470_FREQ_MASK) >> ADT7470_FREQ_SHIFT;
if (!(cfg_reg_1 & ADT7470_CFG_LF))
index += 8;
if (index >= ARRAY_SIZE(adt7470_freq_map))
index = ARRAY_SIZE(adt7470_freq_map) - 1;
return scnprintf(buf, PAGE_SIZE, "%d\n", adt7470_freq_map[index]);
}
static ssize_t set_pwm_freq(struct device *dev,
struct device_attribute *devattr,
const char *buf, size_t count)
{
struct adt7470_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
long freq;
int index;
int low_freq = ADT7470_CFG_LF;
unsigned char val;
if (kstrtol(buf, 10, &freq))
return -EINVAL;
/* Round the user value given to the closest available frequency */
index = find_closest(freq, adt7470_freq_map,
ARRAY_SIZE(adt7470_freq_map));
if (index >= 8) {
index -= 8;
low_freq = 0;
}
mutex_lock(&data->lock);
/* Configuration Register 1 */
val = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
i2c_smbus_write_byte_data(client, ADT7470_REG_CFG,
(val & ~ADT7470_CFG_LF) | low_freq);
/* Configuration Register 2 */
val = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG_2);
i2c_smbus_write_byte_data(client, ADT7470_REG_CFG_2,
(val & ~ADT7470_FREQ_MASK) | (index << ADT7470_FREQ_SHIFT));
mutex_unlock(&data->lock);
return count;
}
static ssize_t show_pwm_max(struct device *dev, static ssize_t show_pwm_max(struct device *dev,
struct device_attribute *devattr, struct device_attribute *devattr,
char *buf) char *buf)
...@@ -918,7 +1012,8 @@ static ssize_t show_alarm(struct device *dev, ...@@ -918,7 +1012,8 @@ static ssize_t show_alarm(struct device *dev,
return sprintf(buf, "0\n"); return sprintf(buf, "0\n");
} }
static DEVICE_ATTR(alarm_mask, S_IRUGO, show_alarm_mask, NULL); static DEVICE_ATTR(alarm_mask, S_IWUSR | S_IRUGO, show_alarm_mask,
set_alarm_mask);
static DEVICE_ATTR(num_temp_sensors, S_IWUSR | S_IRUGO, show_num_temp_sensors, static DEVICE_ATTR(num_temp_sensors, S_IWUSR | S_IRUGO, show_num_temp_sensors,
set_num_temp_sensors); set_num_temp_sensors);
static DEVICE_ATTR(auto_update_interval, S_IWUSR | S_IRUGO, static DEVICE_ATTR(auto_update_interval, S_IWUSR | S_IRUGO,
...@@ -1038,6 +1133,8 @@ static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1); ...@@ -1038,6 +1133,8 @@ static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2); static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3); static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
static DEVICE_ATTR(pwm1_freq, S_IWUSR | S_IRUGO, show_pwm_freq, set_pwm_freq);
static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO, static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
show_pwm_min, set_pwm_min, 0); show_pwm_min, set_pwm_min, 0);
static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO, static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
...@@ -1154,6 +1251,7 @@ static struct attribute *adt7470_attrs[] = { ...@@ -1154,6 +1251,7 @@ static struct attribute *adt7470_attrs[] = {
&sensor_dev_attr_fan4_alarm.dev_attr.attr, &sensor_dev_attr_fan4_alarm.dev_attr.attr,
&sensor_dev_attr_force_pwm_max.dev_attr.attr, &sensor_dev_attr_force_pwm_max.dev_attr.attr,
&sensor_dev_attr_pwm1.dev_attr.attr, &sensor_dev_attr_pwm1.dev_attr.attr,
&dev_attr_pwm1_freq.attr,
&sensor_dev_attr_pwm2.dev_attr.attr, &sensor_dev_attr_pwm2.dev_attr.attr,
&sensor_dev_attr_pwm3.dev_attr.attr, &sensor_dev_attr_pwm3.dev_attr.attr,
&sensor_dev_attr_pwm4.dev_attr.attr, &sensor_dev_attr_pwm4.dev_attr.attr,
...@@ -1256,7 +1354,6 @@ static int adt7470_probe(struct i2c_client *client, ...@@ -1256,7 +1354,6 @@ static int adt7470_probe(struct i2c_client *client,
if (IS_ERR(hwmon_dev)) if (IS_ERR(hwmon_dev))
return PTR_ERR(hwmon_dev); return PTR_ERR(hwmon_dev);
init_completion(&data->auto_update_stop);
data->auto_update = kthread_run(adt7470_update_thread, client, "%s", data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
dev_name(hwmon_dev)); dev_name(hwmon_dev));
if (IS_ERR(data->auto_update)) { if (IS_ERR(data->auto_update)) {
...@@ -1271,7 +1368,6 @@ static int adt7470_remove(struct i2c_client *client) ...@@ -1271,7 +1368,6 @@ static int adt7470_remove(struct i2c_client *client)
struct adt7470_data *data = i2c_get_clientdata(client); struct adt7470_data *data = i2c_get_clientdata(client);
kthread_stop(data->auto_update); kthread_stop(data->auto_update);
wait_for_completion(&data->auto_update_stop);
return 0; return 0;
} }
......
...@@ -36,6 +36,10 @@ ...@@ -36,6 +36,10 @@
#define FTS_EVENT_STATUS_REG 0x0006 #define FTS_EVENT_STATUS_REG 0x0006
#define FTS_GLOBAL_CONTROL_REG 0x0007 #define FTS_GLOBAL_CONTROL_REG 0x0007
#define FTS_DEVICE_DETECT_REG_1 0x0C
#define FTS_DEVICE_DETECT_REG_2 0x0D
#define FTS_DEVICE_DETECT_REG_3 0x0E
#define FTS_SENSOR_EVENT_REG 0x0010 #define FTS_SENSOR_EVENT_REG 0x0010
#define FTS_FAN_EVENT_REG 0x0014 #define FTS_FAN_EVENT_REG 0x0014
...@@ -54,6 +58,8 @@ ...@@ -54,6 +58,8 @@
#define FTS_NO_TEMP_SENSORS 0x10 #define FTS_NO_TEMP_SENSORS 0x10
#define FTS_NO_VOLT_SENSORS 0x04 #define FTS_NO_VOLT_SENSORS 0x04
static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
static struct i2c_device_id fts_id[] = { static struct i2c_device_id fts_id[] = {
{ "ftsteutates", 0 }, { "ftsteutates", 0 },
{ } { }
...@@ -734,6 +740,42 @@ static const struct attribute_group *fts_attr_groups[] = { ...@@ -734,6 +740,42 @@ static const struct attribute_group *fts_attr_groups[] = {
/*****************************************************************************/ /*****************************************************************************/
/* Module initialization / remove functions */ /* Module initialization / remove functions */
/*****************************************************************************/ /*****************************************************************************/
static int fts_detect(struct i2c_client *client,
struct i2c_board_info *info)
{
int val;
/* detection works with revsion greater or equal to 0x2b */
val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
if (val < 0x2b)
return -ENODEV;
/* Device Detect Regs must have 0x17 0x34 and 0x54 */
val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1);
if (val != 0x17)
return -ENODEV;
val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2);
if (val != 0x34)
return -ENODEV;
val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3);
if (val != 0x54)
return -ENODEV;
/*
* 0x10 == Baseboard Management Controller, 0x01 == Teutates
* Device ID Reg needs to be 0x11
*/
val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
if (val != 0x11)
return -ENODEV;
strlcpy(info->type, fts_id[0].name, I2C_NAME_SIZE);
info->flags = 0;
return 0;
}
static int fts_remove(struct i2c_client *client) static int fts_remove(struct i2c_client *client)
{ {
struct fts_data *data = dev_get_drvdata(&client->dev); struct fts_data *data = dev_get_drvdata(&client->dev);
...@@ -804,12 +846,15 @@ static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id) ...@@ -804,12 +846,15 @@ static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id)
/* Module Details */ /* Module Details */
/*****************************************************************************/ /*****************************************************************************/
static struct i2c_driver fts_driver = { static struct i2c_driver fts_driver = {
.class = I2C_CLASS_HWMON,
.driver = { .driver = {
.name = "ftsteutates", .name = "ftsteutates",
}, },
.id_table = fts_id, .id_table = fts_id,
.probe = fts_probe, .probe = fts_probe,
.remove = fts_remove, .remove = fts_remove,
.detect = fts_detect,
.address_list = normal_i2c,
}; };
module_i2c_driver(fts_driver); module_i2c_driver(fts_driver);
......
...@@ -12,17 +12,17 @@ ...@@ -12,17 +12,17 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h> #include <linux/bitops.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/slab.h>
#include <linux/kdev_t.h>
#include <linux/idr.h>
#include <linux/hwmon.h>
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/spinlock.h> #include <linux/hwmon.h>
#include <linux/idr.h>
#include <linux/module.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/thermal.h>
#define HWMON_ID_PREFIX "hwmon" #define HWMON_ID_PREFIX "hwmon"
#define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d" #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
...@@ -30,9 +30,35 @@ ...@@ -30,9 +30,35 @@
struct hwmon_device { struct hwmon_device {
const char *name; const char *name;
struct device dev; struct device dev;
const struct hwmon_chip_info *chip;
struct attribute_group group;
const struct attribute_group **groups;
}; };
#define to_hwmon_device(d) container_of(d, struct hwmon_device, dev) #define to_hwmon_device(d) container_of(d, struct hwmon_device, dev)
struct hwmon_device_attribute {
struct device_attribute dev_attr;
const struct hwmon_ops *ops;
enum hwmon_sensor_types type;
u32 attr;
int index;
};
#define to_hwmon_attr(d) \
container_of(d, struct hwmon_device_attribute, dev_attr)
/*
* Thermal zone information
* In addition to the reference to the hwmon device,
* also provides the sensor index.
*/
struct hwmon_thermal_data {
struct hwmon_device *hwdev; /* Reference to hwmon device */
int index; /* sensor index */
};
static ssize_t static ssize_t
show_name(struct device *dev, struct device_attribute *attr, char *buf) show_name(struct device *dev, struct device_attribute *attr, char *buf)
{ {
...@@ -80,25 +106,409 @@ static struct class hwmon_class = { ...@@ -80,25 +106,409 @@ static struct class hwmon_class = {
static DEFINE_IDA(hwmon_ida); static DEFINE_IDA(hwmon_ida);
/** /* Thermal zone handling */
* hwmon_device_register_with_groups - register w/ hwmon
* @dev: the parent device /*
* @name: hwmon name attribute * The complex conditional is necessary to avoid a cyclic dependency
* @drvdata: driver data to attach to created device * between hwmon and thermal_sys modules.
* @groups: List of attribute groups to create
*
* hwmon_device_unregister() must be called when the device is no
* longer needed.
*
* Returns the pointer to the new device.
*/ */
struct device * #if IS_REACHABLE(CONFIG_THERMAL) && defined(CONFIG_THERMAL_OF) && \
hwmon_device_register_with_groups(struct device *dev, const char *name, (!defined(CONFIG_THERMAL_HWMON) || \
void *drvdata, !(defined(MODULE) && IS_MODULE(CONFIG_THERMAL)))
const struct attribute_group **groups) static int hwmon_thermal_get_temp(void *data, int *temp)
{
struct hwmon_thermal_data *tdata = data;
struct hwmon_device *hwdev = tdata->hwdev;
int ret;
long t;
ret = hwdev->chip->ops->read(&hwdev->dev, hwmon_temp, hwmon_temp_input,
tdata->index, &t);
if (ret < 0)
return ret;
*temp = t;
return 0;
}
static struct thermal_zone_of_device_ops hwmon_thermal_ops = {
.get_temp = hwmon_thermal_get_temp,
};
static int hwmon_thermal_add_sensor(struct device *dev,
struct hwmon_device *hwdev, int index)
{
struct hwmon_thermal_data *tdata;
tdata = devm_kzalloc(dev, sizeof(*tdata), GFP_KERNEL);
if (!tdata)
return -ENOMEM;
tdata->hwdev = hwdev;
tdata->index = index;
devm_thermal_zone_of_sensor_register(&hwdev->dev, index, tdata,
&hwmon_thermal_ops);
return 0;
}
#else
static int hwmon_thermal_add_sensor(struct device *dev,
struct hwmon_device *hwdev, int index)
{
return 0;
}
#endif /* IS_REACHABLE(CONFIG_THERMAL) && ... */
/* sysfs attribute management */
static ssize_t hwmon_attr_show(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct hwmon_device_attribute *hattr = to_hwmon_attr(devattr);
long val;
int ret;
ret = hattr->ops->read(dev, hattr->type, hattr->attr, hattr->index,
&val);
if (ret < 0)
return ret;
return sprintf(buf, "%ld\n", val);
}
static ssize_t hwmon_attr_store(struct device *dev,
struct device_attribute *devattr,
const char *buf, size_t count)
{
struct hwmon_device_attribute *hattr = to_hwmon_attr(devattr);
long val;
int ret;
ret = kstrtol(buf, 10, &val);
if (ret < 0)
return ret;
ret = hattr->ops->write(dev, hattr->type, hattr->attr, hattr->index,
val);
if (ret < 0)
return ret;
return count;
}
static int hwmon_attr_base(enum hwmon_sensor_types type)
{
if (type == hwmon_in)
return 0;
return 1;
}
static struct attribute *hwmon_genattr(struct device *dev,
const void *drvdata,
enum hwmon_sensor_types type,
u32 attr,
int index,
const char *template,
const struct hwmon_ops *ops)
{
struct hwmon_device_attribute *hattr;
struct device_attribute *dattr;
struct attribute *a;
umode_t mode;
char *name;
/* The attribute is invisible if there is no template string */
if (!template)
return ERR_PTR(-ENOENT);
mode = ops->is_visible(drvdata, type, attr, index);
if (!mode)
return ERR_PTR(-ENOENT);
if ((mode & S_IRUGO) && !ops->read)
return ERR_PTR(-EINVAL);
if ((mode & S_IWUGO) && !ops->write)
return ERR_PTR(-EINVAL);
if (type == hwmon_chip) {
name = (char *)template;
} else {
name = devm_kzalloc(dev, strlen(template) + 16, GFP_KERNEL);
if (!name)
return ERR_PTR(-ENOMEM);
scnprintf(name, strlen(template) + 16, template,
index + hwmon_attr_base(type));
}
hattr = devm_kzalloc(dev, sizeof(*hattr), GFP_KERNEL);
if (!hattr)
return ERR_PTR(-ENOMEM);
hattr->type = type;
hattr->attr = attr;
hattr->index = index;
hattr->ops = ops;
dattr = &hattr->dev_attr;
dattr->show = hwmon_attr_show;
dattr->store = hwmon_attr_store;
a = &dattr->attr;
sysfs_attr_init(a);
a->name = name;
a->mode = mode;
return a;
}
static const char * const hwmon_chip_attr_templates[] = {
[hwmon_chip_temp_reset_history] = "temp_reset_history",
[hwmon_chip_in_reset_history] = "in_reset_history",
[hwmon_chip_curr_reset_history] = "curr_reset_history",
[hwmon_chip_power_reset_history] = "power_reset_history",
[hwmon_chip_update_interval] = "update_interval",
[hwmon_chip_alarms] = "alarms",
};
static const char * const hwmon_temp_attr_templates[] = {
[hwmon_temp_input] = "temp%d_input",
[hwmon_temp_type] = "temp%d_type",
[hwmon_temp_lcrit] = "temp%d_lcrit",
[hwmon_temp_lcrit_hyst] = "temp%d_lcrit_hyst",
[hwmon_temp_min] = "temp%d_min",
[hwmon_temp_min_hyst] = "temp%d_min_hyst",
[hwmon_temp_max] = "temp%d_max",
[hwmon_temp_max_hyst] = "temp%d_max_hyst",
[hwmon_temp_crit] = "temp%d_crit",
[hwmon_temp_crit_hyst] = "temp%d_crit_hyst",
[hwmon_temp_emergency] = "temp%d_emergency",
[hwmon_temp_emergency_hyst] = "temp%d_emergency_hyst",
[hwmon_temp_alarm] = "temp%d_alarm",
[hwmon_temp_lcrit_alarm] = "temp%d_lcrit_alarm",
[hwmon_temp_min_alarm] = "temp%d_min_alarm",
[hwmon_temp_max_alarm] = "temp%d_max_alarm",
[hwmon_temp_crit_alarm] = "temp%d_crit_alarm",
[hwmon_temp_emergency_alarm] = "temp%d_emergency_alarm",
[hwmon_temp_fault] = "temp%d_fault",
[hwmon_temp_offset] = "temp%d_offset",
[hwmon_temp_label] = "temp%d_label",
[hwmon_temp_lowest] = "temp%d_lowest",
[hwmon_temp_highest] = "temp%d_highest",
[hwmon_temp_reset_history] = "temp%d_reset_history",
};
static const char * const hwmon_in_attr_templates[] = {
[hwmon_in_input] = "in%d_input",
[hwmon_in_min] = "in%d_min",
[hwmon_in_max] = "in%d_max",
[hwmon_in_lcrit] = "in%d_lcrit",
[hwmon_in_crit] = "in%d_crit",
[hwmon_in_average] = "in%d_average",
[hwmon_in_lowest] = "in%d_lowest",
[hwmon_in_highest] = "in%d_highest",
[hwmon_in_reset_history] = "in%d_reset_history",
[hwmon_in_label] = "in%d_label",
[hwmon_in_alarm] = "in%d_alarm",
[hwmon_in_min_alarm] = "in%d_min_alarm",
[hwmon_in_max_alarm] = "in%d_max_alarm",
[hwmon_in_lcrit_alarm] = "in%d_lcrit_alarm",
[hwmon_in_crit_alarm] = "in%d_crit_alarm",
};
static const char * const hwmon_curr_attr_templates[] = {
[hwmon_curr_input] = "curr%d_input",
[hwmon_curr_min] = "curr%d_min",
[hwmon_curr_max] = "curr%d_max",
[hwmon_curr_lcrit] = "curr%d_lcrit",
[hwmon_curr_crit] = "curr%d_crit",
[hwmon_curr_average] = "curr%d_average",
[hwmon_curr_lowest] = "curr%d_lowest",
[hwmon_curr_highest] = "curr%d_highest",
[hwmon_curr_reset_history] = "curr%d_reset_history",
[hwmon_curr_label] = "curr%d_label",
[hwmon_curr_alarm] = "curr%d_alarm",
[hwmon_curr_min_alarm] = "curr%d_min_alarm",
[hwmon_curr_max_alarm] = "curr%d_max_alarm",
[hwmon_curr_lcrit_alarm] = "curr%d_lcrit_alarm",
[hwmon_curr_crit_alarm] = "curr%d_crit_alarm",
};
static const char * const hwmon_power_attr_templates[] = {
[hwmon_power_average] = "power%d_average",
[hwmon_power_average_interval] = "power%d_average_interval",
[hwmon_power_average_interval_max] = "power%d_interval_max",
[hwmon_power_average_interval_min] = "power%d_interval_min",
[hwmon_power_average_highest] = "power%d_average_highest",
[hwmon_power_average_lowest] = "power%d_average_lowest",
[hwmon_power_average_max] = "power%d_average_max",
[hwmon_power_average_min] = "power%d_average_min",
[hwmon_power_input] = "power%d_input",
[hwmon_power_input_highest] = "power%d_input_highest",
[hwmon_power_input_lowest] = "power%d_input_lowest",
[hwmon_power_reset_history] = "power%d_reset_history",
[hwmon_power_accuracy] = "power%d_accuracy",
[hwmon_power_cap] = "power%d_cap",
[hwmon_power_cap_hyst] = "power%d_cap_hyst",
[hwmon_power_cap_max] = "power%d_cap_max",
[hwmon_power_cap_min] = "power%d_cap_min",
[hwmon_power_max] = "power%d_max",
[hwmon_power_crit] = "power%d_crit",
[hwmon_power_label] = "power%d_label",
[hwmon_power_alarm] = "power%d_alarm",
[hwmon_power_cap_alarm] = "power%d_cap_alarm",
[hwmon_power_max_alarm] = "power%d_max_alarm",
[hwmon_power_crit_alarm] = "power%d_crit_alarm",
};
static const char * const hwmon_energy_attr_templates[] = {
[hwmon_energy_input] = "energy%d_input",
[hwmon_energy_label] = "energy%d_label",
};
static const char * const hwmon_humidity_attr_templates[] = {
[hwmon_humidity_input] = "humidity%d_input",
[hwmon_humidity_label] = "humidity%d_label",
[hwmon_humidity_min] = "humidity%d_min",
[hwmon_humidity_min_hyst] = "humidity%d_min_hyst",
[hwmon_humidity_max] = "humidity%d_max",
[hwmon_humidity_max_hyst] = "humidity%d_max_hyst",
[hwmon_humidity_alarm] = "humidity%d_alarm",
[hwmon_humidity_fault] = "humidity%d_fault",
};
static const char * const hwmon_fan_attr_templates[] = {
[hwmon_fan_input] = "fan%d_input",
[hwmon_fan_label] = "fan%d_label",
[hwmon_fan_min] = "fan%d_min",
[hwmon_fan_max] = "fan%d_max",
[hwmon_fan_div] = "fan%d_div",
[hwmon_fan_pulses] = "fan%d_pulses",
[hwmon_fan_target] = "fan%d_target",
[hwmon_fan_alarm] = "fan%d_alarm",
[hwmon_fan_min_alarm] = "fan%d_min_alarm",
[hwmon_fan_max_alarm] = "fan%d_max_alarm",
[hwmon_fan_fault] = "fan%d_fault",
};
static const char * const hwmon_pwm_attr_templates[] = {
[hwmon_pwm_input] = "pwm%d",
[hwmon_pwm_enable] = "pwm%d_enable",
[hwmon_pwm_mode] = "pwm%d_mode",
[hwmon_pwm_freq] = "pwm%d_freq",
};
static const char * const *__templates[] = {
[hwmon_chip] = hwmon_chip_attr_templates,
[hwmon_temp] = hwmon_temp_attr_templates,
[hwmon_in] = hwmon_in_attr_templates,
[hwmon_curr] = hwmon_curr_attr_templates,
[hwmon_power] = hwmon_power_attr_templates,
[hwmon_energy] = hwmon_energy_attr_templates,
[hwmon_humidity] = hwmon_humidity_attr_templates,
[hwmon_fan] = hwmon_fan_attr_templates,
[hwmon_pwm] = hwmon_pwm_attr_templates,
};
static const int __templates_size[] = {
[hwmon_chip] = ARRAY_SIZE(hwmon_chip_attr_templates),
[hwmon_temp] = ARRAY_SIZE(hwmon_temp_attr_templates),
[hwmon_in] = ARRAY_SIZE(hwmon_in_attr_templates),
[hwmon_curr] = ARRAY_SIZE(hwmon_curr_attr_templates),
[hwmon_power] = ARRAY_SIZE(hwmon_power_attr_templates),
[hwmon_energy] = ARRAY_SIZE(hwmon_energy_attr_templates),
[hwmon_humidity] = ARRAY_SIZE(hwmon_humidity_attr_templates),
[hwmon_fan] = ARRAY_SIZE(hwmon_fan_attr_templates),
[hwmon_pwm] = ARRAY_SIZE(hwmon_pwm_attr_templates),
};
static int hwmon_num_channel_attrs(const struct hwmon_channel_info *info)
{
int i, n;
for (i = n = 0; info->config[i]; i++)
n += hweight32(info->config[i]);
return n;
}
static int hwmon_genattrs(struct device *dev,
const void *drvdata,
struct attribute **attrs,
const struct hwmon_ops *ops,
const struct hwmon_channel_info *info)
{
const char * const *templates;
int template_size;
int i, aindex = 0;
if (info->type >= ARRAY_SIZE(__templates))
return -EINVAL;
templates = __templates[info->type];
template_size = __templates_size[info->type];
for (i = 0; info->config[i]; i++) {
u32 attr_mask = info->config[i];
u32 attr;
while (attr_mask) {
struct attribute *a;
attr = __ffs(attr_mask);
attr_mask &= ~BIT(attr);
if (attr >= template_size)
return -EINVAL;
a = hwmon_genattr(dev, drvdata, info->type, attr, i,
templates[attr], ops);
if (IS_ERR(a)) {
if (PTR_ERR(a) != -ENOENT)
return PTR_ERR(a);
continue;
}
attrs[aindex++] = a;
}
}
return aindex;
}
static struct attribute **
__hwmon_create_attrs(struct device *dev, const void *drvdata,
const struct hwmon_chip_info *chip)
{
int ret, i, aindex = 0, nattrs = 0;
struct attribute **attrs;
for (i = 0; chip->info[i]; i++)
nattrs += hwmon_num_channel_attrs(chip->info[i]);
if (nattrs == 0)
return ERR_PTR(-EINVAL);
attrs = devm_kcalloc(dev, nattrs + 1, sizeof(*attrs), GFP_KERNEL);
if (!attrs)
return ERR_PTR(-ENOMEM);
for (i = 0; chip->info[i]; i++) {
ret = hwmon_genattrs(dev, drvdata, &attrs[aindex], chip->ops,
chip->info[i]);
if (ret < 0)
return ERR_PTR(ret);
aindex += ret;
}
return attrs;
}
static struct device *
__hwmon_device_register(struct device *dev, const char *name, void *drvdata,
const struct hwmon_chip_info *chip,
const struct attribute_group **groups)
{ {
struct hwmon_device *hwdev; struct hwmon_device *hwdev;
int err, id; struct device *hdev;
int i, j, err, id;
/* Do not accept invalid characters in hwmon name attribute */ /* Do not accept invalid characters in hwmon name attribute */
if (name && (!strlen(name) || strpbrk(name, "-* \t\n"))) if (name && (!strlen(name) || strpbrk(name, "-* \t\n")))
...@@ -114,27 +524,127 @@ hwmon_device_register_with_groups(struct device *dev, const char *name, ...@@ -114,27 +524,127 @@ hwmon_device_register_with_groups(struct device *dev, const char *name,
goto ida_remove; goto ida_remove;
} }
hdev = &hwdev->dev;
if (chip && chip->ops->is_visible) {
struct attribute **attrs;
int ngroups = 2;
if (groups)
for (i = 0; groups[i]; i++)
ngroups++;
hwdev->groups = devm_kcalloc(dev, ngroups, sizeof(*groups),
GFP_KERNEL);
if (!hwdev->groups)
return ERR_PTR(-ENOMEM);
attrs = __hwmon_create_attrs(dev, drvdata, chip);
if (IS_ERR(attrs)) {
err = PTR_ERR(attrs);
goto free_hwmon;
}
hwdev->group.attrs = attrs;
ngroups = 0;
hwdev->groups[ngroups++] = &hwdev->group;
if (groups) {
for (i = 0; groups[i]; i++)
hwdev->groups[ngroups++] = groups[i];
}
hdev->groups = hwdev->groups;
} else {
hdev->groups = groups;
}
hwdev->name = name; hwdev->name = name;
hwdev->dev.class = &hwmon_class; hdev->class = &hwmon_class;
hwdev->dev.parent = dev; hdev->parent = dev;
hwdev->dev.groups = groups; hdev->of_node = dev ? dev->of_node : NULL;
hwdev->dev.of_node = dev ? dev->of_node : NULL; hwdev->chip = chip;
dev_set_drvdata(&hwdev->dev, drvdata); dev_set_drvdata(hdev, drvdata);
dev_set_name(&hwdev->dev, HWMON_ID_FORMAT, id); dev_set_name(hdev, HWMON_ID_FORMAT, id);
err = device_register(&hwdev->dev); err = device_register(hdev);
if (err) if (err)
goto free; goto free_hwmon;
if (chip && chip->ops->is_visible && chip->ops->read &&
chip->info[0]->type == hwmon_chip &&
(chip->info[0]->config[0] & HWMON_C_REGISTER_TZ)) {
const struct hwmon_channel_info **info = chip->info;
for (i = 1; info[i]; i++) {
if (info[i]->type != hwmon_temp)
continue;
for (j = 0; info[i]->config[j]; j++) {
if (!chip->ops->is_visible(drvdata, hwmon_temp,
hwmon_temp_input, j))
continue;
if (info[i]->config[j] & HWMON_T_INPUT)
hwmon_thermal_add_sensor(dev, hwdev, j);
}
}
}
return &hwdev->dev; return hdev;
free: free_hwmon:
kfree(hwdev); kfree(hwdev);
ida_remove: ida_remove:
ida_simple_remove(&hwmon_ida, id); ida_simple_remove(&hwmon_ida, id);
return ERR_PTR(err); return ERR_PTR(err);
} }
/**
* hwmon_device_register_with_groups - register w/ hwmon
* @dev: the parent device
* @name: hwmon name attribute
* @drvdata: driver data to attach to created device
* @groups: List of attribute groups to create
*
* hwmon_device_unregister() must be called when the device is no
* longer needed.
*
* Returns the pointer to the new device.
*/
struct device *
hwmon_device_register_with_groups(struct device *dev, const char *name,
void *drvdata,
const struct attribute_group **groups)
{
return __hwmon_device_register(dev, name, drvdata, NULL, groups);
}
EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups); EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups);
/**
* hwmon_device_register_with_info - register w/ hwmon
* @dev: the parent device
* @name: hwmon name attribute
* @drvdata: driver data to attach to created device
* @info: Pointer to hwmon chip information
* @groups - pointer to list of driver specific attribute groups
*
* hwmon_device_unregister() must be called when the device is no
* longer needed.
*
* Returns the pointer to the new device.
*/
struct device *
hwmon_device_register_with_info(struct device *dev, const char *name,
void *drvdata,
const struct hwmon_chip_info *chip,
const struct attribute_group **groups)
{
if (chip && (!chip->ops || !chip->info))
return ERR_PTR(-EINVAL);
return __hwmon_device_register(dev, name, drvdata, chip, groups);
}
EXPORT_SYMBOL_GPL(hwmon_device_register_with_info);
/** /**
* hwmon_device_register - register w/ hwmon * hwmon_device_register - register w/ hwmon
* @dev: the device to register * @dev: the device to register
...@@ -213,6 +723,48 @@ devm_hwmon_device_register_with_groups(struct device *dev, const char *name, ...@@ -213,6 +723,48 @@ devm_hwmon_device_register_with_groups(struct device *dev, const char *name,
} }
EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups); EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups);
/**
* devm_hwmon_device_register_with_info - register w/ hwmon
* @dev: the parent device
* @name: hwmon name attribute
* @drvdata: driver data to attach to created device
* @info: Pointer to hwmon chip information
* @groups - pointer to list of driver specific attribute groups
*
* Returns the pointer to the new device. The new device is automatically
* unregistered with the parent device.
*/
struct device *
devm_hwmon_device_register_with_info(struct device *dev, const char *name,
void *drvdata,
const struct hwmon_chip_info *chip,
const struct attribute_group **groups)
{
struct device **ptr, *hwdev;
if (!dev)
return ERR_PTR(-EINVAL);
ptr = devres_alloc(devm_hwmon_release, sizeof(*ptr), GFP_KERNEL);
if (!ptr)
return ERR_PTR(-ENOMEM);
hwdev = hwmon_device_register_with_info(dev, name, drvdata, chip,
groups);
if (IS_ERR(hwdev))
goto error;
*ptr = hwdev;
devres_add(dev, ptr);
return hwdev;
error:
devres_free(ptr);
return hwdev;
}
EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_info);
static int devm_hwmon_match(struct device *dev, void *res, void *data) static int devm_hwmon_match(struct device *dev, void *res, void *data)
{ {
struct device **hwdev = res; struct device **hwdev = res;
......
...@@ -143,13 +143,11 @@ static void __init make_sensor_label(struct device_node *np, ...@@ -143,13 +143,11 @@ static void __init make_sensor_label(struct device_node *np,
if (cpuid >= 0) if (cpuid >= 0)
/* /*
* The digital thermal sensors are associated * The digital thermal sensors are associated
* with a core. Let's print out the range of * with a core.
* cpu ids corresponding to the hardware
* threads of the core.
*/ */
n += snprintf(sdata->label + n, n += snprintf(sdata->label + n,
sizeof(sdata->label) - n, " %d-%d", sizeof(sdata->label) - n, " %d",
cpuid, cpuid + threads_per_core - 1); cpuid);
else else
n += snprintf(sdata->label + n, n += snprintf(sdata->label + n,
sizeof(sdata->label) - n, " phy%d", id); sizeof(sdata->label) - n, " phy%d", id);
......
...@@ -73,8 +73,11 @@ static int iio_hwmon_probe(struct platform_device *pdev) ...@@ -73,8 +73,11 @@ static int iio_hwmon_probe(struct platform_device *pdev)
name = dev->of_node->name; name = dev->of_node->name;
channels = iio_channel_get_all(dev); channels = iio_channel_get_all(dev);
if (IS_ERR(channels)) if (IS_ERR(channels)) {
if (PTR_ERR(channels) == -ENODEV)
return -EPROBE_DEFER;
return PTR_ERR(channels); return PTR_ERR(channels);
}
st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL); st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
if (st == NULL) { if (st == NULL) {
......
...@@ -2011,10 +2011,10 @@ static struct attribute *it87_attributes_in[] = { ...@@ -2011,10 +2011,10 @@ static struct attribute *it87_attributes_in[] = {
&sensor_dev_attr_in7_beep.dev_attr.attr, /* 39 */ &sensor_dev_attr_in7_beep.dev_attr.attr, /* 39 */
&sensor_dev_attr_in8_input.dev_attr.attr, /* 40 */ &sensor_dev_attr_in8_input.dev_attr.attr, /* 40 */
&sensor_dev_attr_in9_input.dev_attr.attr, /* 41 */ &sensor_dev_attr_in9_input.dev_attr.attr,
&sensor_dev_attr_in10_input.dev_attr.attr, /* 41 */ &sensor_dev_attr_in10_input.dev_attr.attr,
&sensor_dev_attr_in11_input.dev_attr.attr, /* 41 */ &sensor_dev_attr_in11_input.dev_attr.attr,
&sensor_dev_attr_in12_input.dev_attr.attr, /* 41 */ &sensor_dev_attr_in12_input.dev_attr.attr,
NULL NULL
}; };
......
...@@ -28,7 +28,6 @@ ...@@ -28,7 +28,6 @@
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/hwmon.h> #include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/of.h> #include <linux/of.h>
...@@ -254,170 +253,148 @@ static struct jc42_data *jc42_update_device(struct device *dev) ...@@ -254,170 +253,148 @@ static struct jc42_data *jc42_update_device(struct device *dev)
return ret; return ret;
} }
/* sysfs functions */ static int jc42_read(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long *val)
static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct jc42_data *data = jc42_update_device(dev);
if (IS_ERR(data))
return PTR_ERR(data);
return sprintf(buf, "%d\n",
jc42_temp_from_reg(data->temp[attr->index]));
}
static ssize_t show_temp_hyst(struct device *dev,
struct device_attribute *devattr, char *buf)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct jc42_data *data = jc42_update_device(dev); struct jc42_data *data = jc42_update_device(dev);
int temp, hyst; int temp, hyst;
if (IS_ERR(data)) if (IS_ERR(data))
return PTR_ERR(data); return PTR_ERR(data);
temp = jc42_temp_from_reg(data->temp[attr->index]); switch (attr) {
hyst = jc42_hysteresis[(data->config & JC42_CFG_HYST_MASK) case hwmon_temp_input:
>> JC42_CFG_HYST_SHIFT]; *val = jc42_temp_from_reg(data->temp[t_input]);
return sprintf(buf, "%d\n", temp - hyst); return 0;
case hwmon_temp_min:
*val = jc42_temp_from_reg(data->temp[t_min]);
return 0;
case hwmon_temp_max:
*val = jc42_temp_from_reg(data->temp[t_max]);
return 0;
case hwmon_temp_crit:
*val = jc42_temp_from_reg(data->temp[t_crit]);
return 0;
case hwmon_temp_max_hyst:
temp = jc42_temp_from_reg(data->temp[t_max]);
hyst = jc42_hysteresis[(data->config & JC42_CFG_HYST_MASK)
>> JC42_CFG_HYST_SHIFT];
*val = temp - hyst;
return 0;
case hwmon_temp_crit_hyst:
temp = jc42_temp_from_reg(data->temp[t_crit]);
hyst = jc42_hysteresis[(data->config & JC42_CFG_HYST_MASK)
>> JC42_CFG_HYST_SHIFT];
*val = temp - hyst;
return 0;
case hwmon_temp_min_alarm:
*val = (data->temp[t_input] >> JC42_ALARM_MIN_BIT) & 1;
return 0;
case hwmon_temp_max_alarm:
*val = (data->temp[t_input] >> JC42_ALARM_MAX_BIT) & 1;
return 0;
case hwmon_temp_crit_alarm:
*val = (data->temp[t_input] >> JC42_ALARM_CRIT_BIT) & 1;
return 0;
default:
return -EOPNOTSUPP;
}
} }
static ssize_t set_temp(struct device *dev, struct device_attribute *devattr, static int jc42_write(struct device *dev, enum hwmon_sensor_types type,
const char *buf, size_t count) u32 attr, int channel, long val)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct jc42_data *data = dev_get_drvdata(dev); struct jc42_data *data = dev_get_drvdata(dev);
int err, ret = count; struct i2c_client *client = data->client;
int nr = attr->index; int diff, hyst;
long val; int ret;
if (kstrtol(buf, 10, &val) < 0)
return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->temp[nr] = jc42_temp_to_reg(val, data->extended);
err = i2c_smbus_write_word_swapped(data->client, temp_regs[nr],
data->temp[nr]);
if (err < 0)
ret = err;
mutex_unlock(&data->update_lock);
return ret;
}
/* switch (attr) {
* JC42.4 compliant chips only support four hysteresis values. case hwmon_temp_min:
* Pick best choice and go from there. data->temp[t_min] = jc42_temp_to_reg(val, data->extended);
*/ ret = i2c_smbus_write_word_swapped(client, temp_regs[t_min],
static ssize_t set_temp_crit_hyst(struct device *dev, data->temp[t_min]);
struct device_attribute *attr, break;
const char *buf, size_t count) case hwmon_temp_max:
{ data->temp[t_max] = jc42_temp_to_reg(val, data->extended);
struct jc42_data *data = dev_get_drvdata(dev); ret = i2c_smbus_write_word_swapped(client, temp_regs[t_max],
long val; data->temp[t_max]);
int diff, hyst; break;
int err; case hwmon_temp_crit:
int ret = count; data->temp[t_crit] = jc42_temp_to_reg(val, data->extended);
ret = i2c_smbus_write_word_swapped(client, temp_regs[t_crit],
if (kstrtol(buf, 10, &val) < 0) data->temp[t_crit]);
return -EINVAL; break;
case hwmon_temp_crit_hyst:
val = clamp_val(val, (data->extended ? JC42_TEMP_MIN_EXTENDED : /*
JC42_TEMP_MIN) - 6000, JC42_TEMP_MAX); * JC42.4 compliant chips only support four hysteresis values.
diff = jc42_temp_from_reg(data->temp[t_crit]) - val; * Pick best choice and go from there.
*/
hyst = 0; val = clamp_val(val, (data->extended ? JC42_TEMP_MIN_EXTENDED
if (diff > 0) { : JC42_TEMP_MIN) - 6000,
if (diff < 2250) JC42_TEMP_MAX);
hyst = 1; /* 1.5 degrees C */ diff = jc42_temp_from_reg(data->temp[t_crit]) - val;
else if (diff < 4500) hyst = 0;
hyst = 2; /* 3.0 degrees C */ if (diff > 0) {
else if (diff < 2250)
hyst = 3; /* 6.0 degrees C */ hyst = 1; /* 1.5 degrees C */
else if (diff < 4500)
hyst = 2; /* 3.0 degrees C */
else
hyst = 3; /* 6.0 degrees C */
}
data->config = (data->config & ~JC42_CFG_HYST_MASK) |
(hyst << JC42_CFG_HYST_SHIFT);
ret = i2c_smbus_write_word_swapped(data->client,
JC42_REG_CONFIG,
data->config);
break;
default:
ret = -EOPNOTSUPP;
break;
} }
mutex_lock(&data->update_lock);
data->config = (data->config & ~JC42_CFG_HYST_MASK)
| (hyst << JC42_CFG_HYST_SHIFT);
err = i2c_smbus_write_word_swapped(data->client, JC42_REG_CONFIG,
data->config);
if (err < 0)
ret = err;
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return ret;
}
static ssize_t show_alarm(struct device *dev, return ret;
struct device_attribute *attr, char *buf)
{
u16 bit = to_sensor_dev_attr(attr)->index;
struct jc42_data *data = jc42_update_device(dev);
u16 val;
if (IS_ERR(data))
return PTR_ERR(data);
val = data->temp[t_input];
if (bit != JC42_ALARM_CRIT_BIT && (data->config & JC42_CFG_CRIT_ONLY))
val = 0;
return sprintf(buf, "%u\n", (val >> bit) & 1);
} }
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, t_input); static umode_t jc42_is_visible(const void *_data, enum hwmon_sensor_types type,
static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, set_temp, t_crit); u32 attr, int channel)
static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp, set_temp, t_min);
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp, set_temp, t_max);
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO, show_temp_hyst,
set_temp_crit_hyst, t_crit);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO, show_temp_hyst, NULL, t_max);
static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL,
JC42_ALARM_CRIT_BIT);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL,
JC42_ALARM_MIN_BIT);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
JC42_ALARM_MAX_BIT);
static struct attribute *jc42_attributes[] = {
&sensor_dev_attr_temp1_input.dev_attr.attr,
&sensor_dev_attr_temp1_crit.dev_attr.attr,
&sensor_dev_attr_temp1_min.dev_attr.attr,
&sensor_dev_attr_temp1_max.dev_attr.attr,
&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
NULL
};
static umode_t jc42_attribute_mode(struct kobject *kobj,
struct attribute *attr, int index)
{ {
struct device *dev = container_of(kobj, struct device, kobj); const struct jc42_data *data = _data;
struct jc42_data *data = dev_get_drvdata(dev);
unsigned int config = data->config; unsigned int config = data->config;
bool readonly; umode_t mode = S_IRUGO;
if (attr == &sensor_dev_attr_temp1_crit.dev_attr.attr) switch (attr) {
readonly = config & JC42_CFG_TCRIT_LOCK; case hwmon_temp_min:
else if (attr == &sensor_dev_attr_temp1_min.dev_attr.attr || case hwmon_temp_max:
attr == &sensor_dev_attr_temp1_max.dev_attr.attr) if (!(config & JC42_CFG_EVENT_LOCK))
readonly = config & JC42_CFG_EVENT_LOCK; mode |= S_IWUSR;
else if (attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr) break;
readonly = config & (JC42_CFG_EVENT_LOCK | JC42_CFG_TCRIT_LOCK); case hwmon_temp_crit:
else if (!(config & JC42_CFG_TCRIT_LOCK))
readonly = true; mode |= S_IWUSR;
break;
return S_IRUGO | (readonly ? 0 : S_IWUSR); case hwmon_temp_crit_hyst:
if (!(config & (JC42_CFG_EVENT_LOCK | JC42_CFG_TCRIT_LOCK)))
mode |= S_IWUSR;
break;
case hwmon_temp_input:
case hwmon_temp_max_hyst:
case hwmon_temp_min_alarm:
case hwmon_temp_max_alarm:
case hwmon_temp_crit_alarm:
break;
default:
mode = 0;
break;
}
return mode;
} }
static const struct attribute_group jc42_group = {
.attrs = jc42_attributes,
.is_visible = jc42_attribute_mode,
};
__ATTRIBUTE_GROUPS(jc42);
/* Return 0 if detection is successful, -ENODEV otherwise */ /* Return 0 if detection is successful, -ENODEV otherwise */
static int jc42_detect(struct i2c_client *client, struct i2c_board_info *info) static int jc42_detect(struct i2c_client *client, struct i2c_board_info *info)
{ {
...@@ -450,6 +427,34 @@ static int jc42_detect(struct i2c_client *client, struct i2c_board_info *info) ...@@ -450,6 +427,34 @@ static int jc42_detect(struct i2c_client *client, struct i2c_board_info *info)
return -ENODEV; return -ENODEV;
} }
static const u32 jc42_temp_config[] = {
HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_CRIT |
HWMON_T_MAX_HYST | HWMON_T_CRIT_HYST |
HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM,
0
};
static const struct hwmon_channel_info jc42_temp = {
.type = hwmon_temp,
.config = jc42_temp_config,
};
static const struct hwmon_channel_info *jc42_info[] = {
&jc42_temp,
NULL
};
static const struct hwmon_ops jc42_hwmon_ops = {
.is_visible = jc42_is_visible,
.read = jc42_read,
.write = jc42_write,
};
static const struct hwmon_chip_info jc42_chip_info = {
.ops = &jc42_hwmon_ops,
.info = jc42_info,
};
static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id) static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id)
{ {
struct device *dev = &client->dev; struct device *dev = &client->dev;
...@@ -482,9 +487,9 @@ static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id) ...@@ -482,9 +487,9 @@ static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id)
} }
data->config = config; data->config = config;
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
data, data, &jc42_chip_info,
jc42_groups); NULL);
return PTR_ERR_OR_ZERO(hwmon_dev); return PTR_ERR_OR_ZERO(hwmon_dev);
} }
......
...@@ -28,7 +28,6 @@ ...@@ -28,7 +28,6 @@
#include <linux/err.h> #include <linux/err.h>
#include <linux/of.h> #include <linux/of.h>
#include <linux/regmap.h> #include <linux/regmap.h>
#include <linux/thermal.h>
#include "lm75.h" #include "lm75.h"
...@@ -88,56 +87,75 @@ static inline long lm75_reg_to_mc(s16 temp, u8 resolution) ...@@ -88,56 +87,75 @@ static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8); return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
} }
/* sysfs attributes for hwmon */ static int lm75_read(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long *val)
static int lm75_read_temp(void *dev, int *temp)
{ {
struct lm75_data *data = dev_get_drvdata(dev); struct lm75_data *data = dev_get_drvdata(dev);
unsigned int _temp; unsigned int regval;
int err; int err, reg;
err = regmap_read(data->regmap, LM75_REG_TEMP, &_temp); switch (type) {
if (err < 0) case hwmon_chip:
return err; switch (attr) {
case hwmon_chip_update_interval:
*temp = lm75_reg_to_mc(_temp, data->resolution); *val = data->sample_time;
break;;
default:
return -EINVAL;
}
break;
case hwmon_temp:
switch (attr) {
case hwmon_temp_input:
reg = LM75_REG_TEMP;
break;
case hwmon_temp_max:
reg = LM75_REG_MAX;
break;
case hwmon_temp_max_hyst:
reg = LM75_REG_HYST;
break;
default:
return -EINVAL;
}
err = regmap_read(data->regmap, reg, &regval);
if (err < 0)
return err;
*val = lm75_reg_to_mc(regval, data->resolution);
break;
default:
return -EINVAL;
}
return 0; return 0;
} }
static ssize_t show_temp(struct device *dev, struct device_attribute *da, static int lm75_write(struct device *dev, enum hwmon_sensor_types type,
char *buf) u32 attr, int channel, long temp)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct lm75_data *data = dev_get_drvdata(dev); struct lm75_data *data = dev_get_drvdata(dev);
unsigned int temp = 0;
int err;
err = regmap_read(data->regmap, attr->index, &temp);
if (err < 0)
return err;
return sprintf(buf, "%ld\n", lm75_reg_to_mc(temp, data->resolution));
}
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 lm75_data *data = dev_get_drvdata(dev);
long temp;
int error;
u8 resolution; u8 resolution;
int reg;
if (type != hwmon_temp)
return -EINVAL;
error = kstrtol(buf, 10, &temp); switch (attr) {
if (error) case hwmon_temp_max:
return error; reg = LM75_REG_MAX;
break;
case hwmon_temp_max_hyst:
reg = LM75_REG_HYST;
break;
default:
return -EINVAL;
}
/* /*
* Resolution of limit registers is assumed to be the same as the * Resolution of limit registers is assumed to be the same as the
* temperature input register resolution unless given explicitly. * temperature input register resolution unless given explicitly.
*/ */
if (attr->index && data->resolution_limits) if (data->resolution_limits)
resolution = data->resolution_limits; resolution = data->resolution_limits;
else else
resolution = data->resolution; resolution = data->resolution;
...@@ -145,45 +163,77 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *da, ...@@ -145,45 +163,77 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *da,
temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX); temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
temp = DIV_ROUND_CLOSEST(temp << (resolution - 8), temp = DIV_ROUND_CLOSEST(temp << (resolution - 8),
1000) << (16 - resolution); 1000) << (16 - resolution);
error = regmap_write(data->regmap, attr->index, temp);
if (error < 0)
return error;
return count; return regmap_write(data->regmap, reg, temp);
} }
static ssize_t show_update_interval(struct device *dev, static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type,
struct device_attribute *da, char *buf) u32 attr, int channel)
{ {
struct lm75_data *data = dev_get_drvdata(dev); switch (type) {
case hwmon_chip:
return sprintf(buf, "%u\n", data->sample_time); switch (attr) {
case hwmon_chip_update_interval:
return S_IRUGO;
}
break;
case hwmon_temp:
switch (attr) {
case hwmon_temp_input:
return S_IRUGO;
case hwmon_temp_max:
case hwmon_temp_max_hyst:
return S_IRUGO | S_IWUSR;
}
break;
default:
break;
}
return 0;
} }
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, /*-----------------------------------------------------------------------*/
show_temp, set_temp, LM75_REG_MAX);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
show_temp, set_temp, LM75_REG_HYST);
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, LM75_REG_TEMP);
static DEVICE_ATTR(update_interval, S_IRUGO, show_update_interval, NULL);
static struct attribute *lm75_attrs[] = { /* device probe and removal */
&sensor_dev_attr_temp1_input.dev_attr.attr,
&sensor_dev_attr_temp1_max.dev_attr.attr,
&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
&dev_attr_update_interval.attr,
NULL /* chip configuration */
static const u32 lm75_chip_config[] = {
HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
0
}; };
ATTRIBUTE_GROUPS(lm75);
static const struct thermal_zone_of_device_ops lm75_of_thermal_ops = { static const struct hwmon_channel_info lm75_chip = {
.get_temp = lm75_read_temp, .type = hwmon_chip,
.config = lm75_chip_config,
}; };
/*-----------------------------------------------------------------------*/ static const u32 lm75_temp_config[] = {
HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
0
};
/* device probe and removal */ static const struct hwmon_channel_info lm75_temp = {
.type = hwmon_temp,
.config = lm75_temp_config,
};
static const struct hwmon_channel_info *lm75_info[] = {
&lm75_chip,
&lm75_temp,
NULL
};
static const struct hwmon_ops lm75_hwmon_ops = {
.is_visible = lm75_is_visible,
.read = lm75_read,
.write = lm75_write,
};
static const struct hwmon_chip_info lm75_chip_info = {
.ops = &lm75_hwmon_ops,
.info = lm75_info,
};
static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg) static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
{ {
...@@ -337,15 +387,12 @@ lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) ...@@ -337,15 +387,12 @@ lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
dev_dbg(dev, "Config %02x\n", new); dev_dbg(dev, "Config %02x\n", new);
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
data, lm75_groups); data, &lm75_chip_info,
NULL);
if (IS_ERR(hwmon_dev)) if (IS_ERR(hwmon_dev))
return PTR_ERR(hwmon_dev); return PTR_ERR(hwmon_dev);
devm_thermal_zone_of_sensor_register(hwmon_dev, 0,
hwmon_dev,
&lm75_of_thermal_ops);
dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name); dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
return 0; return 0;
......
此差异已折叠。
...@@ -15,22 +15,17 @@ ...@@ -15,22 +15,17 @@
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#include <linux/module.h> #include <linux/bitops.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h> #include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h> #include <linux/module.h>
#include <linux/err.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/sysfs.h> #include <linux/slab.h>
#define DEVNAME "lm95241" #define DEVNAME "lm95241"
...@@ -54,26 +49,25 @@ static const unsigned short normal_i2c[] = { ...@@ -54,26 +49,25 @@ static const unsigned short normal_i2c[] = {
#define LM95241_REG_RW_REMOTE_MODEL 0x30 #define LM95241_REG_RW_REMOTE_MODEL 0x30
/* LM95241 specific bitfields */ /* LM95241 specific bitfields */
#define CFG_STOP 0x40 #define CFG_STOP BIT(6)
#define CFG_CR0076 0x00 #define CFG_CR0076 0x00
#define CFG_CR0182 0x10 #define CFG_CR0182 BIT(4)
#define CFG_CR1000 0x20 #define CFG_CR1000 BIT(5)
#define CFG_CR2700 0x30 #define CFG_CR2700 (BIT(4) | BIT(5))
#define R1MS_SHIFT 0 #define CFG_CRMASK (BIT(4) | BIT(5))
#define R2MS_SHIFT 2 #define R1MS_MASK BIT(0)
#define R1MS_MASK (0x01 << (R1MS_SHIFT)) #define R2MS_MASK BIT(2)
#define R2MS_MASK (0x01 << (R2MS_SHIFT)) #define R1DF_MASK BIT(1)
#define R1DF_SHIFT 1 #define R2DF_MASK BIT(2)
#define R2DF_SHIFT 2 #define R1FE_MASK BIT(0)
#define R1DF_MASK (0x01 << (R1DF_SHIFT)) #define R2FE_MASK BIT(2)
#define R2DF_MASK (0x01 << (R2DF_SHIFT)) #define R1DM BIT(0)
#define R1FE_MASK 0x01 #define R2DM BIT(1)
#define R2FE_MASK 0x05 #define TT1_SHIFT 0
#define TT1_SHIFT 0 #define TT2_SHIFT 4
#define TT2_SHIFT 4 #define TT_OFF 0
#define TT_OFF 0 #define TT_ON 1
#define TT_ON 1 #define TT_MASK 7
#define TT_MASK 7
#define NATSEMI_MAN_ID 0x01 #define NATSEMI_MAN_ID 0x01
#define LM95231_CHIP_ID 0xA1 #define LM95231_CHIP_ID 0xA1
#define LM95241_CHIP_ID 0xA4 #define LM95241_CHIP_ID 0xA4
...@@ -91,11 +85,12 @@ static const u8 lm95241_reg_address[] = { ...@@ -91,11 +85,12 @@ static const u8 lm95241_reg_address[] = {
struct lm95241_data { struct lm95241_data {
struct i2c_client *client; struct i2c_client *client;
struct mutex update_lock; struct mutex update_lock;
unsigned long last_updated, interval; /* in jiffies */ unsigned long last_updated; /* in jiffies */
unsigned long interval; /* in milli-seconds */
char valid; /* zero until following fields are valid */ char valid; /* zero until following fields are valid */
/* registers values */ /* registers values */
u8 temp[ARRAY_SIZE(lm95241_reg_address)]; u8 temp[ARRAY_SIZE(lm95241_reg_address)];
u8 config, model, trutherm; u8 status, config, model, trutherm;
}; };
/* Conversions */ /* Conversions */
...@@ -118,7 +113,8 @@ static struct lm95241_data *lm95241_update_device(struct device *dev) ...@@ -118,7 +113,8 @@ static struct lm95241_data *lm95241_update_device(struct device *dev)
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (time_after(jiffies, data->last_updated + data->interval) || if (time_after(jiffies, data->last_updated
+ msecs_to_jiffies(data->interval)) ||
!data->valid) { !data->valid) {
int i; int i;
...@@ -127,6 +123,9 @@ static struct lm95241_data *lm95241_update_device(struct device *dev) ...@@ -127,6 +123,9 @@ static struct lm95241_data *lm95241_update_device(struct device *dev)
data->temp[i] data->temp[i]
= i2c_smbus_read_byte_data(client, = i2c_smbus_read_byte_data(client,
lm95241_reg_address[i]); lm95241_reg_address[i]);
data->status = i2c_smbus_read_byte_data(client,
LM95241_REG_R_STATUS);
data->last_updated = jiffies; data->last_updated = jiffies;
data->valid = 1; data->valid = 1;
} }
...@@ -136,197 +135,241 @@ static struct lm95241_data *lm95241_update_device(struct device *dev) ...@@ -136,197 +135,241 @@ static struct lm95241_data *lm95241_update_device(struct device *dev)
return data; return data;
} }
/* Sysfs stuff */ static int lm95241_read_chip(struct device *dev, u32 attr, int channel,
static ssize_t show_input(struct device *dev, struct device_attribute *attr, long *val)
char *buf)
{
struct lm95241_data *data = lm95241_update_device(dev);
int index = to_sensor_dev_attr(attr)->index;
return snprintf(buf, PAGE_SIZE - 1, "%d\n",
index == 0 || (data->config & (1 << (index / 2))) ?
temp_from_reg_signed(data->temp[index], data->temp[index + 1]) :
temp_from_reg_unsigned(data->temp[index],
data->temp[index + 1]));
}
static ssize_t show_type(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); struct lm95241_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE - 1, switch (attr) {
data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n"); case hwmon_chip_update_interval:
*val = data->interval;
return 0;
default:
return -EOPNOTSUPP;
}
} }
static ssize_t set_type(struct device *dev, struct device_attribute *attr, static int lm95241_read_temp(struct device *dev, u32 attr, int channel,
const char *buf, size_t count) long *val)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); struct lm95241_data *data = lm95241_update_device(dev);
struct i2c_client *client = data->client;
unsigned long val;
int shift;
u8 mask = to_sensor_dev_attr(attr)->index;
if (kstrtoul(buf, 10, &val) < 0)
return -EINVAL;
if (val != 1 && val != 2)
return -EINVAL;
shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT;
mutex_lock(&data->update_lock);
data->trutherm &= ~(TT_MASK << shift); switch (attr) {
if (val == 1) { case hwmon_temp_input:
data->model |= mask; if (!channel || (data->config & BIT(channel - 1)))
data->trutherm |= (TT_ON << shift); *val = temp_from_reg_signed(data->temp[channel * 2],
} else { data->temp[channel * 2 + 1]);
data->model &= ~mask; else
data->trutherm |= (TT_OFF << shift); *val = temp_from_reg_unsigned(data->temp[channel * 2],
data->temp[channel * 2 + 1]);
return 0;
case hwmon_temp_min:
if (channel == 1)
*val = (data->config & R1DF_MASK) ? -128000 : 0;
else
*val = (data->config & R2DF_MASK) ? -128000 : 0;
return 0;
case hwmon_temp_max:
if (channel == 1)
*val = (data->config & R1DF_MASK) ? 127875 : 255875;
else
*val = (data->config & R2DF_MASK) ? 127875 : 255875;
return 0;
case hwmon_temp_type:
if (channel == 1)
*val = (data->model & R1MS_MASK) ? 1 : 2;
else
*val = (data->model & R2MS_MASK) ? 1 : 2;
return 0;
case hwmon_temp_fault:
if (channel == 1)
*val = !!(data->status & R1DM);
else
*val = !!(data->status & R2DM);
return 0;
default:
return -EOPNOTSUPP;
} }
data->valid = 0;
i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
data->model);
i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
data->trutherm);
mutex_unlock(&data->update_lock);
return count;
} }
static ssize_t show_min(struct device *dev, struct device_attribute *attr, static int lm95241_read(struct device *dev, enum hwmon_sensor_types type,
char *buf) u32 attr, int channel, long *val)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); switch (type) {
case hwmon_chip:
return snprintf(buf, PAGE_SIZE - 1, return lm95241_read_chip(dev, attr, channel, val);
data->config & to_sensor_dev_attr(attr)->index ? case hwmon_temp:
"-127000\n" : "0\n"); return lm95241_read_temp(dev, attr, channel, val);
default:
return -EOPNOTSUPP;
}
} }
static ssize_t set_min(struct device *dev, struct device_attribute *attr, static int lm95241_write_chip(struct device *dev, u32 attr, int channel,
const char *buf, size_t count) long val)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); struct lm95241_data *data = dev_get_drvdata(dev);
long val; int convrate;
u8 config;
if (kstrtol(buf, 10, &val) < 0) int ret;
return -EINVAL;
if (val < -128000)
return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (val < 0) switch (attr) {
data->config |= to_sensor_dev_attr(attr)->index; case hwmon_chip_update_interval:
else config = data->config & ~CFG_CRMASK;
data->config &= ~to_sensor_dev_attr(attr)->index; if (val < 130) {
data->valid = 0; convrate = 76;
config |= CFG_CR0076;
i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG, } else if (val < 590) {
data->config); convrate = 182;
config |= CFG_CR0182;
} else if (val < 1850) {
convrate = 1000;
config |= CFG_CR1000;
} else {
convrate = 2700;
config |= CFG_CR2700;
}
data->interval = convrate;
data->config = config;
ret = i2c_smbus_write_byte_data(data->client,
LM95241_REG_RW_CONFIG, config);
break;
default:
ret = -EOPNOTSUPP;
break;
}
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return ret;
return count;
} }
static ssize_t show_max(struct device *dev, struct device_attribute *attr, static int lm95241_write_temp(struct device *dev, u32 attr, int channel,
char *buf) long val)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); struct lm95241_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
return snprintf(buf, PAGE_SIZE - 1, int ret;
data->config & to_sensor_dev_attr(attr)->index ?
"127000\n" : "255000\n");
}
static ssize_t set_max(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct lm95241_data *data = dev_get_drvdata(dev);
long val;
if (kstrtol(buf, 10, &val) < 0)
return -EINVAL;
if (val >= 256000)
return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (val <= 127000) switch (attr) {
data->config |= to_sensor_dev_attr(attr)->index; case hwmon_temp_min:
else if (channel == 1) {
data->config &= ~to_sensor_dev_attr(attr)->index; if (val < 0)
data->valid = 0; data->config |= R1DF_MASK;
else
i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG, data->config &= ~R1DF_MASK;
data->config); } else {
if (val < 0)
data->config |= R2DF_MASK;
else
data->config &= ~R2DF_MASK;
}
data->valid = 0;
ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
data->config);
break;
case hwmon_temp_max:
if (channel == 1) {
if (val <= 127875)
data->config |= R1DF_MASK;
else
data->config &= ~R1DF_MASK;
} else {
if (val <= 127875)
data->config |= R2DF_MASK;
else
data->config &= ~R2DF_MASK;
}
data->valid = 0;
ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
data->config);
break;
case hwmon_temp_type:
if (val != 1 && val != 2) {
ret = -EINVAL;
break;
}
if (channel == 1) {
data->trutherm &= ~(TT_MASK << TT1_SHIFT);
if (val == 1) {
data->model |= R1MS_MASK;
data->trutherm |= (TT_ON << TT1_SHIFT);
} else {
data->model &= ~R1MS_MASK;
data->trutherm |= (TT_OFF << TT1_SHIFT);
}
} else {
data->trutherm &= ~(TT_MASK << TT2_SHIFT);
if (val == 1) {
data->model |= R2MS_MASK;
data->trutherm |= (TT_ON << TT2_SHIFT);
} else {
data->model &= ~R2MS_MASK;
data->trutherm |= (TT_OFF << TT2_SHIFT);
}
}
ret = i2c_smbus_write_byte_data(client,
LM95241_REG_RW_REMOTE_MODEL,
data->model);
if (ret < 0)
break;
ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
data->trutherm);
break;
default:
ret = -EOPNOTSUPP;
break;
}
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return ret;
} }
static ssize_t show_interval(struct device *dev, struct device_attribute *attr, static int lm95241_write(struct device *dev, enum hwmon_sensor_types type,
char *buf) u32 attr, int channel, long val)
{ {
struct lm95241_data *data = lm95241_update_device(dev); switch (type) {
case hwmon_chip:
return snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->interval return lm95241_write_chip(dev, attr, channel, val);
/ HZ); case hwmon_temp:
return lm95241_write_temp(dev, attr, channel, val);
default:
return -EOPNOTSUPP;
}
} }
static ssize_t set_interval(struct device *dev, struct device_attribute *attr, static umode_t lm95241_is_visible(const void *data,
const char *buf, size_t count) enum hwmon_sensor_types type,
u32 attr, int channel)
{ {
struct lm95241_data *data = dev_get_drvdata(dev); switch (type) {
unsigned long val; case hwmon_chip:
switch (attr) {
if (kstrtoul(buf, 10, &val) < 0) case hwmon_chip_update_interval:
return -EINVAL; return S_IRUGO | S_IWUSR;
}
data->interval = val * HZ / 1000; break;
case hwmon_temp:
return count; switch (attr) {
case hwmon_temp_input:
return S_IRUGO;
case hwmon_temp_fault:
return S_IRUGO;
case hwmon_temp_min:
case hwmon_temp_max:
case hwmon_temp_type:
return S_IRUGO | S_IWUSR;
}
break;
default:
break;
}
return 0;
} }
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type,
R1MS_MASK);
static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type,
R2MS_MASK);
static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min,
R1DF_MASK);
static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min,
R2DF_MASK);
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max,
R1DF_MASK);
static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max,
R2DF_MASK);
static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
set_interval);
static struct attribute *lm95241_attrs[] = {
&sensor_dev_attr_temp1_input.dev_attr.attr,
&sensor_dev_attr_temp2_input.dev_attr.attr,
&sensor_dev_attr_temp3_input.dev_attr.attr,
&sensor_dev_attr_temp2_type.dev_attr.attr,
&sensor_dev_attr_temp3_type.dev_attr.attr,
&sensor_dev_attr_temp2_min.dev_attr.attr,
&sensor_dev_attr_temp3_min.dev_attr.attr,
&sensor_dev_attr_temp2_max.dev_attr.attr,
&sensor_dev_attr_temp3_max.dev_attr.attr,
&dev_attr_update_interval.attr,
NULL
};
ATTRIBUTE_GROUPS(lm95241);
/* Return 0 if detection is successful, -ENODEV otherwise */ /* Return 0 if detection is successful, -ENODEV otherwise */
static int lm95241_detect(struct i2c_client *new_client, static int lm95241_detect(struct i2c_client *new_client,
struct i2c_board_info *info) struct i2c_board_info *info)
...@@ -362,8 +405,8 @@ static int lm95241_detect(struct i2c_client *new_client, ...@@ -362,8 +405,8 @@ static int lm95241_detect(struct i2c_client *new_client,
static void lm95241_init_client(struct i2c_client *client, static void lm95241_init_client(struct i2c_client *client,
struct lm95241_data *data) struct lm95241_data *data)
{ {
data->interval = HZ; /* 1 sec default */ data->interval = 1000;
data->config = CFG_CR0076; data->config = CFG_CR1000;
data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT); data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
...@@ -375,6 +418,47 @@ static void lm95241_init_client(struct i2c_client *client, ...@@ -375,6 +418,47 @@ static void lm95241_init_client(struct i2c_client *client,
data->model); data->model);
} }
static const u32 lm95241_chip_config[] = {
HWMON_C_UPDATE_INTERVAL,
0
};
static const struct hwmon_channel_info lm95241_chip = {
.type = hwmon_chip,
.config = lm95241_chip_config,
};
static const u32 lm95241_temp_config[] = {
HWMON_T_INPUT,
HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | HWMON_T_TYPE |
HWMON_T_FAULT,
HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | HWMON_T_TYPE |
HWMON_T_FAULT,
0
};
static const struct hwmon_channel_info lm95241_temp = {
.type = hwmon_temp,
.config = lm95241_temp_config,
};
static const struct hwmon_channel_info *lm95241_info[] = {
&lm95241_chip,
&lm95241_temp,
NULL
};
static const struct hwmon_ops lm95241_hwmon_ops = {
.is_visible = lm95241_is_visible,
.read = lm95241_read,
.write = lm95241_write,
};
static const struct hwmon_chip_info lm95241_chip_info = {
.ops = &lm95241_hwmon_ops,
.info = lm95241_info,
};
static int lm95241_probe(struct i2c_client *client, static int lm95241_probe(struct i2c_client *client,
const struct i2c_device_id *id) const struct i2c_device_id *id)
{ {
...@@ -392,9 +476,10 @@ static int lm95241_probe(struct i2c_client *client, ...@@ -392,9 +476,10 @@ static int lm95241_probe(struct i2c_client *client,
/* Initialize the LM95241 chip */ /* Initialize the LM95241 chip */
lm95241_init_client(client, data); lm95241_init_client(client, data);
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
data, data,
lm95241_groups); &lm95241_chip_info,
NULL);
return PTR_ERR_OR_ZERO(hwmon_dev); return PTR_ERR_OR_ZERO(hwmon_dev);
} }
...@@ -420,5 +505,5 @@ static struct i2c_driver lm95241_driver = { ...@@ -420,5 +505,5 @@ static struct i2c_driver lm95241_driver = {
module_i2c_driver(lm95241_driver); module_i2c_driver(lm95241_driver);
MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>"); MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>");
MODULE_DESCRIPTION("LM95241 sensor driver"); MODULE_DESCRIPTION("LM95231/LM95241 sensor driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
此差异已折叠。
...@@ -30,6 +30,7 @@ ...@@ -30,6 +30,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/of.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/slab.h> #include <linux/slab.h>
...@@ -52,6 +53,7 @@ struct ltc4151_data { ...@@ -52,6 +53,7 @@ struct ltc4151_data {
struct mutex update_lock; struct mutex update_lock;
bool valid; bool valid;
unsigned long last_updated; /* in jiffies */ unsigned long last_updated; /* in jiffies */
unsigned int shunt; /* in micro ohms */
/* Registers */ /* Registers */
u8 regs[6]; u8 regs[6];
...@@ -111,9 +113,9 @@ static int ltc4151_get_value(struct ltc4151_data *data, u8 reg) ...@@ -111,9 +113,9 @@ static int ltc4151_get_value(struct ltc4151_data *data, u8 reg)
case LTC4151_SENSE_H: case LTC4151_SENSE_H:
/* /*
* 20uV resolution. Convert to current as measured with * 20uV resolution. Convert to current as measured with
* an 1 mOhm sense resistor, in mA. * a given sense resistor, in mA.
*/ */
val = val * 20; val = val * 20 * 1000 / data->shunt;
break; break;
case LTC4151_VIN_H: case LTC4151_VIN_H:
/* 25 mV per increment */ /* 25 mV per increment */
...@@ -176,6 +178,7 @@ static int ltc4151_probe(struct i2c_client *client, ...@@ -176,6 +178,7 @@ static int ltc4151_probe(struct i2c_client *client,
struct device *dev = &client->dev; struct device *dev = &client->dev;
struct ltc4151_data *data; struct ltc4151_data *data;
struct device *hwmon_dev; struct device *hwmon_dev;
u32 shunt;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -ENODEV; return -ENODEV;
...@@ -184,6 +187,15 @@ static int ltc4151_probe(struct i2c_client *client, ...@@ -184,6 +187,15 @@ static int ltc4151_probe(struct i2c_client *client,
if (!data) if (!data)
return -ENOMEM; return -ENOMEM;
if (of_property_read_u32(client->dev.of_node,
"shunt-resistor-micro-ohms", &shunt))
shunt = 1000; /* 1 mOhm if not set via DT */
if (shunt == 0)
return -EINVAL;
data->shunt = shunt;
data->client = client; data->client = client;
mutex_init(&data->update_lock); mutex_init(&data->update_lock);
...@@ -199,10 +211,16 @@ static const struct i2c_device_id ltc4151_id[] = { ...@@ -199,10 +211,16 @@ static const struct i2c_device_id ltc4151_id[] = {
}; };
MODULE_DEVICE_TABLE(i2c, ltc4151_id); MODULE_DEVICE_TABLE(i2c, ltc4151_id);
static const struct of_device_id ltc4151_match[] = {
{ .compatible = "lltc,ltc4151" },
{},
};
/* This is the driver that will be inserted */ /* This is the driver that will be inserted */
static struct i2c_driver ltc4151_driver = { static struct i2c_driver ltc4151_driver = {
.driver = { .driver = {
.name = "ltc4151", .name = "ltc4151",
.of_match_table = of_match_ptr(ltc4151_match),
}, },
.probe = ltc4151_probe, .probe = ltc4151_probe,
.id_table = ltc4151_id, .id_table = ltc4151_id,
......
...@@ -16,6 +16,7 @@ ...@@ -16,6 +16,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/bitops.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/i2c.h> #include <linux/i2c.h>
...@@ -53,8 +54,6 @@ enum ltc4245_cmd { ...@@ -53,8 +54,6 @@ enum ltc4245_cmd {
struct ltc4245_data { struct ltc4245_data {
struct i2c_client *client; struct i2c_client *client;
const struct attribute_group *groups[3];
struct mutex update_lock; struct mutex update_lock;
bool valid; bool valid;
unsigned long last_updated; /* in jiffies */ unsigned long last_updated; /* in jiffies */
...@@ -162,7 +161,7 @@ static struct ltc4245_data *ltc4245_update_device(struct device *dev) ...@@ -162,7 +161,7 @@ static struct ltc4245_data *ltc4245_update_device(struct device *dev)
ltc4245_update_gpios(dev); ltc4245_update_gpios(dev);
data->last_updated = jiffies; data->last_updated = jiffies;
data->valid = 1; data->valid = true;
} }
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
...@@ -256,213 +255,204 @@ static unsigned int ltc4245_get_current(struct device *dev, u8 reg) ...@@ -256,213 +255,204 @@ static unsigned int ltc4245_get_current(struct device *dev, u8 reg)
return curr; return curr;
} }
static ssize_t ltc4245_show_voltage(struct device *dev, /* Map from voltage channel index to voltage register */
struct device_attribute *da,
char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
const int voltage = ltc4245_get_voltage(dev, attr->index);
return snprintf(buf, PAGE_SIZE, "%d\n", voltage); static const s8 ltc4245_in_regs[] = {
} LTC4245_12VIN, LTC4245_5VIN, LTC4245_3VIN, LTC4245_VEEIN,
LTC4245_12VOUT, LTC4245_5VOUT, LTC4245_3VOUT, LTC4245_VEEOUT,
};
/* Map from current channel index to current register */
static ssize_t ltc4245_show_current(struct device *dev, static const s8 ltc4245_curr_regs[] = {
struct device_attribute *da, LTC4245_12VSENSE, LTC4245_5VSENSE, LTC4245_3VSENSE, LTC4245_VEESENSE,
char *buf) };
static int ltc4245_read_curr(struct device *dev, u32 attr, int channel,
long *val)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct ltc4245_data *data = ltc4245_update_device(dev);
const unsigned int curr = ltc4245_get_current(dev, attr->index);
return snprintf(buf, PAGE_SIZE, "%u\n", curr); switch (attr) {
case hwmon_curr_input:
*val = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
return 0;
case hwmon_curr_max_alarm:
*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel + 4));
return 0;
default:
return -EOPNOTSUPP;
}
} }
static ssize_t ltc4245_show_power(struct device *dev, static int ltc4245_read_in(struct device *dev, u32 attr, int channel, long *val)
struct device_attribute *da,
char *buf)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct ltc4245_data *data = ltc4245_update_device(dev);
const unsigned int curr = ltc4245_get_current(dev, attr->index);
const int output_voltage = ltc4245_get_voltage(dev, attr->index+1);
/* current in mA * voltage in mV == power in uW */ switch (attr) {
const unsigned int power = abs(output_voltage * curr); case hwmon_in_input:
if (channel < 8) {
*val = ltc4245_get_voltage(dev,
ltc4245_in_regs[channel]);
} else {
int regval = data->gpios[channel - 8];
if (regval < 0)
return regval;
*val = regval * 10;
}
return 0;
case hwmon_in_min_alarm:
if (channel < 4)
*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel));
else
*val = !!(data->cregs[LTC4245_FAULT2] &
BIT(channel - 4));
return 0;
default:
return -EOPNOTSUPP;
}
}
return snprintf(buf, PAGE_SIZE, "%u\n", power); static int ltc4245_read_power(struct device *dev, u32 attr, int channel,
long *val)
{
unsigned long curr;
long voltage;
switch (attr) {
case hwmon_power_input:
(void)ltc4245_update_device(dev);
curr = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
voltage = ltc4245_get_voltage(dev, ltc4245_in_regs[channel]);
*val = abs(curr * voltage);
return 0;
default:
return -EOPNOTSUPP;
}
} }
static ssize_t ltc4245_show_alarm(struct device *dev, static int ltc4245_read(struct device *dev, enum hwmon_sensor_types type,
struct device_attribute *da, u32 attr, int channel, long *val)
char *buf)
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);
struct ltc4245_data *data = ltc4245_update_device(dev);
const u8 reg = data->cregs[attr->index];
const u32 mask = attr->nr;
return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0); switch (type) {
case hwmon_curr:
return ltc4245_read_curr(dev, attr, channel, val);
case hwmon_power:
return ltc4245_read_power(dev, attr, channel, val);
case hwmon_in:
return ltc4245_read_in(dev, attr, channel - 1, val);
default:
return -EOPNOTSUPP;
}
} }
static ssize_t ltc4245_show_gpio(struct device *dev, static umode_t ltc4245_is_visible(const void *_data,
struct device_attribute *da, enum hwmon_sensor_types type,
char *buf) u32 attr, int channel)
{ {
struct sensor_device_attribute *attr = to_sensor_dev_attr(da); const struct ltc4245_data *data = _data;
struct ltc4245_data *data = ltc4245_update_device(dev);
int val = data->gpios[attr->index]; switch (type) {
case hwmon_in:
if (channel == 0)
return 0;
switch (attr) {
case hwmon_in_input:
if (channel > 9 && !data->use_extra_gpios)
return 0;
return S_IRUGO;
case hwmon_in_min_alarm:
if (channel > 8)
return 0;
return S_IRUGO;
default:
return 0;
}
case hwmon_curr:
switch (attr) {
case hwmon_curr_input:
case hwmon_curr_max_alarm:
return S_IRUGO;
default:
return 0;
}
case hwmon_power:
switch (attr) {
case hwmon_power_input:
return S_IRUGO;
default:
return 0;
}
default:
return 0;
}
}
/* handle stale GPIO's */ static const u32 ltc4245_in_config[] = {
if (val < 0) HWMON_I_INPUT, /* dummy, skipped in is_visible */
return val; HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT | HWMON_I_MIN_ALARM,
HWMON_I_INPUT,
HWMON_I_INPUT,
HWMON_I_INPUT,
0
};
/* Convert to millivolts and print */ static const struct hwmon_channel_info ltc4245_in = {
return snprintf(buf, PAGE_SIZE, "%u\n", val * 10); .type = hwmon_in,
} .config = ltc4245_in_config,
};
/* Construct a sensor_device_attribute structure for each register */ static const u32 ltc4245_curr_config[] = {
HWMON_C_INPUT | HWMON_C_MAX_ALARM,
/* Input voltages */ HWMON_C_INPUT | HWMON_C_MAX_ALARM,
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4245_show_voltage, NULL, HWMON_C_INPUT | HWMON_C_MAX_ALARM,
LTC4245_12VIN); HWMON_C_INPUT | HWMON_C_MAX_ALARM,
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4245_show_voltage, NULL, 0
LTC4245_5VIN); };
static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_3VIN);
static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_VEEIN);
/* Input undervoltage alarms */
static SENSOR_DEVICE_ATTR_2(in1_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 0, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in2_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 1, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in3_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 2, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in4_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 3, LTC4245_FAULT1);
/* Currents (via sense resistor) */
static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4245_show_current, NULL,
LTC4245_12VSENSE);
static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc4245_show_current, NULL,
LTC4245_5VSENSE);
static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, ltc4245_show_current, NULL,
LTC4245_3VSENSE);
static SENSOR_DEVICE_ATTR(curr4_input, S_IRUGO, ltc4245_show_current, NULL,
LTC4245_VEESENSE);
/* Overcurrent alarms */
static SENSOR_DEVICE_ATTR_2(curr1_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 4, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr2_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 5, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr3_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 6, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr4_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 7, LTC4245_FAULT1);
/* Output voltages */
static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_12VOUT);
static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_5VOUT);
static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_3VOUT);
static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, ltc4245_show_voltage, NULL,
LTC4245_VEEOUT);
/* Power Bad alarms */
static SENSOR_DEVICE_ATTR_2(in5_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 0, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in6_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 1, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in7_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 2, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in8_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
1 << 3, LTC4245_FAULT2);
/* GPIO voltages */
static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, ltc4245_show_gpio, NULL, 0);
static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, ltc4245_show_gpio, NULL, 1);
static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, ltc4245_show_gpio, NULL, 2);
/* Power Consumption (virtual) */
static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ltc4245_show_power, NULL,
LTC4245_12VSENSE);
static SENSOR_DEVICE_ATTR(power2_input, S_IRUGO, ltc4245_show_power, NULL,
LTC4245_5VSENSE);
static SENSOR_DEVICE_ATTR(power3_input, S_IRUGO, ltc4245_show_power, NULL,
LTC4245_3VSENSE);
static SENSOR_DEVICE_ATTR(power4_input, S_IRUGO, ltc4245_show_power, NULL,
LTC4245_VEESENSE);
/* static const struct hwmon_channel_info ltc4245_curr = {
* Finally, construct an array of pointers to members of the above objects, .type = hwmon_curr,
* as required for sysfs_create_group() .config = ltc4245_curr_config,
*/
static struct attribute *ltc4245_std_attributes[] = {
&sensor_dev_attr_in1_input.dev_attr.attr,
&sensor_dev_attr_in2_input.dev_attr.attr,
&sensor_dev_attr_in3_input.dev_attr.attr,
&sensor_dev_attr_in4_input.dev_attr.attr,
&sensor_dev_attr_in1_min_alarm.dev_attr.attr,
&sensor_dev_attr_in2_min_alarm.dev_attr.attr,
&sensor_dev_attr_in3_min_alarm.dev_attr.attr,
&sensor_dev_attr_in4_min_alarm.dev_attr.attr,
&sensor_dev_attr_curr1_input.dev_attr.attr,
&sensor_dev_attr_curr2_input.dev_attr.attr,
&sensor_dev_attr_curr3_input.dev_attr.attr,
&sensor_dev_attr_curr4_input.dev_attr.attr,
&sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
&sensor_dev_attr_curr2_max_alarm.dev_attr.attr,
&sensor_dev_attr_curr3_max_alarm.dev_attr.attr,
&sensor_dev_attr_curr4_max_alarm.dev_attr.attr,
&sensor_dev_attr_in5_input.dev_attr.attr,
&sensor_dev_attr_in6_input.dev_attr.attr,
&sensor_dev_attr_in7_input.dev_attr.attr,
&sensor_dev_attr_in8_input.dev_attr.attr,
&sensor_dev_attr_in5_min_alarm.dev_attr.attr,
&sensor_dev_attr_in6_min_alarm.dev_attr.attr,
&sensor_dev_attr_in7_min_alarm.dev_attr.attr,
&sensor_dev_attr_in8_min_alarm.dev_attr.attr,
&sensor_dev_attr_in9_input.dev_attr.attr,
&sensor_dev_attr_power1_input.dev_attr.attr,
&sensor_dev_attr_power2_input.dev_attr.attr,
&sensor_dev_attr_power3_input.dev_attr.attr,
&sensor_dev_attr_power4_input.dev_attr.attr,
NULL,
}; };
static struct attribute *ltc4245_gpio_attributes[] = { static const u32 ltc4245_power_config[] = {
&sensor_dev_attr_in10_input.dev_attr.attr, HWMON_P_INPUT,
&sensor_dev_attr_in11_input.dev_attr.attr, HWMON_P_INPUT,
NULL, HWMON_P_INPUT,
HWMON_P_INPUT,
0
}; };
static const struct attribute_group ltc4245_std_group = { static const struct hwmon_channel_info ltc4245_power = {
.attrs = ltc4245_std_attributes, .type = hwmon_power,
.config = ltc4245_power_config,
}; };
static const struct attribute_group ltc4245_gpio_group = { static const struct hwmon_channel_info *ltc4245_info[] = {
.attrs = ltc4245_gpio_attributes, &ltc4245_in,
&ltc4245_curr,
&ltc4245_power,
NULL
}; };
static void ltc4245_sysfs_add_groups(struct ltc4245_data *data) static const struct hwmon_ops ltc4245_hwmon_ops = {
{ .is_visible = ltc4245_is_visible,
/* standard sysfs attributes */ .read = ltc4245_read,
data->groups[0] = &ltc4245_std_group; };
/* if we're using the extra gpio support, register it's attributes */ static const struct hwmon_chip_info ltc4245_chip_info = {
if (data->use_extra_gpios) .ops = &ltc4245_hwmon_ops,
data->groups[1] = &ltc4245_gpio_group; .info = ltc4245_info,
} };
static bool ltc4245_use_extra_gpios(struct i2c_client *client) static bool ltc4245_use_extra_gpios(struct i2c_client *client)
{ {
...@@ -502,12 +492,10 @@ static int ltc4245_probe(struct i2c_client *client, ...@@ -502,12 +492,10 @@ static int ltc4245_probe(struct i2c_client *client,
i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00); i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00); i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);
/* Add sysfs hooks */ hwmon_dev = devm_hwmon_device_register_with_info(&client->dev,
ltc4245_sysfs_add_groups(data); client->name, data,
&ltc4245_chip_info,
hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev, NULL);
client->name, data,
data->groups);
return PTR_ERR_OR_ZERO(hwmon_dev); return PTR_ERR_OR_ZERO(hwmon_dev);
} }
......
此差异已折叠。
此差异已折叠。
...@@ -195,6 +195,8 @@ superio_exit(int ioreg) ...@@ -195,6 +195,8 @@ superio_exit(int ioreg)
#define NUM_FAN 6 #define NUM_FAN 6
#define TEMP_SOURCE_VIRTUAL 0x1f
/* Common and NCT6775 specific data */ /* Common and NCT6775 specific data */
/* Voltage min/max registers for nr=7..14 are in bank 5 */ /* Voltage min/max registers for nr=7..14 are in bank 5 */
...@@ -3940,7 +3942,7 @@ static int nct6775_probe(struct platform_device *pdev) ...@@ -3940,7 +3942,7 @@ static int nct6775_probe(struct platform_device *pdev)
continue; continue;
src = nct6775_read_value(data, data->REG_TEMP_SEL[i]) & 0x1f; src = nct6775_read_value(data, data->REG_TEMP_SEL[i]) & 0x1f;
if (!src || (mask & (1 << src))) if (!src)
continue; continue;
if (src >= data->temp_label_num || if (src >= data->temp_label_num ||
...@@ -3952,7 +3954,16 @@ static int nct6775_probe(struct platform_device *pdev) ...@@ -3952,7 +3954,16 @@ static int nct6775_probe(struct platform_device *pdev)
continue; continue;
} }
mask |= 1 << src; /*
* For virtual temperature sources, the 'virtual' temperature
* for each fan reflects a different temperature, and there
* are no duplicates.
*/
if (src != TEMP_SOURCE_VIRTUAL) {
if (mask & (1 << src))
continue;
mask |= 1 << src;
}
/* Use fixed index for SYSTIN(1), CPUTIN(2), AUXTIN(3) */ /* Use fixed index for SYSTIN(1), CPUTIN(2), AUXTIN(3) */
if (src <= data->temp_fixed_num) { if (src <= data->temp_fixed_num) {
...@@ -4232,11 +4243,11 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data) ...@@ -4232,11 +4243,11 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
if (err) if (err)
return err; return err;
if (force_id) val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) |
superio_inb(sioaddr, SIO_REG_DEVID + 1);
if (force_id && val != 0xffff)
val = force_id; val = force_id;
else
val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
| superio_inb(sioaddr, SIO_REG_DEVID + 1);
switch (val & SIO_ID_MASK) { switch (val & SIO_ID_MASK) {
case SIO_NCT6106_ID: case SIO_NCT6106_ID:
sio_data->kind = nct6106; sio_data->kind = nct6106;
......
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
此差异已折叠。
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册