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 HWMON_ID_PREFIX "hwmon"
28 #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
33 const struct hwmon_chip_info
*chip
;
35 struct attribute_group group
;
36 const struct attribute_group
**groups
;
39 #define to_hwmon_device(d) container_of(d, struct hwmon_device, dev)
41 struct hwmon_device_attribute
{
42 struct device_attribute dev_attr
;
43 const struct hwmon_ops
*ops
;
44 enum hwmon_sensor_types type
;
49 #define to_hwmon_attr(d) \
50 container_of(d, struct hwmon_device_attribute, dev_attr)
53 * Thermal zone information
54 * In addition to the reference to the hwmon device,
55 * also provides the sensor index.
57 struct hwmon_thermal_data
{
58 struct hwmon_device
*hwdev
; /* Reference to hwmon device */
59 int index
; /* sensor index */
63 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
65 return sprintf(buf
, "%s\n", to_hwmon_device(dev
)->name
);
67 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
69 static struct attribute
*hwmon_dev_attrs
[] = {
74 static umode_t
hwmon_dev_name_is_visible(struct kobject
*kobj
,
75 struct attribute
*attr
, int n
)
77 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
79 if (to_hwmon_device(dev
)->name
== NULL
)
85 static struct attribute_group hwmon_dev_attr_group
= {
86 .attrs
= hwmon_dev_attrs
,
87 .is_visible
= hwmon_dev_name_is_visible
,
90 static const struct attribute_group
*hwmon_dev_attr_groups
[] = {
91 &hwmon_dev_attr_group
,
95 static void hwmon_dev_release(struct device
*dev
)
97 kfree(to_hwmon_device(dev
));
100 static struct class hwmon_class
= {
102 .owner
= THIS_MODULE
,
103 .dev_groups
= hwmon_dev_attr_groups
,
104 .dev_release
= hwmon_dev_release
,
107 static DEFINE_IDA(hwmon_ida
);
109 /* Thermal zone handling */
112 * The complex conditional is necessary to avoid a cyclic dependency
113 * between hwmon and thermal_sys modules.
115 #if IS_REACHABLE(CONFIG_THERMAL) && defined(CONFIG_THERMAL_OF) && \
116 (!defined(CONFIG_THERMAL_HWMON) || \
117 !(defined(MODULE) && IS_MODULE(CONFIG_THERMAL)))
118 static int hwmon_thermal_get_temp(void *data
, int *temp
)
120 struct hwmon_thermal_data
*tdata
= data
;
121 struct hwmon_device
*hwdev
= tdata
->hwdev
;
125 ret
= hwdev
->chip
->ops
->read(&hwdev
->dev
, hwmon_temp
, hwmon_temp_input
,
135 static struct thermal_zone_of_device_ops hwmon_thermal_ops
= {
136 .get_temp
= hwmon_thermal_get_temp
,
139 static int hwmon_thermal_add_sensor(struct device
*dev
,
140 struct hwmon_device
*hwdev
, int index
)
142 struct hwmon_thermal_data
*tdata
;
144 tdata
= devm_kzalloc(dev
, sizeof(*tdata
), GFP_KERNEL
);
148 tdata
->hwdev
= hwdev
;
149 tdata
->index
= index
;
151 devm_thermal_zone_of_sensor_register(&hwdev
->dev
, index
, tdata
,
157 static int hwmon_thermal_add_sensor(struct device
*dev
,
158 struct hwmon_device
*hwdev
, int index
)
162 #endif /* IS_REACHABLE(CONFIG_THERMAL) && ... */
164 /* sysfs attribute management */
166 static ssize_t
hwmon_attr_show(struct device
*dev
,
167 struct device_attribute
*devattr
, char *buf
)
169 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
173 ret
= hattr
->ops
->read(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
178 return sprintf(buf
, "%ld\n", val
);
181 static ssize_t
hwmon_attr_show_string(struct device
*dev
,
182 struct device_attribute
*devattr
,
185 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
189 ret
= hattr
->ops
->read_string(dev
, hattr
->type
, hattr
->attr
,
194 return sprintf(buf
, "%s\n", s
);
197 static ssize_t
hwmon_attr_store(struct device
*dev
,
198 struct device_attribute
*devattr
,
199 const char *buf
, size_t count
)
201 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
205 ret
= kstrtol(buf
, 10, &val
);
209 ret
= hattr
->ops
->write(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
217 static int hwmon_attr_base(enum hwmon_sensor_types type
)
219 if (type
== hwmon_in
)
224 static bool is_string_attr(enum hwmon_sensor_types type
, u32 attr
)
226 return (type
== hwmon_temp
&& attr
== hwmon_temp_label
) ||
227 (type
== hwmon_in
&& attr
== hwmon_in_label
) ||
228 (type
== hwmon_curr
&& attr
== hwmon_curr_label
) ||
229 (type
== hwmon_power
&& attr
== hwmon_power_label
) ||
230 (type
== hwmon_energy
&& attr
== hwmon_energy_label
) ||
231 (type
== hwmon_humidity
&& attr
== hwmon_humidity_label
) ||
232 (type
== hwmon_fan
&& attr
== hwmon_fan_label
);
235 static struct attribute
*hwmon_genattr(struct device
*dev
,
237 enum hwmon_sensor_types type
,
240 const char *template,
241 const struct hwmon_ops
*ops
)
243 struct hwmon_device_attribute
*hattr
;
244 struct device_attribute
*dattr
;
248 bool is_string
= is_string_attr(type
, attr
);
250 /* The attribute is invisible if there is no template string */
252 return ERR_PTR(-ENOENT
);
254 mode
= ops
->is_visible(drvdata
, type
, attr
, index
);
256 return ERR_PTR(-ENOENT
);
258 if ((mode
& S_IRUGO
) && ((is_string
&& !ops
->read_string
) ||
259 (!is_string
&& !ops
->read
)))
260 return ERR_PTR(-EINVAL
);
261 if ((mode
& S_IWUGO
) && !ops
->write
)
262 return ERR_PTR(-EINVAL
);
264 if (type
== hwmon_chip
) {
265 name
= (char *)template;
267 name
= devm_kzalloc(dev
, strlen(template) + 16, GFP_KERNEL
);
269 return ERR_PTR(-ENOMEM
);
270 scnprintf(name
, strlen(template) + 16, template,
271 index
+ hwmon_attr_base(type
));
274 hattr
= devm_kzalloc(dev
, sizeof(*hattr
), GFP_KERNEL
);
276 return ERR_PTR(-ENOMEM
);
280 hattr
->index
= index
;
283 dattr
= &hattr
->dev_attr
;
284 dattr
->show
= is_string
? hwmon_attr_show_string
: hwmon_attr_show
;
285 dattr
->store
= hwmon_attr_store
;
296 * Chip attributes are not attribute templates but actual sysfs attributes.
297 * See hwmon_genattr() for special handling.
299 static const char * const hwmon_chip_attrs
[] = {
300 [hwmon_chip_temp_reset_history
] = "temp_reset_history",
301 [hwmon_chip_in_reset_history
] = "in_reset_history",
302 [hwmon_chip_curr_reset_history
] = "curr_reset_history",
303 [hwmon_chip_power_reset_history
] = "power_reset_history",
304 [hwmon_chip_update_interval
] = "update_interval",
305 [hwmon_chip_alarms
] = "alarms",
308 static const char * const hwmon_temp_attr_templates
[] = {
309 [hwmon_temp_input
] = "temp%d_input",
310 [hwmon_temp_type
] = "temp%d_type",
311 [hwmon_temp_lcrit
] = "temp%d_lcrit",
312 [hwmon_temp_lcrit_hyst
] = "temp%d_lcrit_hyst",
313 [hwmon_temp_min
] = "temp%d_min",
314 [hwmon_temp_min_hyst
] = "temp%d_min_hyst",
315 [hwmon_temp_max
] = "temp%d_max",
316 [hwmon_temp_max_hyst
] = "temp%d_max_hyst",
317 [hwmon_temp_crit
] = "temp%d_crit",
318 [hwmon_temp_crit_hyst
] = "temp%d_crit_hyst",
319 [hwmon_temp_emergency
] = "temp%d_emergency",
320 [hwmon_temp_emergency_hyst
] = "temp%d_emergency_hyst",
321 [hwmon_temp_alarm
] = "temp%d_alarm",
322 [hwmon_temp_lcrit_alarm
] = "temp%d_lcrit_alarm",
323 [hwmon_temp_min_alarm
] = "temp%d_min_alarm",
324 [hwmon_temp_max_alarm
] = "temp%d_max_alarm",
325 [hwmon_temp_crit_alarm
] = "temp%d_crit_alarm",
326 [hwmon_temp_emergency_alarm
] = "temp%d_emergency_alarm",
327 [hwmon_temp_fault
] = "temp%d_fault",
328 [hwmon_temp_offset
] = "temp%d_offset",
329 [hwmon_temp_label
] = "temp%d_label",
330 [hwmon_temp_lowest
] = "temp%d_lowest",
331 [hwmon_temp_highest
] = "temp%d_highest",
332 [hwmon_temp_reset_history
] = "temp%d_reset_history",
335 static const char * const hwmon_in_attr_templates
[] = {
336 [hwmon_in_input
] = "in%d_input",
337 [hwmon_in_min
] = "in%d_min",
338 [hwmon_in_max
] = "in%d_max",
339 [hwmon_in_lcrit
] = "in%d_lcrit",
340 [hwmon_in_crit
] = "in%d_crit",
341 [hwmon_in_average
] = "in%d_average",
342 [hwmon_in_lowest
] = "in%d_lowest",
343 [hwmon_in_highest
] = "in%d_highest",
344 [hwmon_in_reset_history
] = "in%d_reset_history",
345 [hwmon_in_label
] = "in%d_label",
346 [hwmon_in_alarm
] = "in%d_alarm",
347 [hwmon_in_min_alarm
] = "in%d_min_alarm",
348 [hwmon_in_max_alarm
] = "in%d_max_alarm",
349 [hwmon_in_lcrit_alarm
] = "in%d_lcrit_alarm",
350 [hwmon_in_crit_alarm
] = "in%d_crit_alarm",
353 static const char * const hwmon_curr_attr_templates
[] = {
354 [hwmon_curr_input
] = "curr%d_input",
355 [hwmon_curr_min
] = "curr%d_min",
356 [hwmon_curr_max
] = "curr%d_max",
357 [hwmon_curr_lcrit
] = "curr%d_lcrit",
358 [hwmon_curr_crit
] = "curr%d_crit",
359 [hwmon_curr_average
] = "curr%d_average",
360 [hwmon_curr_lowest
] = "curr%d_lowest",
361 [hwmon_curr_highest
] = "curr%d_highest",
362 [hwmon_curr_reset_history
] = "curr%d_reset_history",
363 [hwmon_curr_label
] = "curr%d_label",
364 [hwmon_curr_alarm
] = "curr%d_alarm",
365 [hwmon_curr_min_alarm
] = "curr%d_min_alarm",
366 [hwmon_curr_max_alarm
] = "curr%d_max_alarm",
367 [hwmon_curr_lcrit_alarm
] = "curr%d_lcrit_alarm",
368 [hwmon_curr_crit_alarm
] = "curr%d_crit_alarm",
371 static const char * const hwmon_power_attr_templates
[] = {
372 [hwmon_power_average
] = "power%d_average",
373 [hwmon_power_average_interval
] = "power%d_average_interval",
374 [hwmon_power_average_interval_max
] = "power%d_interval_max",
375 [hwmon_power_average_interval_min
] = "power%d_interval_min",
376 [hwmon_power_average_highest
] = "power%d_average_highest",
377 [hwmon_power_average_lowest
] = "power%d_average_lowest",
378 [hwmon_power_average_max
] = "power%d_average_max",
379 [hwmon_power_average_min
] = "power%d_average_min",
380 [hwmon_power_input
] = "power%d_input",
381 [hwmon_power_input_highest
] = "power%d_input_highest",
382 [hwmon_power_input_lowest
] = "power%d_input_lowest",
383 [hwmon_power_reset_history
] = "power%d_reset_history",
384 [hwmon_power_accuracy
] = "power%d_accuracy",
385 [hwmon_power_cap
] = "power%d_cap",
386 [hwmon_power_cap_hyst
] = "power%d_cap_hyst",
387 [hwmon_power_cap_max
] = "power%d_cap_max",
388 [hwmon_power_cap_min
] = "power%d_cap_min",
389 [hwmon_power_max
] = "power%d_max",
390 [hwmon_power_crit
] = "power%d_crit",
391 [hwmon_power_label
] = "power%d_label",
392 [hwmon_power_alarm
] = "power%d_alarm",
393 [hwmon_power_cap_alarm
] = "power%d_cap_alarm",
394 [hwmon_power_max_alarm
] = "power%d_max_alarm",
395 [hwmon_power_crit_alarm
] = "power%d_crit_alarm",
398 static const char * const hwmon_energy_attr_templates
[] = {
399 [hwmon_energy_input
] = "energy%d_input",
400 [hwmon_energy_label
] = "energy%d_label",
403 static const char * const hwmon_humidity_attr_templates
[] = {
404 [hwmon_humidity_input
] = "humidity%d_input",
405 [hwmon_humidity_label
] = "humidity%d_label",
406 [hwmon_humidity_min
] = "humidity%d_min",
407 [hwmon_humidity_min_hyst
] = "humidity%d_min_hyst",
408 [hwmon_humidity_max
] = "humidity%d_max",
409 [hwmon_humidity_max_hyst
] = "humidity%d_max_hyst",
410 [hwmon_humidity_alarm
] = "humidity%d_alarm",
411 [hwmon_humidity_fault
] = "humidity%d_fault",
414 static const char * const hwmon_fan_attr_templates
[] = {
415 [hwmon_fan_input
] = "fan%d_input",
416 [hwmon_fan_label
] = "fan%d_label",
417 [hwmon_fan_min
] = "fan%d_min",
418 [hwmon_fan_max
] = "fan%d_max",
419 [hwmon_fan_div
] = "fan%d_div",
420 [hwmon_fan_pulses
] = "fan%d_pulses",
421 [hwmon_fan_target
] = "fan%d_target",
422 [hwmon_fan_alarm
] = "fan%d_alarm",
423 [hwmon_fan_min_alarm
] = "fan%d_min_alarm",
424 [hwmon_fan_max_alarm
] = "fan%d_max_alarm",
425 [hwmon_fan_fault
] = "fan%d_fault",
428 static const char * const hwmon_pwm_attr_templates
[] = {
429 [hwmon_pwm_input
] = "pwm%d",
430 [hwmon_pwm_enable
] = "pwm%d_enable",
431 [hwmon_pwm_mode
] = "pwm%d_mode",
432 [hwmon_pwm_freq
] = "pwm%d_freq",
435 static const char * const *__templates
[] = {
436 [hwmon_chip
] = hwmon_chip_attrs
,
437 [hwmon_temp
] = hwmon_temp_attr_templates
,
438 [hwmon_in
] = hwmon_in_attr_templates
,
439 [hwmon_curr
] = hwmon_curr_attr_templates
,
440 [hwmon_power
] = hwmon_power_attr_templates
,
441 [hwmon_energy
] = hwmon_energy_attr_templates
,
442 [hwmon_humidity
] = hwmon_humidity_attr_templates
,
443 [hwmon_fan
] = hwmon_fan_attr_templates
,
444 [hwmon_pwm
] = hwmon_pwm_attr_templates
,
447 static const int __templates_size
[] = {
448 [hwmon_chip
] = ARRAY_SIZE(hwmon_chip_attrs
),
449 [hwmon_temp
] = ARRAY_SIZE(hwmon_temp_attr_templates
),
450 [hwmon_in
] = ARRAY_SIZE(hwmon_in_attr_templates
),
451 [hwmon_curr
] = ARRAY_SIZE(hwmon_curr_attr_templates
),
452 [hwmon_power
] = ARRAY_SIZE(hwmon_power_attr_templates
),
453 [hwmon_energy
] = ARRAY_SIZE(hwmon_energy_attr_templates
),
454 [hwmon_humidity
] = ARRAY_SIZE(hwmon_humidity_attr_templates
),
455 [hwmon_fan
] = ARRAY_SIZE(hwmon_fan_attr_templates
),
456 [hwmon_pwm
] = ARRAY_SIZE(hwmon_pwm_attr_templates
),
459 static int hwmon_num_channel_attrs(const struct hwmon_channel_info
*info
)
463 for (i
= n
= 0; info
->config
[i
]; i
++)
464 n
+= hweight32(info
->config
[i
]);
469 static int hwmon_genattrs(struct device
*dev
,
471 struct attribute
**attrs
,
472 const struct hwmon_ops
*ops
,
473 const struct hwmon_channel_info
*info
)
475 const char * const *templates
;
479 if (info
->type
>= ARRAY_SIZE(__templates
))
482 templates
= __templates
[info
->type
];
483 template_size
= __templates_size
[info
->type
];
485 for (i
= 0; info
->config
[i
]; i
++) {
486 u32 attr_mask
= info
->config
[i
];
492 attr
= __ffs(attr_mask
);
493 attr_mask
&= ~BIT(attr
);
494 if (attr
>= template_size
)
496 a
= hwmon_genattr(dev
, drvdata
, info
->type
, attr
, i
,
497 templates
[attr
], ops
);
499 if (PTR_ERR(a
) != -ENOENT
)
509 static struct attribute
**
510 __hwmon_create_attrs(struct device
*dev
, const void *drvdata
,
511 const struct hwmon_chip_info
*chip
)
513 int ret
, i
, aindex
= 0, nattrs
= 0;
514 struct attribute
**attrs
;
516 for (i
= 0; chip
->info
[i
]; i
++)
517 nattrs
+= hwmon_num_channel_attrs(chip
->info
[i
]);
520 return ERR_PTR(-EINVAL
);
522 attrs
= devm_kcalloc(dev
, nattrs
+ 1, sizeof(*attrs
), GFP_KERNEL
);
524 return ERR_PTR(-ENOMEM
);
526 for (i
= 0; chip
->info
[i
]; i
++) {
527 ret
= hwmon_genattrs(dev
, drvdata
, &attrs
[aindex
], chip
->ops
,
537 static struct device
*
538 __hwmon_device_register(struct device
*dev
, const char *name
, void *drvdata
,
539 const struct hwmon_chip_info
*chip
,
540 const struct attribute_group
**groups
)
542 struct hwmon_device
*hwdev
;
546 /* Do not accept invalid characters in hwmon name attribute */
547 if (name
&& (!strlen(name
) || strpbrk(name
, "-* \t\n")))
548 return ERR_PTR(-EINVAL
);
550 id
= ida_simple_get(&hwmon_ida
, 0, 0, GFP_KERNEL
);
554 hwdev
= kzalloc(sizeof(*hwdev
), GFP_KERNEL
);
562 if (chip
&& chip
->ops
->is_visible
) {
563 struct attribute
**attrs
;
567 for (i
= 0; groups
[i
]; i
++)
570 hwdev
->groups
= devm_kcalloc(dev
, ngroups
, sizeof(*groups
),
572 if (!hwdev
->groups
) {
577 attrs
= __hwmon_create_attrs(dev
, drvdata
, chip
);
579 err
= PTR_ERR(attrs
);
583 hwdev
->group
.attrs
= attrs
;
585 hwdev
->groups
[ngroups
++] = &hwdev
->group
;
588 for (i
= 0; groups
[i
]; i
++)
589 hwdev
->groups
[ngroups
++] = groups
[i
];
592 hdev
->groups
= hwdev
->groups
;
594 hdev
->groups
= groups
;
598 hdev
->class = &hwmon_class
;
600 hdev
->of_node
= dev
? dev
->of_node
: NULL
;
602 dev_set_drvdata(hdev
, drvdata
);
603 dev_set_name(hdev
, HWMON_ID_FORMAT
, id
);
604 err
= device_register(hdev
);
608 if (chip
&& chip
->ops
->is_visible
&& chip
->ops
->read
&&
609 chip
->info
[0]->type
== hwmon_chip
&&
610 (chip
->info
[0]->config
[0] & HWMON_C_REGISTER_TZ
)) {
611 const struct hwmon_channel_info
**info
= chip
->info
;
613 for (i
= 1; info
[i
]; i
++) {
614 if (info
[i
]->type
!= hwmon_temp
)
617 for (j
= 0; info
[i
]->config
[j
]; j
++) {
618 if (!chip
->ops
->is_visible(drvdata
, hwmon_temp
,
619 hwmon_temp_input
, j
))
621 if (info
[i
]->config
[j
] & HWMON_T_INPUT
)
622 hwmon_thermal_add_sensor(dev
, hwdev
, j
);
632 ida_simple_remove(&hwmon_ida
, id
);
637 * hwmon_device_register_with_groups - register w/ hwmon
638 * @dev: the parent device
639 * @name: hwmon name attribute
640 * @drvdata: driver data to attach to created device
641 * @groups: List of attribute groups to create
643 * hwmon_device_unregister() must be called when the device is no
646 * Returns the pointer to the new device.
649 hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
651 const struct attribute_group
**groups
)
653 return __hwmon_device_register(dev
, name
, drvdata
, NULL
, groups
);
655 EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups
);
658 * hwmon_device_register_with_info - register w/ hwmon
659 * @dev: the parent device
660 * @name: hwmon name attribute
661 * @drvdata: driver data to attach to created device
662 * @info: Pointer to hwmon chip information
663 * @groups - pointer to list of driver specific attribute groups
665 * hwmon_device_unregister() must be called when the device is no
668 * Returns the pointer to the new device.
671 hwmon_device_register_with_info(struct device
*dev
, const char *name
,
673 const struct hwmon_chip_info
*chip
,
674 const struct attribute_group
**groups
)
676 if (chip
&& (!chip
->ops
|| !chip
->info
))
677 return ERR_PTR(-EINVAL
);
679 return __hwmon_device_register(dev
, name
, drvdata
, chip
, groups
);
681 EXPORT_SYMBOL_GPL(hwmon_device_register_with_info
);
684 * hwmon_device_register - register w/ hwmon
685 * @dev: the device to register
687 * hwmon_device_unregister() must be called when the device is no
690 * Returns the pointer to the new device.
692 struct device
*hwmon_device_register(struct device
*dev
)
695 "hwmon_device_register() is deprecated. Please convert the driver to use hwmon_device_register_with_info().\n");
697 return hwmon_device_register_with_groups(dev
, NULL
, NULL
, NULL
);
699 EXPORT_SYMBOL_GPL(hwmon_device_register
);
702 * hwmon_device_unregister - removes the previously registered class device
704 * @dev: the class device to destroy
706 void hwmon_device_unregister(struct device
*dev
)
710 if (likely(sscanf(dev_name(dev
), HWMON_ID_FORMAT
, &id
) == 1)) {
711 device_unregister(dev
);
712 ida_simple_remove(&hwmon_ida
, id
);
715 "hwmon_device_unregister() failed: bad class ID!\n");
717 EXPORT_SYMBOL_GPL(hwmon_device_unregister
);
719 static void devm_hwmon_release(struct device
*dev
, void *res
)
721 struct device
*hwdev
= *(struct device
**)res
;
723 hwmon_device_unregister(hwdev
);
727 * devm_hwmon_device_register_with_groups - register w/ hwmon
728 * @dev: the parent device
729 * @name: hwmon name attribute
730 * @drvdata: driver data to attach to created device
731 * @groups: List of attribute groups to create
733 * Returns the pointer to the new device. The new device is automatically
734 * unregistered with the parent device.
737 devm_hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
739 const struct attribute_group
**groups
)
741 struct device
**ptr
, *hwdev
;
744 return ERR_PTR(-EINVAL
);
746 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
748 return ERR_PTR(-ENOMEM
);
750 hwdev
= hwmon_device_register_with_groups(dev
, name
, drvdata
, groups
);
755 devres_add(dev
, ptr
);
762 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups
);
765 * devm_hwmon_device_register_with_info - register w/ hwmon
766 * @dev: the parent device
767 * @name: hwmon name attribute
768 * @drvdata: driver data to attach to created device
769 * @info: Pointer to hwmon chip information
770 * @groups - pointer to list of driver specific attribute groups
772 * Returns the pointer to the new device. The new device is automatically
773 * unregistered with the parent device.
776 devm_hwmon_device_register_with_info(struct device
*dev
, const char *name
,
778 const struct hwmon_chip_info
*chip
,
779 const struct attribute_group
**groups
)
781 struct device
**ptr
, *hwdev
;
784 return ERR_PTR(-EINVAL
);
786 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
788 return ERR_PTR(-ENOMEM
);
790 hwdev
= hwmon_device_register_with_info(dev
, name
, drvdata
, chip
,
796 devres_add(dev
, ptr
);
804 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_info
);
806 static int devm_hwmon_match(struct device
*dev
, void *res
, void *data
)
808 struct device
**hwdev
= res
;
810 return *hwdev
== data
;
814 * devm_hwmon_device_unregister - removes a previously registered hwmon device
816 * @dev: the parent device of the device to unregister
818 void devm_hwmon_device_unregister(struct device
*dev
)
820 WARN_ON(devres_release(dev
, devm_hwmon_release
, devm_hwmon_match
, dev
));
822 EXPORT_SYMBOL_GPL(devm_hwmon_device_unregister
);
824 static void __init
hwmon_pci_quirks(void)
826 #if defined CONFIG_X86 && defined CONFIG_PCI
831 /* Open access to 0x295-0x296 on MSI MS-7031 */
832 sb
= pci_get_device(PCI_VENDOR_ID_ATI
, 0x436c, NULL
);
834 if (sb
->subsystem_vendor
== 0x1462 && /* MSI */
835 sb
->subsystem_device
== 0x0031) { /* MS-7031 */
836 pci_read_config_byte(sb
, 0x48, &enable
);
837 pci_read_config_word(sb
, 0x64, &base
);
839 if (base
== 0 && !(enable
& BIT(2))) {
841 "Opening wide generic port at 0x295\n");
842 pci_write_config_word(sb
, 0x64, 0x295);
843 pci_write_config_byte(sb
, 0x48,
852 static int __init
hwmon_init(void)
858 err
= class_register(&hwmon_class
);
860 pr_err("couldn't register hwmon sysfs class\n");
866 static void __exit
hwmon_exit(void)
868 class_unregister(&hwmon_class
);
871 subsys_initcall(hwmon_init
);
872 module_exit(hwmon_exit
);
874 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
875 MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
876 MODULE_LICENSE("GPL");