Documentation/hwmon/hwmon-kernel-api.rst

   1 The Linux Hardware Monitoring kernel API
   2 ========================================
   3
   4 Guenter Roeck
   5
   6 Introduction
   7 ------------
   8
   9 This document describes the API that can be used by hardware monitoring
  10 drivers that want to use the hardware monitoring framework.
  11
  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.rst.
  16
  17 For additional guidelines on how to write and improve hwmon drivers, please
  18 also read Documentation/hwmon/submitting-patches.rst.
  19
  20 The API
  21 -------
  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::
  25
  26   struct device *
  27   hwmon_device_register_with_groups(struct device *dev, const char *name,
  28                                     void *drvdata,
  29                                     const struct attribute_group **groups);
  30
  31   struct device *
  32   devm_hwmon_device_register_with_groups(struct device *dev,
  33                                          const char *name, void *drvdata,
  34                                          const struct attribute_group **groups);
  35
  36   struct device *
  37   hwmon_device_register_with_info(struct device *dev,
  38                                   const char *name, void *drvdata,
  39                                   const struct hwmon_chip_info *info,
  40                                   const struct attribute_group **extra_groups);
  41
  42   struct device *
  43   devm_hwmon_device_register_with_info(struct device *dev,
  44                                        const char *name,
  45                                        void *drvdata,
  46                                        const struct hwmon_chip_info *info,
  47                                        const struct attribute_group **extra_groups);
  48
  49   void hwmon_device_unregister(struct device *dev);
  50
  51   void devm_hwmon_device_unregister(struct device *dev);
  52
  53   char *hwmon_sanitize_name(const char *name);
  54
  55   char *devm_hwmon_sanitize_name(struct device *dev, const char *name);
  56
  57 hwmon_device_register_with_groups registers a hardware monitoring device.
  58 The first parameter of this function is a pointer to the parent device.
  59 The name parameter is a pointer to the hwmon device name. The registration
  60 function wil create a name sysfs attribute pointing to this name.
  61 The drvdata parameter is the pointer to the local driver data.
  62 hwmon_device_register_with_groups will attach this pointer to the newly
  63 allocated hwmon device. The pointer can be retrieved by the driver using
  64 dev_get_drvdata() on the hwmon device pointer. The groups parameter is
  65 a pointer to a list of sysfs attribute groups. The list must be NULL terminated.
  66 hwmon_device_register_with_groups creates the hwmon device with name attribute
  67 as well as all sysfs attributes attached to the hwmon device.
  68 This function returns a pointer to the newly created hardware monitoring device
  69 or PTR_ERR for failure.
  70
  71 devm_hwmon_device_register_with_groups is similar to
  72 hwmon_device_register_with_groups. However, it is device managed, meaning the
  73 hwmon device does not have to be removed explicitly by the removal function.
  74
  75 hwmon_device_register_with_info is the most comprehensive and preferred means
  76 to register a hardware monitoring device. It creates the standard sysfs
  77 attributes in the hardware monitoring core, letting the driver focus on reading
  78 from and writing to the chip instead of having to bother with sysfs attributes.
  79 The parent device parameter as well as the chip parameter must not be NULL. Its
  80 parameters are described in more detail below.
  81
  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.
  85
  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_with_groups or hwmon_device_register_with_info.
  91
  92 devm_hwmon_device_unregister does not normally have to be called. It is only
  93 needed for error handling, and only needed if the driver probe fails after
  94 the call to devm_hwmon_device_register_with_groups or
  95 hwmon_device_register_with_info and if the automatic (device managed)
  96 removal would be too late.
  97
  98 All supported hwmon device registration functions only accept valid device
  99 names. Device names including invalid characters (whitespace, '*', or '-')
 100 will be rejected. The 'name' parameter is mandatory.
 101
 102 If the driver doesn't use a static device name (for example it uses
 103 dev_name()), and therefore cannot make sure the name only contains valid
 104 characters, hwmon_sanitize_name can be used. This convenience function
 105 will duplicate the string and replace any invalid characters with an
 106 underscore. It will allocate memory for the new string and it is the
 107 responsibility of the caller to release the memory when the device is
 108 removed.
 109
 110 devm_hwmon_sanitize_name is the resource managed version of
 111 hwmon_sanitize_name; the memory will be freed automatically on device
 112 removal.
 113
 114 Using devm_hwmon_device_register_with_info()
 115 --------------------------------------------
 116
 117 hwmon_device_register_with_info() registers a hardware monitoring device.
 118 The parameters to this function are
 119
 120 =============================================== ===============================================
 121 `struct device *dev`                            Pointer to parent device
 122 `const char *name`                              Device name
 123 `void *drvdata`                                 Driver private data
 124 `const struct hwmon_chip_info *info`            Pointer to chip description.
 125 `const struct attribute_group **extra_groups`   Null-terminated list of additional non-standard
 126                                                 sysfs attribute groups.
 127 =============================================== ===============================================
 128
 129 This function returns a pointer to the created hardware monitoring device
 130 on success and a negative error code for failure.
 131
 132 The hwmon_chip_info structure looks as follows::
 133
 134         struct hwmon_chip_info {
 135                 const struct hwmon_ops *ops;
 136                 const struct hwmon_channel_info **info;
 137         };
 138
 139 It contains the following fields:
 140
 141 * ops:
 142         Pointer to device operations.
 143 * info:
 144         NULL-terminated list of device channel descriptors.
 145
 146 The list of hwmon operations is defined as::
 147
 148   struct hwmon_ops {
 149         umode_t (*is_visible)(const void *, enum hwmon_sensor_types type,
 150                               u32 attr, int);
 151         int (*read)(struct device *, enum hwmon_sensor_types type,
 152                     u32 attr, int, long *);
 153         int (*write)(struct device *, enum hwmon_sensor_types type,
 154                      u32 attr, int, long);
 155   };
 156
 157 It defines the following operations.
 158
 159 * is_visible:
 160     Pointer to a function to return the file mode for each supported
 161     attribute. This function is mandatory.
 162
 163 * read:
 164     Pointer to a function for reading a value from the chip. This function
 165     is optional, but must be provided if any readable attributes exist.
 166
 167 * write:
 168     Pointer to a function for writing a value to the chip. This function is
 169     optional, but must be provided if any writeable attributes exist.
 170
 171 Each sensor channel is described with struct hwmon_channel_info, which is
 172 defined as follows::
 173
 174         struct hwmon_channel_info {
 175                 enum hwmon_sensor_types type;
 176                 u32 *config;
 177         };
 178
 179 It contains following fields:
 180
 181 * type:
 182     The hardware monitoring sensor type.
 183
 184     Supported sensor types are
 185
 186      ================== ==================================================
 187      hwmon_chip         A virtual sensor type, used to describe attributes
 188                         which are not bound to a specific input or output
 189      hwmon_temp         Temperature sensor
 190      hwmon_in           Voltage sensor
 191      hwmon_curr         Current sensor
 192      hwmon_power                Power sensor
 193      hwmon_energy       Energy sensor
 194      hwmon_humidity     Humidity sensor
 195      hwmon_fan          Fan speed sensor
 196      hwmon_pwm          PWM control
 197      ================== ==================================================
 198
 199 * config:
 200     Pointer to a 0-terminated list of configuration values for each
 201     sensor of the given type. Each value is a combination of bit values
 202     describing the attributes supposed by a single sensor.
 203
 204 As an example, here is the complete description file for a LM75 compatible
 205 sensor chip. The chip has a single temperature sensor. The driver wants to
 206 register with the thermal subsystem (HWMON_C_REGISTER_TZ), and it supports
 207 the update_interval attribute (HWMON_C_UPDATE_INTERVAL). The chip supports
 208 reading the temperature (HWMON_T_INPUT), it has a maximum temperature
 209 register (HWMON_T_MAX) as well as a maximum temperature hysteresis register
 210 (HWMON_T_MAX_HYST)::
 211
 212         static const u32 lm75_chip_config[] = {
 213                 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
 214                 0
 215         };
 216
 217         static const struct hwmon_channel_info lm75_chip = {
 218                 .type = hwmon_chip,
 219                 .config = lm75_chip_config,
 220         };
 221
 222         static const u32 lm75_temp_config[] = {
 223                 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
 224                 0
 225         };
 226
 227         static const struct hwmon_channel_info lm75_temp = {
 228                 .type = hwmon_temp,
 229                 .config = lm75_temp_config,
 230         };
 231
 232         static const struct hwmon_channel_info *lm75_info[] = {
 233                 &lm75_chip,
 234                 &lm75_temp,
 235                 NULL
 236         };
 237
 238         The HWMON_CHANNEL_INFO() macro can and should be used when possible.
 239         With this macro, the above example can be simplified to
 240
 241         static const struct hwmon_channel_info *lm75_info[] = {
 242                 HWMON_CHANNEL_INFO(chip,
 243                                 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
 244                 HWMON_CHANNEL_INFO(temp,
 245                                 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST),
 246                 NULL
 247         };
 248
 249         The remaining declarations are as follows.
 250
 251         static const struct hwmon_ops lm75_hwmon_ops = {
 252                 .is_visible = lm75_is_visible,
 253                 .read = lm75_read,
 254                 .write = lm75_write,
 255         };
 256
 257         static const struct hwmon_chip_info lm75_chip_info = {
 258                 .ops = &lm75_hwmon_ops,
 259                 .info = lm75_info,
 260         };
 261
 262 A complete list of bit values indicating individual attribute support
 263 is defined in include/linux/hwmon.h. Definition prefixes are as follows.
 264
 265 =============== =================================================
 266 HWMON_C_xxxx    Chip attributes, for use with hwmon_chip.
 267 HWMON_T_xxxx    Temperature attributes, for use with hwmon_temp.
 268 HWMON_I_xxxx    Voltage attributes, for use with hwmon_in.
 269 HWMON_C_xxxx    Current attributes, for use with hwmon_curr.
 270                 Notice the prefix overlap with chip attributes.
 271 HWMON_P_xxxx    Power attributes, for use with hwmon_power.
 272 HWMON_E_xxxx    Energy attributes, for use with hwmon_energy.
 273 HWMON_H_xxxx    Humidity attributes, for use with hwmon_humidity.
 274 HWMON_F_xxxx    Fan speed attributes, for use with hwmon_fan.
 275 HWMON_PWM_xxxx  PWM control attributes, for use with hwmon_pwm.
 276 =============== =================================================
 277
 278 Driver callback functions
 279 -------------------------
 280
 281 Each driver provides is_visible, read, and write functions. Parameters
 282 and return values for those functions are as follows::
 283
 284   umode_t is_visible_func(const void *data, enum hwmon_sensor_types type,
 285                           u32 attr, int channel)
 286
 287 Parameters:
 288         data:
 289                 Pointer to device private data structure.
 290         type:
 291                 The sensor type.
 292         attr:
 293                 Attribute identifier associated with a specific attribute.
 294                 For example, the attribute value for HWMON_T_INPUT would be
 295                 hwmon_temp_input. For complete mappings of bit fields to
 296                 attribute values please see include/linux/hwmon.h.
 297         channel:
 298                 The sensor channel number.
 299
 300 Return value:
 301         The file mode for this attribute. Typically, this will be 0 (the
 302         attribute will not be created), S_IRUGO, or 'S_IRUGO | S_IWUSR'.
 303
 304 ::
 305
 306         int read_func(struct device *dev, enum hwmon_sensor_types type,
 307                       u32 attr, int channel, long *val)
 308
 309 Parameters:
 310         dev:
 311                 Pointer to the hardware monitoring device.
 312         type:
 313                 The sensor type.
 314         attr:
 315                 Attribute identifier associated with a specific attribute.
 316                 For example, the attribute value for HWMON_T_INPUT would be
 317                 hwmon_temp_input. For complete mappings please see
 318                 include/linux/hwmon.h.
 319         channel:
 320                 The sensor channel number.
 321         val:
 322                 Pointer to attribute value.
 323
 324 Return value:
 325         0 on success, a negative error number otherwise.
 326
 327 ::
 328
 329         int write_func(struct device *dev, enum hwmon_sensor_types type,
 330                        u32 attr, int channel, long val)
 331
 332 Parameters:
 333         dev:
 334                 Pointer to the hardware monitoring device.
 335         type:
 336                 The sensor type.
 337         attr:
 338                 Attribute identifier associated with a specific attribute.
 339                 For example, the attribute value for HWMON_T_INPUT would be
 340                 hwmon_temp_input. For complete mappings please see
 341                 include/linux/hwmon.h.
 342         channel:
 343                 The sensor channel number.
 344         val:
 345                 The value to write to the chip.
 346
 347 Return value:
 348         0 on success, a negative error number otherwise.
 349
 350
 351 Driver-provided sysfs attributes
 352 --------------------------------
 353
 354 If the hardware monitoring device is registered with
 355 hwmon_device_register_with_info or devm_hwmon_device_register_with_info,
 356 it is most likely not necessary to provide sysfs attributes. Only additional
 357 non-standard sysfs attributes need to be provided when one of those registration
 358 functions is used.
 359
 360 The header file linux/hwmon-sysfs.h provides a number of useful macros to
 361 declare and use hardware monitoring sysfs attributes.
 362
 363 In many cases, you can use the exsting define DEVICE_ATTR or its variants
 364 DEVICE_ATTR_{RW,RO,WO} to declare such attributes. This is feasible if an
 365 attribute has no additional context. However, in many cases there will be
 366 additional information such as a sensor index which will need to be passed
 367 to the sysfs attribute handling function.
 368
 369 SENSOR_DEVICE_ATTR and SENSOR_DEVICE_ATTR_2 can be used to define attributes
 370 which need such additional context information. SENSOR_DEVICE_ATTR requires
 371 one additional argument, SENSOR_DEVICE_ATTR_2 requires two.
 372
 373 Simplified variants of SENSOR_DEVICE_ATTR and SENSOR_DEVICE_ATTR_2 are available
 374 and should be used if standard attribute permissions and function names are
 375 feasible. Standard permissions are 0644 for SENSOR_DEVICE_ATTR[_2]_RW,
 376 0444 for SENSOR_DEVICE_ATTR[_2]_RO, and 0200 for SENSOR_DEVICE_ATTR[_2]_WO.
 377 Standard functions, similar to DEVICE_ATTR_{RW,RO,WO}, have _show and _store
 378 appended to the provided function name.
 379
 380 SENSOR_DEVICE_ATTR and its variants define a struct sensor_device_attribute
 381 variable. This structure has the following fields::
 382
 383         struct sensor_device_attribute {
 384                 struct device_attribute dev_attr;
 385                 int index;
 386         };
 387
 388 You can use to_sensor_dev_attr to get the pointer to this structure from the
 389 attribute read or write function. Its parameter is the device to which the
 390 attribute is attached.
 391
 392 SENSOR_DEVICE_ATTR_2 and its variants define a struct sensor_device_attribute_2
 393 variable, which is defined as follows::
 394
 395         struct sensor_device_attribute_2 {
 396                 struct device_attribute dev_attr;
 397                 u8 index;
 398                 u8 nr;
 399         };
 400
 401 Use to_sensor_dev_attr_2 to get the pointer to this structure. Its parameter
 402 is the device to which the attribute is attached.