2 * hwmon.c - part of lm_sensors, Linux kernel modules for hardware monitoring
4 * This file defines the sysfs class "hwmon", for use by sensors drivers.
6 * Copyright (C) 2005 Mark M. Hoffman <mhoffman@lightlink.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/bitops.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/gfp.h>
19 #include <linux/hwmon.h>
20 #include <linux/idr.h>
21 #include <linux/module.h>
22 #include <linux/pci.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25 #include <linux/thermal.h>
27 #define CREATE_TRACE_POINTS
28 #include <trace/events/hwmon.h>
30 #define HWMON_ID_PREFIX "hwmon"
31 #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
36 const struct hwmon_chip_info
*chip
;
38 struct attribute_group group
;
39 const struct attribute_group
**groups
;
42 #define to_hwmon_device(d) container_of(d, struct hwmon_device, dev)
44 #define MAX_SYSFS_ATTR_NAME_LENGTH 32
46 struct hwmon_device_attribute
{
47 struct device_attribute dev_attr
;
48 const struct hwmon_ops
*ops
;
49 enum hwmon_sensor_types type
;
52 char name
[MAX_SYSFS_ATTR_NAME_LENGTH
];
55 #define to_hwmon_attr(d) \
56 container_of(d, struct hwmon_device_attribute, dev_attr)
59 * Thermal zone information
60 * In addition to the reference to the hwmon device,
61 * also provides the sensor index.
63 struct hwmon_thermal_data
{
64 struct hwmon_device
*hwdev
; /* Reference to hwmon device */
65 int index
; /* sensor index */
69 name_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
71 return sprintf(buf
, "%s\n", to_hwmon_device(dev
)->name
);
73 static DEVICE_ATTR_RO(name
);
75 static struct attribute
*hwmon_dev_attrs
[] = {
80 static umode_t
hwmon_dev_name_is_visible(struct kobject
*kobj
,
81 struct attribute
*attr
, int n
)
83 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
85 if (to_hwmon_device(dev
)->name
== NULL
)
91 static const struct attribute_group hwmon_dev_attr_group
= {
92 .attrs
= hwmon_dev_attrs
,
93 .is_visible
= hwmon_dev_name_is_visible
,
96 static const struct attribute_group
*hwmon_dev_attr_groups
[] = {
97 &hwmon_dev_attr_group
,
101 static void hwmon_dev_release(struct device
*dev
)
103 kfree(to_hwmon_device(dev
));
106 static struct class hwmon_class
= {
108 .owner
= THIS_MODULE
,
109 .dev_groups
= hwmon_dev_attr_groups
,
110 .dev_release
= hwmon_dev_release
,
113 static DEFINE_IDA(hwmon_ida
);
115 /* Thermal zone handling */
118 * The complex conditional is necessary to avoid a cyclic dependency
119 * between hwmon and thermal_sys modules.
121 #if IS_REACHABLE(CONFIG_THERMAL) && defined(CONFIG_THERMAL_OF) && \
122 (!defined(CONFIG_THERMAL_HWMON) || \
123 !(defined(MODULE) && IS_MODULE(CONFIG_THERMAL)))
124 static int hwmon_thermal_get_temp(void *data
, int *temp
)
126 struct hwmon_thermal_data
*tdata
= data
;
127 struct hwmon_device
*hwdev
= tdata
->hwdev
;
131 ret
= hwdev
->chip
->ops
->read(&hwdev
->dev
, hwmon_temp
, hwmon_temp_input
,
141 static const struct thermal_zone_of_device_ops hwmon_thermal_ops
= {
142 .get_temp
= hwmon_thermal_get_temp
,
145 static int hwmon_thermal_add_sensor(struct device
*dev
,
146 struct hwmon_device
*hwdev
, int index
)
148 struct hwmon_thermal_data
*tdata
;
149 struct thermal_zone_device
*tzd
;
151 tdata
= devm_kzalloc(dev
, sizeof(*tdata
), GFP_KERNEL
);
155 tdata
->hwdev
= hwdev
;
156 tdata
->index
= index
;
158 tzd
= devm_thermal_zone_of_sensor_register(&hwdev
->dev
, index
, tdata
,
161 * If CONFIG_THERMAL_OF is disabled, this returns -ENODEV,
162 * so ignore that error but forward any other error.
164 if (IS_ERR(tzd
) && (PTR_ERR(tzd
) != -ENODEV
))
170 static int hwmon_thermal_add_sensor(struct device
*dev
,
171 struct hwmon_device
*hwdev
, int index
)
175 #endif /* IS_REACHABLE(CONFIG_THERMAL) && ... */
177 static int hwmon_attr_base(enum hwmon_sensor_types type
)
179 if (type
== hwmon_in
)
184 /* sysfs attribute management */
186 static ssize_t
hwmon_attr_show(struct device
*dev
,
187 struct device_attribute
*devattr
, char *buf
)
189 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
193 ret
= hattr
->ops
->read(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
198 trace_hwmon_attr_show(hattr
->index
+ hwmon_attr_base(hattr
->type
),
201 return sprintf(buf
, "%ld\n", val
);
204 static ssize_t
hwmon_attr_show_string(struct device
*dev
,
205 struct device_attribute
*devattr
,
208 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
209 enum hwmon_sensor_types type
= hattr
->type
;
213 ret
= hattr
->ops
->read_string(dev
, hattr
->type
, hattr
->attr
,
218 trace_hwmon_attr_show_string(hattr
->index
+ hwmon_attr_base(type
),
221 return sprintf(buf
, "%s\n", s
);
224 static ssize_t
hwmon_attr_store(struct device
*dev
,
225 struct device_attribute
*devattr
,
226 const char *buf
, size_t count
)
228 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
232 ret
= kstrtol(buf
, 10, &val
);
236 ret
= hattr
->ops
->write(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
241 trace_hwmon_attr_store(hattr
->index
+ hwmon_attr_base(hattr
->type
),
247 static bool is_string_attr(enum hwmon_sensor_types type
, u32 attr
)
249 return (type
== hwmon_temp
&& attr
== hwmon_temp_label
) ||
250 (type
== hwmon_in
&& attr
== hwmon_in_label
) ||
251 (type
== hwmon_curr
&& attr
== hwmon_curr_label
) ||
252 (type
== hwmon_power
&& attr
== hwmon_power_label
) ||
253 (type
== hwmon_energy
&& attr
== hwmon_energy_label
) ||
254 (type
== hwmon_humidity
&& attr
== hwmon_humidity_label
) ||
255 (type
== hwmon_fan
&& attr
== hwmon_fan_label
);
258 static struct attribute
*hwmon_genattr(struct device
*dev
,
260 enum hwmon_sensor_types type
,
263 const char *template,
264 const struct hwmon_ops
*ops
)
266 struct hwmon_device_attribute
*hattr
;
267 struct device_attribute
*dattr
;
271 bool is_string
= is_string_attr(type
, attr
);
273 /* The attribute is invisible if there is no template string */
275 return ERR_PTR(-ENOENT
);
277 mode
= ops
->is_visible(drvdata
, type
, attr
, index
);
279 return ERR_PTR(-ENOENT
);
281 if ((mode
& 0444) && ((is_string
&& !ops
->read_string
) ||
282 (!is_string
&& !ops
->read
)))
283 return ERR_PTR(-EINVAL
);
284 if ((mode
& 0222) && !ops
->write
)
285 return ERR_PTR(-EINVAL
);
287 hattr
= devm_kzalloc(dev
, sizeof(*hattr
), GFP_KERNEL
);
289 return ERR_PTR(-ENOMEM
);
291 if (type
== hwmon_chip
) {
294 scnprintf(hattr
->name
, sizeof(hattr
->name
), template,
295 index
+ hwmon_attr_base(type
));
301 hattr
->index
= index
;
304 dattr
= &hattr
->dev_attr
;
305 dattr
->show
= is_string
? hwmon_attr_show_string
: hwmon_attr_show
;
306 dattr
->store
= hwmon_attr_store
;
317 * Chip attributes are not attribute templates but actual sysfs attributes.
318 * See hwmon_genattr() for special handling.
320 static const char * const hwmon_chip_attrs
[] = {
321 [hwmon_chip_temp_reset_history
] = "temp_reset_history",
322 [hwmon_chip_in_reset_history
] = "in_reset_history",
323 [hwmon_chip_curr_reset_history
] = "curr_reset_history",
324 [hwmon_chip_power_reset_history
] = "power_reset_history",
325 [hwmon_chip_update_interval
] = "update_interval",
326 [hwmon_chip_alarms
] = "alarms",
327 [hwmon_chip_samples
] = "samples",
328 [hwmon_chip_curr_samples
] = "curr_samples",
329 [hwmon_chip_in_samples
] = "in_samples",
330 [hwmon_chip_power_samples
] = "power_samples",
331 [hwmon_chip_temp_samples
] = "temp_samples",
334 static const char * const hwmon_temp_attr_templates
[] = {
335 [hwmon_temp_input
] = "temp%d_input",
336 [hwmon_temp_type
] = "temp%d_type",
337 [hwmon_temp_lcrit
] = "temp%d_lcrit",
338 [hwmon_temp_lcrit_hyst
] = "temp%d_lcrit_hyst",
339 [hwmon_temp_min
] = "temp%d_min",
340 [hwmon_temp_min_hyst
] = "temp%d_min_hyst",
341 [hwmon_temp_max
] = "temp%d_max",
342 [hwmon_temp_max_hyst
] = "temp%d_max_hyst",
343 [hwmon_temp_crit
] = "temp%d_crit",
344 [hwmon_temp_crit_hyst
] = "temp%d_crit_hyst",
345 [hwmon_temp_emergency
] = "temp%d_emergency",
346 [hwmon_temp_emergency_hyst
] = "temp%d_emergency_hyst",
347 [hwmon_temp_alarm
] = "temp%d_alarm",
348 [hwmon_temp_lcrit_alarm
] = "temp%d_lcrit_alarm",
349 [hwmon_temp_min_alarm
] = "temp%d_min_alarm",
350 [hwmon_temp_max_alarm
] = "temp%d_max_alarm",
351 [hwmon_temp_crit_alarm
] = "temp%d_crit_alarm",
352 [hwmon_temp_emergency_alarm
] = "temp%d_emergency_alarm",
353 [hwmon_temp_fault
] = "temp%d_fault",
354 [hwmon_temp_offset
] = "temp%d_offset",
355 [hwmon_temp_label
] = "temp%d_label",
356 [hwmon_temp_lowest
] = "temp%d_lowest",
357 [hwmon_temp_highest
] = "temp%d_highest",
358 [hwmon_temp_reset_history
] = "temp%d_reset_history",
361 static const char * const hwmon_in_attr_templates
[] = {
362 [hwmon_in_input
] = "in%d_input",
363 [hwmon_in_min
] = "in%d_min",
364 [hwmon_in_max
] = "in%d_max",
365 [hwmon_in_lcrit
] = "in%d_lcrit",
366 [hwmon_in_crit
] = "in%d_crit",
367 [hwmon_in_average
] = "in%d_average",
368 [hwmon_in_lowest
] = "in%d_lowest",
369 [hwmon_in_highest
] = "in%d_highest",
370 [hwmon_in_reset_history
] = "in%d_reset_history",
371 [hwmon_in_label
] = "in%d_label",
372 [hwmon_in_alarm
] = "in%d_alarm",
373 [hwmon_in_min_alarm
] = "in%d_min_alarm",
374 [hwmon_in_max_alarm
] = "in%d_max_alarm",
375 [hwmon_in_lcrit_alarm
] = "in%d_lcrit_alarm",
376 [hwmon_in_crit_alarm
] = "in%d_crit_alarm",
377 [hwmon_in_enable
] = "in%d_enable",
380 static const char * const hwmon_curr_attr_templates
[] = {
381 [hwmon_curr_input
] = "curr%d_input",
382 [hwmon_curr_min
] = "curr%d_min",
383 [hwmon_curr_max
] = "curr%d_max",
384 [hwmon_curr_lcrit
] = "curr%d_lcrit",
385 [hwmon_curr_crit
] = "curr%d_crit",
386 [hwmon_curr_average
] = "curr%d_average",
387 [hwmon_curr_lowest
] = "curr%d_lowest",
388 [hwmon_curr_highest
] = "curr%d_highest",
389 [hwmon_curr_reset_history
] = "curr%d_reset_history",
390 [hwmon_curr_label
] = "curr%d_label",
391 [hwmon_curr_alarm
] = "curr%d_alarm",
392 [hwmon_curr_min_alarm
] = "curr%d_min_alarm",
393 [hwmon_curr_max_alarm
] = "curr%d_max_alarm",
394 [hwmon_curr_lcrit_alarm
] = "curr%d_lcrit_alarm",
395 [hwmon_curr_crit_alarm
] = "curr%d_crit_alarm",
398 static const char * const hwmon_power_attr_templates
[] = {
399 [hwmon_power_average
] = "power%d_average",
400 [hwmon_power_average_interval
] = "power%d_average_interval",
401 [hwmon_power_average_interval_max
] = "power%d_interval_max",
402 [hwmon_power_average_interval_min
] = "power%d_interval_min",
403 [hwmon_power_average_highest
] = "power%d_average_highest",
404 [hwmon_power_average_lowest
] = "power%d_average_lowest",
405 [hwmon_power_average_max
] = "power%d_average_max",
406 [hwmon_power_average_min
] = "power%d_average_min",
407 [hwmon_power_input
] = "power%d_input",
408 [hwmon_power_input_highest
] = "power%d_input_highest",
409 [hwmon_power_input_lowest
] = "power%d_input_lowest",
410 [hwmon_power_reset_history
] = "power%d_reset_history",
411 [hwmon_power_accuracy
] = "power%d_accuracy",
412 [hwmon_power_cap
] = "power%d_cap",
413 [hwmon_power_cap_hyst
] = "power%d_cap_hyst",
414 [hwmon_power_cap_max
] = "power%d_cap_max",
415 [hwmon_power_cap_min
] = "power%d_cap_min",
416 [hwmon_power_min
] = "power%d_min",
417 [hwmon_power_max
] = "power%d_max",
418 [hwmon_power_lcrit
] = "power%d_lcrit",
419 [hwmon_power_crit
] = "power%d_crit",
420 [hwmon_power_label
] = "power%d_label",
421 [hwmon_power_alarm
] = "power%d_alarm",
422 [hwmon_power_cap_alarm
] = "power%d_cap_alarm",
423 [hwmon_power_min_alarm
] = "power%d_min_alarm",
424 [hwmon_power_max_alarm
] = "power%d_max_alarm",
425 [hwmon_power_lcrit_alarm
] = "power%d_lcrit_alarm",
426 [hwmon_power_crit_alarm
] = "power%d_crit_alarm",
429 static const char * const hwmon_energy_attr_templates
[] = {
430 [hwmon_energy_input
] = "energy%d_input",
431 [hwmon_energy_label
] = "energy%d_label",
434 static const char * const hwmon_humidity_attr_templates
[] = {
435 [hwmon_humidity_input
] = "humidity%d_input",
436 [hwmon_humidity_label
] = "humidity%d_label",
437 [hwmon_humidity_min
] = "humidity%d_min",
438 [hwmon_humidity_min_hyst
] = "humidity%d_min_hyst",
439 [hwmon_humidity_max
] = "humidity%d_max",
440 [hwmon_humidity_max_hyst
] = "humidity%d_max_hyst",
441 [hwmon_humidity_alarm
] = "humidity%d_alarm",
442 [hwmon_humidity_fault
] = "humidity%d_fault",
445 static const char * const hwmon_fan_attr_templates
[] = {
446 [hwmon_fan_input
] = "fan%d_input",
447 [hwmon_fan_label
] = "fan%d_label",
448 [hwmon_fan_min
] = "fan%d_min",
449 [hwmon_fan_max
] = "fan%d_max",
450 [hwmon_fan_div
] = "fan%d_div",
451 [hwmon_fan_pulses
] = "fan%d_pulses",
452 [hwmon_fan_target
] = "fan%d_target",
453 [hwmon_fan_alarm
] = "fan%d_alarm",
454 [hwmon_fan_min_alarm
] = "fan%d_min_alarm",
455 [hwmon_fan_max_alarm
] = "fan%d_max_alarm",
456 [hwmon_fan_fault
] = "fan%d_fault",
459 static const char * const hwmon_pwm_attr_templates
[] = {
460 [hwmon_pwm_input
] = "pwm%d",
461 [hwmon_pwm_enable
] = "pwm%d_enable",
462 [hwmon_pwm_mode
] = "pwm%d_mode",
463 [hwmon_pwm_freq
] = "pwm%d_freq",
466 static const char * const *__templates
[] = {
467 [hwmon_chip
] = hwmon_chip_attrs
,
468 [hwmon_temp
] = hwmon_temp_attr_templates
,
469 [hwmon_in
] = hwmon_in_attr_templates
,
470 [hwmon_curr
] = hwmon_curr_attr_templates
,
471 [hwmon_power
] = hwmon_power_attr_templates
,
472 [hwmon_energy
] = hwmon_energy_attr_templates
,
473 [hwmon_humidity
] = hwmon_humidity_attr_templates
,
474 [hwmon_fan
] = hwmon_fan_attr_templates
,
475 [hwmon_pwm
] = hwmon_pwm_attr_templates
,
478 static const int __templates_size
[] = {
479 [hwmon_chip
] = ARRAY_SIZE(hwmon_chip_attrs
),
480 [hwmon_temp
] = ARRAY_SIZE(hwmon_temp_attr_templates
),
481 [hwmon_in
] = ARRAY_SIZE(hwmon_in_attr_templates
),
482 [hwmon_curr
] = ARRAY_SIZE(hwmon_curr_attr_templates
),
483 [hwmon_power
] = ARRAY_SIZE(hwmon_power_attr_templates
),
484 [hwmon_energy
] = ARRAY_SIZE(hwmon_energy_attr_templates
),
485 [hwmon_humidity
] = ARRAY_SIZE(hwmon_humidity_attr_templates
),
486 [hwmon_fan
] = ARRAY_SIZE(hwmon_fan_attr_templates
),
487 [hwmon_pwm
] = ARRAY_SIZE(hwmon_pwm_attr_templates
),
490 static int hwmon_num_channel_attrs(const struct hwmon_channel_info
*info
)
494 for (i
= n
= 0; info
->config
[i
]; i
++)
495 n
+= hweight32(info
->config
[i
]);
500 static int hwmon_genattrs(struct device
*dev
,
502 struct attribute
**attrs
,
503 const struct hwmon_ops
*ops
,
504 const struct hwmon_channel_info
*info
)
506 const char * const *templates
;
510 if (info
->type
>= ARRAY_SIZE(__templates
))
513 templates
= __templates
[info
->type
];
514 template_size
= __templates_size
[info
->type
];
516 for (i
= 0; info
->config
[i
]; i
++) {
517 u32 attr_mask
= info
->config
[i
];
523 attr
= __ffs(attr_mask
);
524 attr_mask
&= ~BIT(attr
);
525 if (attr
>= template_size
)
527 a
= hwmon_genattr(dev
, drvdata
, info
->type
, attr
, i
,
528 templates
[attr
], ops
);
530 if (PTR_ERR(a
) != -ENOENT
)
540 static struct attribute
**
541 __hwmon_create_attrs(struct device
*dev
, const void *drvdata
,
542 const struct hwmon_chip_info
*chip
)
544 int ret
, i
, aindex
= 0, nattrs
= 0;
545 struct attribute
**attrs
;
547 for (i
= 0; chip
->info
[i
]; i
++)
548 nattrs
+= hwmon_num_channel_attrs(chip
->info
[i
]);
551 return ERR_PTR(-EINVAL
);
553 attrs
= devm_kcalloc(dev
, nattrs
+ 1, sizeof(*attrs
), GFP_KERNEL
);
555 return ERR_PTR(-ENOMEM
);
557 for (i
= 0; chip
->info
[i
]; i
++) {
558 ret
= hwmon_genattrs(dev
, drvdata
, &attrs
[aindex
], chip
->ops
,
568 static struct device
*
569 __hwmon_device_register(struct device
*dev
, const char *name
, void *drvdata
,
570 const struct hwmon_chip_info
*chip
,
571 const struct attribute_group
**groups
)
573 struct hwmon_device
*hwdev
;
577 /* Complain about invalid characters in hwmon name attribute */
578 if (name
&& (!strlen(name
) || strpbrk(name
, "-* \t\n")))
580 "hwmon: '%s' is not a valid name attribute, please fix\n",
583 id
= ida_simple_get(&hwmon_ida
, 0, 0, GFP_KERNEL
);
587 hwdev
= kzalloc(sizeof(*hwdev
), GFP_KERNEL
);
596 struct attribute
**attrs
;
597 int ngroups
= 2; /* terminating NULL plus &hwdev->groups */
600 for (i
= 0; groups
[i
]; i
++)
603 hwdev
->groups
= devm_kcalloc(dev
, ngroups
, sizeof(*groups
),
605 if (!hwdev
->groups
) {
610 attrs
= __hwmon_create_attrs(dev
, drvdata
, chip
);
612 err
= PTR_ERR(attrs
);
616 hwdev
->group
.attrs
= attrs
;
618 hwdev
->groups
[ngroups
++] = &hwdev
->group
;
621 for (i
= 0; groups
[i
]; i
++)
622 hwdev
->groups
[ngroups
++] = groups
[i
];
625 hdev
->groups
= hwdev
->groups
;
627 hdev
->groups
= groups
;
631 hdev
->class = &hwmon_class
;
633 hdev
->of_node
= dev
? dev
->of_node
: NULL
;
635 dev_set_drvdata(hdev
, drvdata
);
636 dev_set_name(hdev
, HWMON_ID_FORMAT
, id
);
637 err
= device_register(hdev
);
641 if (dev
&& chip
&& chip
->ops
->read
&&
642 chip
->info
[0]->type
== hwmon_chip
&&
643 (chip
->info
[0]->config
[0] & HWMON_C_REGISTER_TZ
)) {
644 const struct hwmon_channel_info
**info
= chip
->info
;
646 for (i
= 1; info
[i
]; i
++) {
647 if (info
[i
]->type
!= hwmon_temp
)
650 for (j
= 0; info
[i
]->config
[j
]; j
++) {
651 if (!chip
->ops
->is_visible(drvdata
, hwmon_temp
,
652 hwmon_temp_input
, j
))
654 if (info
[i
]->config
[j
] & HWMON_T_INPUT
) {
655 err
= hwmon_thermal_add_sensor(dev
,
658 device_unregister(hdev
);
671 ida_simple_remove(&hwmon_ida
, id
);
676 * hwmon_device_register_with_groups - register w/ hwmon
677 * @dev: the parent device
678 * @name: hwmon name attribute
679 * @drvdata: driver data to attach to created device
680 * @groups: List of attribute groups to create
682 * hwmon_device_unregister() must be called when the device is no
685 * Returns the pointer to the new device.
688 hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
690 const struct attribute_group
**groups
)
693 return ERR_PTR(-EINVAL
);
695 return __hwmon_device_register(dev
, name
, drvdata
, NULL
, groups
);
697 EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups
);
700 * hwmon_device_register_with_info - register w/ hwmon
701 * @dev: the parent device
702 * @name: hwmon name attribute
703 * @drvdata: driver data to attach to created device
704 * @chip: pointer to hwmon chip information
705 * @extra_groups: pointer to list of additional non-standard attribute groups
707 * hwmon_device_unregister() must be called when the device is no
710 * Returns the pointer to the new device.
713 hwmon_device_register_with_info(struct device
*dev
, const char *name
,
715 const struct hwmon_chip_info
*chip
,
716 const struct attribute_group
**extra_groups
)
719 return ERR_PTR(-EINVAL
);
721 if (chip
&& (!chip
->ops
|| !chip
->ops
->is_visible
|| !chip
->info
))
722 return ERR_PTR(-EINVAL
);
725 return ERR_PTR(-EINVAL
);
727 return __hwmon_device_register(dev
, name
, drvdata
, chip
, extra_groups
);
729 EXPORT_SYMBOL_GPL(hwmon_device_register_with_info
);
732 * hwmon_device_register - register w/ hwmon
733 * @dev: the device to register
735 * hwmon_device_unregister() must be called when the device is no
738 * Returns the pointer to the new device.
740 struct device
*hwmon_device_register(struct device
*dev
)
743 "hwmon_device_register() is deprecated. Please convert the driver to use hwmon_device_register_with_info().\n");
745 return __hwmon_device_register(dev
, NULL
, NULL
, NULL
, NULL
);
747 EXPORT_SYMBOL_GPL(hwmon_device_register
);
750 * hwmon_device_unregister - removes the previously registered class device
752 * @dev: the class device to destroy
754 void hwmon_device_unregister(struct device
*dev
)
758 if (likely(sscanf(dev_name(dev
), HWMON_ID_FORMAT
, &id
) == 1)) {
759 device_unregister(dev
);
760 ida_simple_remove(&hwmon_ida
, id
);
763 "hwmon_device_unregister() failed: bad class ID!\n");
765 EXPORT_SYMBOL_GPL(hwmon_device_unregister
);
767 static void devm_hwmon_release(struct device
*dev
, void *res
)
769 struct device
*hwdev
= *(struct device
**)res
;
771 hwmon_device_unregister(hwdev
);
775 * devm_hwmon_device_register_with_groups - register w/ hwmon
776 * @dev: the parent device
777 * @name: hwmon name attribute
778 * @drvdata: driver data to attach to created device
779 * @groups: List of attribute groups to create
781 * Returns the pointer to the new device. The new device is automatically
782 * unregistered with the parent device.
785 devm_hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
787 const struct attribute_group
**groups
)
789 struct device
**ptr
, *hwdev
;
792 return ERR_PTR(-EINVAL
);
794 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
796 return ERR_PTR(-ENOMEM
);
798 hwdev
= hwmon_device_register_with_groups(dev
, name
, drvdata
, groups
);
803 devres_add(dev
, ptr
);
810 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups
);
813 * devm_hwmon_device_register_with_info - register w/ hwmon
814 * @dev: the parent device
815 * @name: hwmon name attribute
816 * @drvdata: driver data to attach to created device
817 * @chip: pointer to hwmon chip information
818 * @groups: pointer to list of driver specific attribute groups
820 * Returns the pointer to the new device. The new device is automatically
821 * unregistered with the parent device.
824 devm_hwmon_device_register_with_info(struct device
*dev
, const char *name
,
826 const struct hwmon_chip_info
*chip
,
827 const struct attribute_group
**groups
)
829 struct device
**ptr
, *hwdev
;
832 return ERR_PTR(-EINVAL
);
834 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
836 return ERR_PTR(-ENOMEM
);
838 hwdev
= hwmon_device_register_with_info(dev
, name
, drvdata
, chip
,
844 devres_add(dev
, ptr
);
852 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_info
);
854 static int devm_hwmon_match(struct device
*dev
, void *res
, void *data
)
856 struct device
**hwdev
= res
;
858 return *hwdev
== data
;
862 * devm_hwmon_device_unregister - removes a previously registered hwmon device
864 * @dev: the parent device of the device to unregister
866 void devm_hwmon_device_unregister(struct device
*dev
)
868 WARN_ON(devres_release(dev
, devm_hwmon_release
, devm_hwmon_match
, dev
));
870 EXPORT_SYMBOL_GPL(devm_hwmon_device_unregister
);
872 static void __init
hwmon_pci_quirks(void)
874 #if defined CONFIG_X86 && defined CONFIG_PCI
879 /* Open access to 0x295-0x296 on MSI MS-7031 */
880 sb
= pci_get_device(PCI_VENDOR_ID_ATI
, 0x436c, NULL
);
882 if (sb
->subsystem_vendor
== 0x1462 && /* MSI */
883 sb
->subsystem_device
== 0x0031) { /* MS-7031 */
884 pci_read_config_byte(sb
, 0x48, &enable
);
885 pci_read_config_word(sb
, 0x64, &base
);
887 if (base
== 0 && !(enable
& BIT(2))) {
889 "Opening wide generic port at 0x295\n");
890 pci_write_config_word(sb
, 0x64, 0x295);
891 pci_write_config_byte(sb
, 0x48,
900 static int __init
hwmon_init(void)
906 err
= class_register(&hwmon_class
);
908 pr_err("couldn't register hwmon sysfs class\n");
914 static void __exit
hwmon_exit(void)
916 class_unregister(&hwmon_class
);
919 subsys_initcall(hwmon_init
);
920 module_exit(hwmon_exit
);
922 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
923 MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
924 MODULE_LICENSE("GPL");