1 The Linux Hardware Monitoring kernel API.
2 =========================================
9 This document describes the API that can be used by hardware monitoring
10 drivers that want to use the hardware monitoring framework.
12 This document does not describe what a hardware monitoring (hwmon) Driver or
13 Device is. It also does not describe the API which can be used by user space
14 to communicate with a hardware monitoring device. If you want to know this
15 then please read the following file: Documentation/hwmon/sysfs-interface.
17 For additional guidelines on how to write and improve hwmon drivers, please
18 also read Documentation/hwmon/submitting-patches.
22 Each hardware monitoring driver must #include <linux/hwmon.h> and, in most
23 cases, <linux/hwmon-sysfs.h>. linux/hwmon.h declares the following
24 register/unregister functions:
26 struct device *hwmon_device_register(struct device *dev);
28 hwmon_device_register_with_groups(struct device *dev, const char *name,
30 const struct attribute_group **groups);
33 devm_hwmon_device_register_with_groups(struct device *dev,
34 const char *name, void *drvdata,
35 const struct attribute_group **groups);
38 hwmon_device_register_with_info(struct device *dev,
39 const char *name, void *drvdata,
40 const struct hwmon_chip_info *info,
41 const struct attribute_group **groups);
44 devm_hwmon_device_register_with_info(struct device *dev,
47 const struct hwmon_chip_info *info,
48 const struct attribute_group **groups);
50 void hwmon_device_unregister(struct device *dev);
51 void devm_hwmon_device_unregister(struct device *dev);
53 hwmon_device_register registers a hardware monitoring device. The parameter
54 of this function is a pointer to the parent device.
55 This function returns a pointer to the newly created hardware monitoring device
56 or PTR_ERR for failure. If this registration function is used, hardware
57 monitoring sysfs attributes are expected to have been created and attached to
58 the parent device prior to calling hwmon_device_register. A name attribute must
59 have been created by the caller.
61 hwmon_device_register_with_groups is similar to hwmon_device_register. However,
62 it has additional parameters. The name parameter is a pointer to the hwmon
63 device name. The registration function wil create a name sysfs attribute
64 pointing to this name. The drvdata parameter is the pointer to the local
65 driver data. hwmon_device_register_with_groups will attach this pointer
66 to the newly allocated hwmon device. The pointer can be retrieved by the driver
67 using dev_get_drvdata() on the hwmon device pointer. The groups parameter is
68 a pointer to a list of sysfs attribute groups. The list must be NULL terminated.
69 hwmon_device_register_with_groups creates the hwmon device with name attribute
70 as well as all sysfs attributes attached to the hwmon device.
72 devm_hwmon_device_register_with_groups is similar to
73 hwmon_device_register_with_groups. However, it is device managed, meaning the
74 hwmon device does not have to be removed explicitly by the removal function.
76 hwmon_device_register_with_info is the most comprehensive and preferred means
77 to register a hardware monitoring device. It creates the standard sysfs
78 attributes in the hardware monitoring core, letting the driver focus on reading
79 from and writing to the chip instead of having to bother with sysfs attributes.
80 Its parameters are described in more detail below.
82 devm_hwmon_device_register_with_info is similar to
83 hwmon_device_register_with_info. However, it is device managed, meaning the
84 hwmon device does not have to be removed explicitly by the removal function.
86 hwmon_device_unregister deregisters a registered hardware monitoring device.
87 The parameter of this function is the pointer to the registered hardware
88 monitoring device structure. This function must be called from the driver
89 remove function if the hardware monitoring device was registered with
90 hwmon_device_register, hwmon_device_register_with_groups, or
91 hwmon_device_register_with_info.
93 devm_hwmon_device_unregister does not normally have to be called. It is only
94 needed for error handling, and only needed if the driver probe fails after
95 the call to devm_hwmon_device_register_with_groups and if the automatic
96 (device managed) removal would be too late.
98 Using devm_hwmon_device_register_with_info()
99 --------------------------------------------
101 hwmon_device_register_with_info() registers a hardware monitoring device.
102 The parameters to this function are
104 struct device *dev Pointer to parent device
105 const char *name Device name
106 void *drvdata Driver private data
107 const struct hwmon_chip_info *info
108 Pointer to chip description.
109 const struct attribute_group **groups
110 Null-terminated list of additional sysfs attribute
113 This function returns a pointer to the created hardware monitoring device
114 on success and a negative error code for failure.
116 The hwmon_chip_info structure looks as follows.
118 struct hwmon_chip_info {
119 const struct hwmon_ops *ops;
120 const struct hwmon_channel_info **info;
123 It contains the following fields:
125 * ops: Pointer to device operations.
126 * info: NULL-terminated list of device channel descriptors.
128 The list of hwmon operations is defined as:
131 umode_t (*is_visible)(const void *, enum hwmon_sensor_types type,
133 int (*read)(struct device *, enum hwmon_sensor_types type,
134 u32 attr, int, long *);
135 int (*write)(struct device *, enum hwmon_sensor_types type,
136 u32 attr, int, long);
139 It defines the following operations.
141 * is_visible: Pointer to a function to return the file mode for each supported
142 attribute. This function is mandatory.
144 * read: Pointer to a function for reading a value from the chip. This function
145 is optional, but must be provided if any readable attributes exist.
147 * write: Pointer to a function for writing a value to the chip. This function is
148 optional, but must be provided if any writeable attributes exist.
150 Each sensor channel is described with struct hwmon_channel_info, which is
153 struct hwmon_channel_info {
154 enum hwmon_sensor_types type;
158 It contains following fields:
160 * type: The hardware monitoring sensor type.
161 Supported sensor types are
162 * hwmon_chip A virtual sensor type, used to describe attributes
163 which apply to the entire chip.
164 * hwmon_temp Temperature sensor
165 * hwmon_in Voltage sensor
166 * hwmon_curr Current sensor
167 * hwmon_power Power sensor
168 * hwmon_energy Energy sensor
169 * hwmon_humidity Humidity sensor
170 * hwmon_fan Fan speed sensor
172 * config: Pointer to a 0-terminated list of configuration values for each
173 sensor of the given type. Each value is a combination of bit values
174 describing the attributes supposed by a single sensor.
176 As an example, here is the complete description file for a LM75 compatible
177 sensor chip. The chip has a single temperature sensor. The driver wants to
178 register with the thermal subsystem (HWMON_C_REGISTER_TZ), and it supports
179 the update_interval attribute (HWMON_C_UPDATE_INTERVAL). The chip supports
180 reading the temperature (HWMON_T_INPUT), it has a maximum temperature
181 register (HWMON_T_MAX) as well as a maximum temperature hysteresis register
184 static const u32 lm75_chip_config[] = {
185 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
189 static const struct hwmon_channel_info lm75_chip = {
191 .config = lm75_chip_config,
194 static const u32 lm75_temp_config[] = {
195 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
199 static const struct hwmon_channel_info lm75_temp = {
201 .config = lm75_temp_config,
204 static const struct hwmon_channel_info *lm75_info[] = {
210 static const struct hwmon_ops lm75_hwmon_ops = {
211 .is_visible = lm75_is_visible,
216 static const struct hwmon_chip_info lm75_chip_info = {
217 .ops = &lm75_hwmon_ops,
221 A complete list of bit values indicating individual attribute support
222 is defined in include/linux/hwmon.h. Definition prefixes are as follows.
224 HWMON_C_xxxx Chip attributes, for use with hwmon_chip.
225 HWMON_T_xxxx Temperature attributes, for use with hwmon_temp.
226 HWMON_I_xxxx Voltage attributes, for use with hwmon_in.
227 HWMON_C_xxxx Current attributes, for use with hwmon_curr.
228 Notice the prefix overlap with chip attributes.
229 HWMON_P_xxxx Power attributes, for use with hwmon_power.
230 HWMON_E_xxxx Energy attributes, for use with hwmon_energy.
231 HWMON_H_xxxx Humidity attributes, for use with hwmon_humidity.
232 HWMON_F_xxxx Fan speed attributes, for use with hwmon_fan.
234 Driver callback functions
235 -------------------------
237 Each driver provides is_visible, read, and write functions. Parameters
238 and return values for those functions are as follows.
240 umode_t is_visible_func(const void *data, enum hwmon_sensor_types type,
241 u32 attr, int channel)
244 data: Pointer to device private data structure.
245 type: The sensor type.
246 attr: Attribute identifier associated with a specific attribute.
247 For example, the attribute value for HWMON_T_INPUT would be
248 hwmon_temp_input. For complete mappings of bit fields to
249 attribute values please see include/linux/hwmon.h.
250 channel:The sensor channel number.
253 The file mode for this attribute. Typically, this will be 0 (the
254 attribute will not be created), S_IRUGO, or 'S_IRUGO | S_IWUSR'.
256 int read_func(struct device *dev, enum hwmon_sensor_types type,
257 u32 attr, int channel, long *val)
260 dev: Pointer to the hardware monitoring device.
261 type: The sensor type.
262 attr: Attribute identifier associated with a specific attribute.
263 For example, the attribute value for HWMON_T_INPUT would be
264 hwmon_temp_input. For complete mappings please see
265 include/linux/hwmon.h.
266 channel:The sensor channel number.
267 val: Pointer to attribute value.
270 0 on success, a negative error number otherwise.
272 int write_func(struct device *dev, enum hwmon_sensor_types type,
273 u32 attr, int channel, long val)
276 dev: Pointer to the hardware monitoring device.
277 type: The sensor type.
278 attr: Attribute identifier associated with a specific attribute.
279 For example, the attribute value for HWMON_T_INPUT would be
280 hwmon_temp_input. For complete mappings please see
281 include/linux/hwmon.h.
282 channel:The sensor channel number.
283 val: The value to write to the chip.
286 0 on success, a negative error number otherwise.
289 Driver-provided sysfs attributes
290 --------------------------------
292 If the hardware monitoring device is registered with
293 hwmon_device_register_with_info or devm_hwmon_device_register_with_info,
294 it is most likely not necessary to provide sysfs attributes. Only non-standard
295 sysfs attributes need to be provided when one of those registration functions
298 The header file linux/hwmon-sysfs.h provides a number of useful macros to
299 declare and use hardware monitoring sysfs attributes.
301 In many cases, you can use the exsting define DEVICE_ATTR to declare such
302 attributes. This is feasible if an attribute has no additional context. However,
303 in many cases there will be additional information such as a sensor index which
304 will need to be passed to the sysfs attribute handling function.
306 SENSOR_DEVICE_ATTR and SENSOR_DEVICE_ATTR_2 can be used to define attributes
307 which need such additional context information. SENSOR_DEVICE_ATTR requires
308 one additional argument, SENSOR_DEVICE_ATTR_2 requires two.
310 SENSOR_DEVICE_ATTR defines a struct sensor_device_attribute variable.
311 This structure has the following fields.
313 struct sensor_device_attribute {
314 struct device_attribute dev_attr;
318 You can use to_sensor_dev_attr to get the pointer to this structure from the
319 attribute read or write function. Its parameter is the device to which the
320 attribute is attached.
322 SENSOR_DEVICE_ATTR_2 defines a struct sensor_device_attribute_2 variable,
323 which is defined as follows.
325 struct sensor_device_attribute_2 {
326 struct device_attribute dev_attr;
331 Use to_sensor_dev_attr_2 to get the pointer to this structure. Its parameter
332 is the device to which the attribute is attached.