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 #define MAX_SYSFS_ATTR_NAME_LENGTH 32
43 struct hwmon_device_attribute
{
44 struct device_attribute dev_attr
;
45 const struct hwmon_ops
*ops
;
46 enum hwmon_sensor_types type
;
49 char name
[MAX_SYSFS_ATTR_NAME_LENGTH
];
52 #define to_hwmon_attr(d) \
53 container_of(d, struct hwmon_device_attribute, dev_attr)
56 * Thermal zone information
57 * In addition to the reference to the hwmon device,
58 * also provides the sensor index.
60 struct hwmon_thermal_data
{
61 struct hwmon_device
*hwdev
; /* Reference to hwmon device */
62 int index
; /* sensor index */
66 name_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
68 return sprintf(buf
, "%s\n", to_hwmon_device(dev
)->name
);
70 static DEVICE_ATTR_RO(name
);
72 static struct attribute
*hwmon_dev_attrs
[] = {
77 static umode_t
hwmon_dev_name_is_visible(struct kobject
*kobj
,
78 struct attribute
*attr
, int n
)
80 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
82 if (to_hwmon_device(dev
)->name
== NULL
)
88 static const struct attribute_group hwmon_dev_attr_group
= {
89 .attrs
= hwmon_dev_attrs
,
90 .is_visible
= hwmon_dev_name_is_visible
,
93 static const struct attribute_group
*hwmon_dev_attr_groups
[] = {
94 &hwmon_dev_attr_group
,
98 static void hwmon_dev_release(struct device
*dev
)
100 kfree(to_hwmon_device(dev
));
103 static struct class hwmon_class
= {
105 .owner
= THIS_MODULE
,
106 .dev_groups
= hwmon_dev_attr_groups
,
107 .dev_release
= hwmon_dev_release
,
110 static DEFINE_IDA(hwmon_ida
);
112 /* Thermal zone handling */
115 * The complex conditional is necessary to avoid a cyclic dependency
116 * between hwmon and thermal_sys modules.
118 #if IS_REACHABLE(CONFIG_THERMAL) && defined(CONFIG_THERMAL_OF) && \
119 (!defined(CONFIG_THERMAL_HWMON) || \
120 !(defined(MODULE) && IS_MODULE(CONFIG_THERMAL)))
121 static int hwmon_thermal_get_temp(void *data
, int *temp
)
123 struct hwmon_thermal_data
*tdata
= data
;
124 struct hwmon_device
*hwdev
= tdata
->hwdev
;
128 ret
= hwdev
->chip
->ops
->read(&hwdev
->dev
, hwmon_temp
, hwmon_temp_input
,
138 static const struct thermal_zone_of_device_ops hwmon_thermal_ops
= {
139 .get_temp
= hwmon_thermal_get_temp
,
142 static int hwmon_thermal_add_sensor(struct device
*dev
,
143 struct hwmon_device
*hwdev
, int index
)
145 struct hwmon_thermal_data
*tdata
;
147 tdata
= devm_kzalloc(dev
, sizeof(*tdata
), GFP_KERNEL
);
151 tdata
->hwdev
= hwdev
;
152 tdata
->index
= index
;
154 devm_thermal_zone_of_sensor_register(&hwdev
->dev
, index
, tdata
,
160 static int hwmon_thermal_add_sensor(struct device
*dev
,
161 struct hwmon_device
*hwdev
, int index
)
165 #endif /* IS_REACHABLE(CONFIG_THERMAL) && ... */
167 /* sysfs attribute management */
169 static ssize_t
hwmon_attr_show(struct device
*dev
,
170 struct device_attribute
*devattr
, char *buf
)
172 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
176 ret
= hattr
->ops
->read(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
181 return sprintf(buf
, "%ld\n", val
);
184 static ssize_t
hwmon_attr_show_string(struct device
*dev
,
185 struct device_attribute
*devattr
,
188 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
192 ret
= hattr
->ops
->read_string(dev
, hattr
->type
, hattr
->attr
,
197 return sprintf(buf
, "%s\n", s
);
200 static ssize_t
hwmon_attr_store(struct device
*dev
,
201 struct device_attribute
*devattr
,
202 const char *buf
, size_t count
)
204 struct hwmon_device_attribute
*hattr
= to_hwmon_attr(devattr
);
208 ret
= kstrtol(buf
, 10, &val
);
212 ret
= hattr
->ops
->write(dev
, hattr
->type
, hattr
->attr
, hattr
->index
,
220 static int hwmon_attr_base(enum hwmon_sensor_types type
)
222 if (type
== hwmon_in
)
227 static bool is_string_attr(enum hwmon_sensor_types type
, u32 attr
)
229 return (type
== hwmon_temp
&& attr
== hwmon_temp_label
) ||
230 (type
== hwmon_in
&& attr
== hwmon_in_label
) ||
231 (type
== hwmon_curr
&& attr
== hwmon_curr_label
) ||
232 (type
== hwmon_power
&& attr
== hwmon_power_label
) ||
233 (type
== hwmon_energy
&& attr
== hwmon_energy_label
) ||
234 (type
== hwmon_humidity
&& attr
== hwmon_humidity_label
) ||
235 (type
== hwmon_fan
&& attr
== hwmon_fan_label
);
238 static struct attribute
*hwmon_genattr(struct device
*dev
,
240 enum hwmon_sensor_types type
,
243 const char *template,
244 const struct hwmon_ops
*ops
)
246 struct hwmon_device_attribute
*hattr
;
247 struct device_attribute
*dattr
;
251 bool is_string
= is_string_attr(type
, attr
);
253 /* The attribute is invisible if there is no template string */
255 return ERR_PTR(-ENOENT
);
257 mode
= ops
->is_visible(drvdata
, type
, attr
, index
);
259 return ERR_PTR(-ENOENT
);
261 if ((mode
& S_IRUGO
) && ((is_string
&& !ops
->read_string
) ||
262 (!is_string
&& !ops
->read
)))
263 return ERR_PTR(-EINVAL
);
264 if ((mode
& S_IWUGO
) && !ops
->write
)
265 return ERR_PTR(-EINVAL
);
267 hattr
= devm_kzalloc(dev
, sizeof(*hattr
), GFP_KERNEL
);
269 return ERR_PTR(-ENOMEM
);
271 if (type
== hwmon_chip
) {
272 name
= (char *)template;
274 scnprintf(hattr
->name
, sizeof(hattr
->name
), template,
275 index
+ hwmon_attr_base(type
));
281 hattr
->index
= index
;
284 dattr
= &hattr
->dev_attr
;
285 dattr
->show
= is_string
? hwmon_attr_show_string
: hwmon_attr_show
;
286 dattr
->store
= hwmon_attr_store
;
297 * Chip attributes are not attribute templates but actual sysfs attributes.
298 * See hwmon_genattr() for special handling.
300 static const char * const hwmon_chip_attrs
[] = {
301 [hwmon_chip_temp_reset_history
] = "temp_reset_history",
302 [hwmon_chip_in_reset_history
] = "in_reset_history",
303 [hwmon_chip_curr_reset_history
] = "curr_reset_history",
304 [hwmon_chip_power_reset_history
] = "power_reset_history",
305 [hwmon_chip_update_interval
] = "update_interval",
306 [hwmon_chip_alarms
] = "alarms",
309 static const char * const hwmon_temp_attr_templates
[] = {
310 [hwmon_temp_input
] = "temp%d_input",
311 [hwmon_temp_type
] = "temp%d_type",
312 [hwmon_temp_lcrit
] = "temp%d_lcrit",
313 [hwmon_temp_lcrit_hyst
] = "temp%d_lcrit_hyst",
314 [hwmon_temp_min
] = "temp%d_min",
315 [hwmon_temp_min_hyst
] = "temp%d_min_hyst",
316 [hwmon_temp_max
] = "temp%d_max",
317 [hwmon_temp_max_hyst
] = "temp%d_max_hyst",
318 [hwmon_temp_crit
] = "temp%d_crit",
319 [hwmon_temp_crit_hyst
] = "temp%d_crit_hyst",
320 [hwmon_temp_emergency
] = "temp%d_emergency",
321 [hwmon_temp_emergency_hyst
] = "temp%d_emergency_hyst",
322 [hwmon_temp_alarm
] = "temp%d_alarm",
323 [hwmon_temp_lcrit_alarm
] = "temp%d_lcrit_alarm",
324 [hwmon_temp_min_alarm
] = "temp%d_min_alarm",
325 [hwmon_temp_max_alarm
] = "temp%d_max_alarm",
326 [hwmon_temp_crit_alarm
] = "temp%d_crit_alarm",
327 [hwmon_temp_emergency_alarm
] = "temp%d_emergency_alarm",
328 [hwmon_temp_fault
] = "temp%d_fault",
329 [hwmon_temp_offset
] = "temp%d_offset",
330 [hwmon_temp_label
] = "temp%d_label",
331 [hwmon_temp_lowest
] = "temp%d_lowest",
332 [hwmon_temp_highest
] = "temp%d_highest",
333 [hwmon_temp_reset_history
] = "temp%d_reset_history",
336 static const char * const hwmon_in_attr_templates
[] = {
337 [hwmon_in_input
] = "in%d_input",
338 [hwmon_in_min
] = "in%d_min",
339 [hwmon_in_max
] = "in%d_max",
340 [hwmon_in_lcrit
] = "in%d_lcrit",
341 [hwmon_in_crit
] = "in%d_crit",
342 [hwmon_in_average
] = "in%d_average",
343 [hwmon_in_lowest
] = "in%d_lowest",
344 [hwmon_in_highest
] = "in%d_highest",
345 [hwmon_in_reset_history
] = "in%d_reset_history",
346 [hwmon_in_label
] = "in%d_label",
347 [hwmon_in_alarm
] = "in%d_alarm",
348 [hwmon_in_min_alarm
] = "in%d_min_alarm",
349 [hwmon_in_max_alarm
] = "in%d_max_alarm",
350 [hwmon_in_lcrit_alarm
] = "in%d_lcrit_alarm",
351 [hwmon_in_crit_alarm
] = "in%d_crit_alarm",
354 static const char * const hwmon_curr_attr_templates
[] = {
355 [hwmon_curr_input
] = "curr%d_input",
356 [hwmon_curr_min
] = "curr%d_min",
357 [hwmon_curr_max
] = "curr%d_max",
358 [hwmon_curr_lcrit
] = "curr%d_lcrit",
359 [hwmon_curr_crit
] = "curr%d_crit",
360 [hwmon_curr_average
] = "curr%d_average",
361 [hwmon_curr_lowest
] = "curr%d_lowest",
362 [hwmon_curr_highest
] = "curr%d_highest",
363 [hwmon_curr_reset_history
] = "curr%d_reset_history",
364 [hwmon_curr_label
] = "curr%d_label",
365 [hwmon_curr_alarm
] = "curr%d_alarm",
366 [hwmon_curr_min_alarm
] = "curr%d_min_alarm",
367 [hwmon_curr_max_alarm
] = "curr%d_max_alarm",
368 [hwmon_curr_lcrit_alarm
] = "curr%d_lcrit_alarm",
369 [hwmon_curr_crit_alarm
] = "curr%d_crit_alarm",
372 static const char * const hwmon_power_attr_templates
[] = {
373 [hwmon_power_average
] = "power%d_average",
374 [hwmon_power_average_interval
] = "power%d_average_interval",
375 [hwmon_power_average_interval_max
] = "power%d_interval_max",
376 [hwmon_power_average_interval_min
] = "power%d_interval_min",
377 [hwmon_power_average_highest
] = "power%d_average_highest",
378 [hwmon_power_average_lowest
] = "power%d_average_lowest",
379 [hwmon_power_average_max
] = "power%d_average_max",
380 [hwmon_power_average_min
] = "power%d_average_min",
381 [hwmon_power_input
] = "power%d_input",
382 [hwmon_power_input_highest
] = "power%d_input_highest",
383 [hwmon_power_input_lowest
] = "power%d_input_lowest",
384 [hwmon_power_reset_history
] = "power%d_reset_history",
385 [hwmon_power_accuracy
] = "power%d_accuracy",
386 [hwmon_power_cap
] = "power%d_cap",
387 [hwmon_power_cap_hyst
] = "power%d_cap_hyst",
388 [hwmon_power_cap_max
] = "power%d_cap_max",
389 [hwmon_power_cap_min
] = "power%d_cap_min",
390 [hwmon_power_max
] = "power%d_max",
391 [hwmon_power_crit
] = "power%d_crit",
392 [hwmon_power_label
] = "power%d_label",
393 [hwmon_power_alarm
] = "power%d_alarm",
394 [hwmon_power_cap_alarm
] = "power%d_cap_alarm",
395 [hwmon_power_max_alarm
] = "power%d_max_alarm",
396 [hwmon_power_crit_alarm
] = "power%d_crit_alarm",
399 static const char * const hwmon_energy_attr_templates
[] = {
400 [hwmon_energy_input
] = "energy%d_input",
401 [hwmon_energy_label
] = "energy%d_label",
404 static const char * const hwmon_humidity_attr_templates
[] = {
405 [hwmon_humidity_input
] = "humidity%d_input",
406 [hwmon_humidity_label
] = "humidity%d_label",
407 [hwmon_humidity_min
] = "humidity%d_min",
408 [hwmon_humidity_min_hyst
] = "humidity%d_min_hyst",
409 [hwmon_humidity_max
] = "humidity%d_max",
410 [hwmon_humidity_max_hyst
] = "humidity%d_max_hyst",
411 [hwmon_humidity_alarm
] = "humidity%d_alarm",
412 [hwmon_humidity_fault
] = "humidity%d_fault",
415 static const char * const hwmon_fan_attr_templates
[] = {
416 [hwmon_fan_input
] = "fan%d_input",
417 [hwmon_fan_label
] = "fan%d_label",
418 [hwmon_fan_min
] = "fan%d_min",
419 [hwmon_fan_max
] = "fan%d_max",
420 [hwmon_fan_div
] = "fan%d_div",
421 [hwmon_fan_pulses
] = "fan%d_pulses",
422 [hwmon_fan_target
] = "fan%d_target",
423 [hwmon_fan_alarm
] = "fan%d_alarm",
424 [hwmon_fan_min_alarm
] = "fan%d_min_alarm",
425 [hwmon_fan_max_alarm
] = "fan%d_max_alarm",
426 [hwmon_fan_fault
] = "fan%d_fault",
429 static const char * const hwmon_pwm_attr_templates
[] = {
430 [hwmon_pwm_input
] = "pwm%d",
431 [hwmon_pwm_enable
] = "pwm%d_enable",
432 [hwmon_pwm_mode
] = "pwm%d_mode",
433 [hwmon_pwm_freq
] = "pwm%d_freq",
436 static const char * const *__templates
[] = {
437 [hwmon_chip
] = hwmon_chip_attrs
,
438 [hwmon_temp
] = hwmon_temp_attr_templates
,
439 [hwmon_in
] = hwmon_in_attr_templates
,
440 [hwmon_curr
] = hwmon_curr_attr_templates
,
441 [hwmon_power
] = hwmon_power_attr_templates
,
442 [hwmon_energy
] = hwmon_energy_attr_templates
,
443 [hwmon_humidity
] = hwmon_humidity_attr_templates
,
444 [hwmon_fan
] = hwmon_fan_attr_templates
,
445 [hwmon_pwm
] = hwmon_pwm_attr_templates
,
448 static const int __templates_size
[] = {
449 [hwmon_chip
] = ARRAY_SIZE(hwmon_chip_attrs
),
450 [hwmon_temp
] = ARRAY_SIZE(hwmon_temp_attr_templates
),
451 [hwmon_in
] = ARRAY_SIZE(hwmon_in_attr_templates
),
452 [hwmon_curr
] = ARRAY_SIZE(hwmon_curr_attr_templates
),
453 [hwmon_power
] = ARRAY_SIZE(hwmon_power_attr_templates
),
454 [hwmon_energy
] = ARRAY_SIZE(hwmon_energy_attr_templates
),
455 [hwmon_humidity
] = ARRAY_SIZE(hwmon_humidity_attr_templates
),
456 [hwmon_fan
] = ARRAY_SIZE(hwmon_fan_attr_templates
),
457 [hwmon_pwm
] = ARRAY_SIZE(hwmon_pwm_attr_templates
),
460 static int hwmon_num_channel_attrs(const struct hwmon_channel_info
*info
)
464 for (i
= n
= 0; info
->config
[i
]; i
++)
465 n
+= hweight32(info
->config
[i
]);
470 static int hwmon_genattrs(struct device
*dev
,
472 struct attribute
**attrs
,
473 const struct hwmon_ops
*ops
,
474 const struct hwmon_channel_info
*info
)
476 const char * const *templates
;
480 if (info
->type
>= ARRAY_SIZE(__templates
))
483 templates
= __templates
[info
->type
];
484 template_size
= __templates_size
[info
->type
];
486 for (i
= 0; info
->config
[i
]; i
++) {
487 u32 attr_mask
= info
->config
[i
];
493 attr
= __ffs(attr_mask
);
494 attr_mask
&= ~BIT(attr
);
495 if (attr
>= template_size
)
497 a
= hwmon_genattr(dev
, drvdata
, info
->type
, attr
, i
,
498 templates
[attr
], ops
);
500 if (PTR_ERR(a
) != -ENOENT
)
510 static struct attribute
**
511 __hwmon_create_attrs(struct device
*dev
, const void *drvdata
,
512 const struct hwmon_chip_info
*chip
)
514 int ret
, i
, aindex
= 0, nattrs
= 0;
515 struct attribute
**attrs
;
517 for (i
= 0; chip
->info
[i
]; i
++)
518 nattrs
+= hwmon_num_channel_attrs(chip
->info
[i
]);
521 return ERR_PTR(-EINVAL
);
523 attrs
= devm_kcalloc(dev
, nattrs
+ 1, sizeof(*attrs
), GFP_KERNEL
);
525 return ERR_PTR(-ENOMEM
);
527 for (i
= 0; chip
->info
[i
]; i
++) {
528 ret
= hwmon_genattrs(dev
, drvdata
, &attrs
[aindex
], chip
->ops
,
538 static struct device
*
539 __hwmon_device_register(struct device
*dev
, const char *name
, void *drvdata
,
540 const struct hwmon_chip_info
*chip
,
541 const struct attribute_group
**groups
)
543 struct hwmon_device
*hwdev
;
547 /* Complain about invalid characters in hwmon name attribute */
548 if (name
&& (!strlen(name
) || strpbrk(name
, "-* \t\n")))
550 "hwmon: '%s' is not a valid name attribute, please fix\n",
553 id
= ida_simple_get(&hwmon_ida
, 0, 0, GFP_KERNEL
);
557 hwdev
= kzalloc(sizeof(*hwdev
), GFP_KERNEL
);
566 struct attribute
**attrs
;
567 int ngroups
= 2; /* terminating NULL plus &hwdev->groups */
570 for (i
= 0; groups
[i
]; i
++)
573 hwdev
->groups
= devm_kcalloc(dev
, ngroups
, sizeof(*groups
),
575 if (!hwdev
->groups
) {
580 attrs
= __hwmon_create_attrs(dev
, drvdata
, chip
);
582 err
= PTR_ERR(attrs
);
586 hwdev
->group
.attrs
= attrs
;
588 hwdev
->groups
[ngroups
++] = &hwdev
->group
;
591 for (i
= 0; groups
[i
]; i
++)
592 hwdev
->groups
[ngroups
++] = groups
[i
];
595 hdev
->groups
= hwdev
->groups
;
597 hdev
->groups
= groups
;
601 hdev
->class = &hwmon_class
;
603 hdev
->of_node
= dev
? dev
->of_node
: NULL
;
605 dev_set_drvdata(hdev
, drvdata
);
606 dev_set_name(hdev
, HWMON_ID_FORMAT
, id
);
607 err
= device_register(hdev
);
611 if (dev
&& chip
&& chip
->ops
->read
&&
612 chip
->info
[0]->type
== hwmon_chip
&&
613 (chip
->info
[0]->config
[0] & HWMON_C_REGISTER_TZ
)) {
614 const struct hwmon_channel_info
**info
= chip
->info
;
616 for (i
= 1; info
[i
]; i
++) {
617 if (info
[i
]->type
!= hwmon_temp
)
620 for (j
= 0; info
[i
]->config
[j
]; j
++) {
621 if (!chip
->ops
->is_visible(drvdata
, hwmon_temp
,
622 hwmon_temp_input
, j
))
624 if (info
[i
]->config
[j
] & HWMON_T_INPUT
)
625 hwmon_thermal_add_sensor(dev
, hwdev
, j
);
635 ida_simple_remove(&hwmon_ida
, id
);
640 * hwmon_device_register_with_groups - register w/ hwmon
641 * @dev: the parent device
642 * @name: hwmon name attribute
643 * @drvdata: driver data to attach to created device
644 * @groups: List of attribute groups to create
646 * hwmon_device_unregister() must be called when the device is no
649 * Returns the pointer to the new device.
652 hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
654 const struct attribute_group
**groups
)
657 return ERR_PTR(-EINVAL
);
659 return __hwmon_device_register(dev
, name
, drvdata
, NULL
, groups
);
661 EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups
);
664 * hwmon_device_register_with_info - register w/ hwmon
665 * @dev: the parent device
666 * @name: hwmon name attribute
667 * @drvdata: driver data to attach to created device
668 * @info: pointer to hwmon chip information
669 * @extra_groups: pointer to list of additional non-standard attribute groups
671 * hwmon_device_unregister() must be called when the device is no
674 * Returns the pointer to the new device.
677 hwmon_device_register_with_info(struct device
*dev
, const char *name
,
679 const struct hwmon_chip_info
*chip
,
680 const struct attribute_group
**extra_groups
)
683 return ERR_PTR(-EINVAL
);
685 if (chip
&& (!chip
->ops
|| !chip
->ops
->is_visible
|| !chip
->info
))
686 return ERR_PTR(-EINVAL
);
688 return __hwmon_device_register(dev
, name
, drvdata
, chip
, extra_groups
);
690 EXPORT_SYMBOL_GPL(hwmon_device_register_with_info
);
693 * hwmon_device_register - register w/ hwmon
694 * @dev: the device to register
696 * hwmon_device_unregister() must be called when the device is no
699 * Returns the pointer to the new device.
701 struct device
*hwmon_device_register(struct device
*dev
)
704 "hwmon_device_register() is deprecated. Please convert the driver to use hwmon_device_register_with_info().\n");
706 return __hwmon_device_register(dev
, NULL
, NULL
, NULL
, NULL
);
708 EXPORT_SYMBOL_GPL(hwmon_device_register
);
711 * hwmon_device_unregister - removes the previously registered class device
713 * @dev: the class device to destroy
715 void hwmon_device_unregister(struct device
*dev
)
719 if (likely(sscanf(dev_name(dev
), HWMON_ID_FORMAT
, &id
) == 1)) {
720 device_unregister(dev
);
721 ida_simple_remove(&hwmon_ida
, id
);
724 "hwmon_device_unregister() failed: bad class ID!\n");
726 EXPORT_SYMBOL_GPL(hwmon_device_unregister
);
728 static void devm_hwmon_release(struct device
*dev
, void *res
)
730 struct device
*hwdev
= *(struct device
**)res
;
732 hwmon_device_unregister(hwdev
);
736 * devm_hwmon_device_register_with_groups - register w/ hwmon
737 * @dev: the parent device
738 * @name: hwmon name attribute
739 * @drvdata: driver data to attach to created device
740 * @groups: List of attribute groups to create
742 * Returns the pointer to the new device. The new device is automatically
743 * unregistered with the parent device.
746 devm_hwmon_device_register_with_groups(struct device
*dev
, const char *name
,
748 const struct attribute_group
**groups
)
750 struct device
**ptr
, *hwdev
;
753 return ERR_PTR(-EINVAL
);
755 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
757 return ERR_PTR(-ENOMEM
);
759 hwdev
= hwmon_device_register_with_groups(dev
, name
, drvdata
, groups
);
764 devres_add(dev
, ptr
);
771 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups
);
774 * devm_hwmon_device_register_with_info - register w/ hwmon
775 * @dev: the parent device
776 * @name: hwmon name attribute
777 * @drvdata: driver data to attach to created device
778 * @info: Pointer to hwmon chip information
779 * @groups - pointer to list of driver specific attribute groups
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_info(struct device
*dev
, const char *name
,
787 const struct hwmon_chip_info
*chip
,
788 const struct attribute_group
**groups
)
790 struct device
**ptr
, *hwdev
;
793 return ERR_PTR(-EINVAL
);
795 ptr
= devres_alloc(devm_hwmon_release
, sizeof(*ptr
), GFP_KERNEL
);
797 return ERR_PTR(-ENOMEM
);
799 hwdev
= hwmon_device_register_with_info(dev
, name
, drvdata
, chip
,
805 devres_add(dev
, ptr
);
813 EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_info
);
815 static int devm_hwmon_match(struct device
*dev
, void *res
, void *data
)
817 struct device
**hwdev
= res
;
819 return *hwdev
== data
;
823 * devm_hwmon_device_unregister - removes a previously registered hwmon device
825 * @dev: the parent device of the device to unregister
827 void devm_hwmon_device_unregister(struct device
*dev
)
829 WARN_ON(devres_release(dev
, devm_hwmon_release
, devm_hwmon_match
, dev
));
831 EXPORT_SYMBOL_GPL(devm_hwmon_device_unregister
);
833 static void __init
hwmon_pci_quirks(void)
835 #if defined CONFIG_X86 && defined CONFIG_PCI
840 /* Open access to 0x295-0x296 on MSI MS-7031 */
841 sb
= pci_get_device(PCI_VENDOR_ID_ATI
, 0x436c, NULL
);
843 if (sb
->subsystem_vendor
== 0x1462 && /* MSI */
844 sb
->subsystem_device
== 0x0031) { /* MS-7031 */
845 pci_read_config_byte(sb
, 0x48, &enable
);
846 pci_read_config_word(sb
, 0x64, &base
);
848 if (base
== 0 && !(enable
& BIT(2))) {
850 "Opening wide generic port at 0x295\n");
851 pci_write_config_word(sb
, 0x64, 0x295);
852 pci_write_config_byte(sb
, 0x48,
861 static int __init
hwmon_init(void)
867 err
= class_register(&hwmon_class
);
869 pr_err("couldn't register hwmon sysfs class\n");
875 static void __exit
hwmon_exit(void)
877 class_unregister(&hwmon_class
);
880 subsys_initcall(hwmon_init
);
881 module_exit(hwmon_exit
);
883 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
884 MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
885 MODULE_LICENSE("GPL");