1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* hwmon interface for the ACPI Fan driver.
*
* Copyright (C) 2024 Armin Wolf <W_Armin@gmx.de>
*/
#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/limits.h>
#include <linux/types.h>
#include <linux/units.h>
#include "fan.h"
/* Returned when the ACPI fan does not support speed reporting */
#define FAN_SPEED_UNAVAILABLE U32_MAX
#define FAN_POWER_UNAVAILABLE U32_MAX
static struct acpi_fan_fps *acpi_fan_get_current_fps(struct acpi_fan *fan, u64 control)
{
unsigned int i;
for (i = 0; i < fan->fps_count; i++) {
if (fan->fps[i].control == control)
return &fan->fps[i];
}
return NULL;
}
static umode_t acpi_fan_hwmon_is_visible(const void *drvdata, enum hwmon_sensor_types type,
u32 attr, int channel)
{
const struct acpi_fan *fan = drvdata;
unsigned int i;
switch (type) {
case hwmon_fan:
switch (attr) {
case hwmon_fan_input:
return 0444;
case hwmon_fan_target:
/*
* When in fine grain control mode, not every fan control value
* has an associated fan performance state.
*/
if (fan->fif.fine_grain_ctrl)
return 0;
return 0444;
default:
return 0;
}
case hwmon_power:
switch (attr) {
case hwmon_power_input:
/*
* When in fine grain control mode, not every fan control value
* has an associated fan performance state.
*/
if (fan->fif.fine_grain_ctrl)
return 0;
/*
* When all fan performance states contain no valid power data,
* when the associated attribute should not be created.
*/
for (i = 0; i < fan->fps_count; i++) {
if (fan->fps[i].power != FAN_POWER_UNAVAILABLE)
return 0444;
}
return 0;
default:
return 0;
}
default:
return 0;
}
}
static int acpi_fan_hwmon_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
int channel, long *val)
{
struct acpi_device *adev = to_acpi_device(dev->parent);
struct acpi_fan *fan = dev_get_drvdata(dev);
struct acpi_fan_fps *fps;
struct acpi_fan_fst fst;
int ret;
ret = acpi_fan_get_fst(adev, &fst);
if (ret < 0)
return ret;
switch (type) {
case hwmon_fan:
switch (attr) {
case hwmon_fan_input:
if (fst.speed == FAN_SPEED_UNAVAILABLE)
return -ENODEV;
if (fst.speed > LONG_MAX)
return -EOVERFLOW;
*val = fst.speed;
return 0;
case hwmon_fan_target:
fps = acpi_fan_get_current_fps(fan, fst.control);
if (!fps)
return -EIO;
if (fps->speed > LONG_MAX)
return -EOVERFLOW;
*val = fps->speed;
return 0;
default:
return -EOPNOTSUPP;
}
case hwmon_power:
switch (attr) {
case hwmon_power_input:
fps = acpi_fan_get_current_fps(fan, fst.control);
if (!fps)
return -EIO;
if (fps->power == FAN_POWER_UNAVAILABLE)
return -ENODEV;
if (fps->power > LONG_MAX / MICROWATT_PER_MILLIWATT)
return -EOVERFLOW;
*val = fps->power * MICROWATT_PER_MILLIWATT;
return 0;
default:
return -EOPNOTSUPP;
}
default:
return -EOPNOTSUPP;
}
}
static const struct hwmon_ops acpi_fan_hwmon_ops = {
.is_visible = acpi_fan_hwmon_is_visible,
.read = acpi_fan_hwmon_read,
};
static const struct hwmon_channel_info * const acpi_fan_hwmon_info[] = {
HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_TARGET),
HWMON_CHANNEL_INFO(power, HWMON_P_INPUT),
NULL
};
static const struct hwmon_chip_info acpi_fan_hwmon_chip_info = {
.ops = &acpi_fan_hwmon_ops,
.info = acpi_fan_hwmon_info,
};
int devm_acpi_fan_create_hwmon(struct acpi_device *device)
{
struct acpi_fan *fan = acpi_driver_data(device);
struct device *hdev;
hdev = devm_hwmon_device_register_with_info(&device->dev, "acpi_fan", fan,
&acpi_fan_hwmon_chip_info, NULL);
return PTR_ERR_OR_ZERO(hdev);
}
|
