This source file includes following definitions.
- power_supply_hwmon_in_to_property
- power_supply_hwmon_curr_to_property
- power_supply_hwmon_temp_to_property
- power_supply_hwmon_to_property
- power_supply_hwmon_is_a_label
- power_supply_hwmon_is_writable
- power_supply_hwmon_is_visible
- power_supply_hwmon_read_string
- power_supply_hwmon_read
- power_supply_hwmon_write
- power_supply_hwmon_bitmap_free
- power_supply_add_hwmon_sysfs
- power_supply_remove_hwmon_sysfs
1
2
3
4
5
6 #include <linux/err.h>
7 #include <linux/hwmon.h>
8 #include <linux/power_supply.h>
9 #include <linux/slab.h>
10
11 struct power_supply_hwmon {
12 struct power_supply *psy;
13 unsigned long *props;
14 };
15
16 static int power_supply_hwmon_in_to_property(u32 attr)
17 {
18 switch (attr) {
19 case hwmon_in_average:
20 return POWER_SUPPLY_PROP_VOLTAGE_AVG;
21 case hwmon_in_min:
22 return POWER_SUPPLY_PROP_VOLTAGE_MIN;
23 case hwmon_in_max:
24 return POWER_SUPPLY_PROP_VOLTAGE_MAX;
25 case hwmon_in_input:
26 return POWER_SUPPLY_PROP_VOLTAGE_NOW;
27 default:
28 return -EINVAL;
29 }
30 }
31
32 static int power_supply_hwmon_curr_to_property(u32 attr)
33 {
34 switch (attr) {
35 case hwmon_curr_average:
36 return POWER_SUPPLY_PROP_CURRENT_AVG;
37 case hwmon_curr_max:
38 return POWER_SUPPLY_PROP_CURRENT_MAX;
39 case hwmon_curr_input:
40 return POWER_SUPPLY_PROP_CURRENT_NOW;
41 default:
42 return -EINVAL;
43 }
44 }
45
46 static int power_supply_hwmon_temp_to_property(u32 attr, int channel)
47 {
48 if (channel) {
49 switch (attr) {
50 case hwmon_temp_input:
51 return POWER_SUPPLY_PROP_TEMP_AMBIENT;
52 case hwmon_temp_min_alarm:
53 return POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN;
54 case hwmon_temp_max_alarm:
55 return POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX;
56 default:
57 break;
58 }
59 } else {
60 switch (attr) {
61 case hwmon_temp_input:
62 return POWER_SUPPLY_PROP_TEMP;
63 case hwmon_temp_max:
64 return POWER_SUPPLY_PROP_TEMP_MAX;
65 case hwmon_temp_min:
66 return POWER_SUPPLY_PROP_TEMP_MIN;
67 case hwmon_temp_min_alarm:
68 return POWER_SUPPLY_PROP_TEMP_ALERT_MIN;
69 case hwmon_temp_max_alarm:
70 return POWER_SUPPLY_PROP_TEMP_ALERT_MAX;
71 default:
72 break;
73 }
74 }
75
76 return -EINVAL;
77 }
78
79 static int
80 power_supply_hwmon_to_property(enum hwmon_sensor_types type,
81 u32 attr, int channel)
82 {
83 switch (type) {
84 case hwmon_in:
85 return power_supply_hwmon_in_to_property(attr);
86 case hwmon_curr:
87 return power_supply_hwmon_curr_to_property(attr);
88 case hwmon_temp:
89 return power_supply_hwmon_temp_to_property(attr, channel);
90 default:
91 return -EINVAL;
92 }
93 }
94
95 static bool power_supply_hwmon_is_a_label(enum hwmon_sensor_types type,
96 u32 attr)
97 {
98 return type == hwmon_temp && attr == hwmon_temp_label;
99 }
100
101 static bool power_supply_hwmon_is_writable(enum hwmon_sensor_types type,
102 u32 attr)
103 {
104 switch (type) {
105 case hwmon_in:
106 return attr == hwmon_in_min ||
107 attr == hwmon_in_max;
108 case hwmon_curr:
109 return attr == hwmon_curr_max;
110 case hwmon_temp:
111 return attr == hwmon_temp_max ||
112 attr == hwmon_temp_min ||
113 attr == hwmon_temp_min_alarm ||
114 attr == hwmon_temp_max_alarm;
115 default:
116 return false;
117 }
118 }
119
120 static umode_t power_supply_hwmon_is_visible(const void *data,
121 enum hwmon_sensor_types type,
122 u32 attr, int channel)
123 {
124 const struct power_supply_hwmon *psyhw = data;
125 int prop;
126
127
128 if (power_supply_hwmon_is_a_label(type, attr))
129 return 0444;
130
131 prop = power_supply_hwmon_to_property(type, attr, channel);
132 if (prop < 0 || !test_bit(prop, psyhw->props))
133 return 0;
134
135 if (power_supply_property_is_writeable(psyhw->psy, prop) > 0 &&
136 power_supply_hwmon_is_writable(type, attr))
137 return 0644;
138
139 return 0444;
140 }
141
142 static int power_supply_hwmon_read_string(struct device *dev,
143 enum hwmon_sensor_types type,
144 u32 attr, int channel,
145 const char **str)
146 {
147 *str = channel ? "temp" : "temp ambient";
148 return 0;
149 }
150
151 static int
152 power_supply_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
153 u32 attr, int channel, long *val)
154 {
155 struct power_supply_hwmon *psyhw = dev_get_drvdata(dev);
156 struct power_supply *psy = psyhw->psy;
157 union power_supply_propval pspval;
158 int ret, prop;
159
160 prop = power_supply_hwmon_to_property(type, attr, channel);
161 if (prop < 0)
162 return prop;
163
164 ret = power_supply_get_property(psy, prop, &pspval);
165 if (ret)
166 return ret;
167
168 switch (type) {
169
170
171
172
173
174 case hwmon_curr:
175 case hwmon_in:
176 pspval.intval = DIV_ROUND_CLOSEST(pspval.intval, 1000);
177 break;
178
179
180
181 case hwmon_temp:
182 if (check_mul_overflow(pspval.intval, 100,
183 &pspval.intval))
184 return -EOVERFLOW;
185 break;
186 default:
187 return -EINVAL;
188 }
189
190 *val = pspval.intval;
191
192 return 0;
193 }
194
195 static int
196 power_supply_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
197 u32 attr, int channel, long val)
198 {
199 struct power_supply_hwmon *psyhw = dev_get_drvdata(dev);
200 struct power_supply *psy = psyhw->psy;
201 union power_supply_propval pspval;
202 int prop;
203
204 prop = power_supply_hwmon_to_property(type, attr, channel);
205 if (prop < 0)
206 return prop;
207
208 pspval.intval = val;
209
210 switch (type) {
211
212
213
214
215
216 case hwmon_curr:
217 case hwmon_in:
218 if (check_mul_overflow(pspval.intval, 1000,
219 &pspval.intval))
220 return -EOVERFLOW;
221 break;
222
223
224
225 case hwmon_temp:
226 pspval.intval = DIV_ROUND_CLOSEST(pspval.intval, 100);
227 break;
228 default:
229 return -EINVAL;
230 }
231
232 return power_supply_set_property(psy, prop, &pspval);
233 }
234
235 static const struct hwmon_ops power_supply_hwmon_ops = {
236 .is_visible = power_supply_hwmon_is_visible,
237 .read = power_supply_hwmon_read,
238 .write = power_supply_hwmon_write,
239 .read_string = power_supply_hwmon_read_string,
240 };
241
242 static const struct hwmon_channel_info *power_supply_hwmon_info[] = {
243 HWMON_CHANNEL_INFO(temp,
244 HWMON_T_LABEL |
245 HWMON_T_INPUT |
246 HWMON_T_MAX |
247 HWMON_T_MIN |
248 HWMON_T_MIN_ALARM |
249 HWMON_T_MIN_ALARM,
250
251 HWMON_T_LABEL |
252 HWMON_T_INPUT |
253 HWMON_T_MIN_ALARM |
254 HWMON_T_LABEL |
255 HWMON_T_MAX_ALARM),
256
257 HWMON_CHANNEL_INFO(curr,
258 HWMON_C_AVERAGE |
259 HWMON_C_MAX |
260 HWMON_C_INPUT),
261
262 HWMON_CHANNEL_INFO(in,
263 HWMON_I_AVERAGE |
264 HWMON_I_MIN |
265 HWMON_I_MAX |
266 HWMON_I_INPUT),
267 NULL
268 };
269
270 static const struct hwmon_chip_info power_supply_hwmon_chip_info = {
271 .ops = &power_supply_hwmon_ops,
272 .info = power_supply_hwmon_info,
273 };
274
275 static void power_supply_hwmon_bitmap_free(void *data)
276 {
277 bitmap_free(data);
278 }
279
280 int power_supply_add_hwmon_sysfs(struct power_supply *psy)
281 {
282 const struct power_supply_desc *desc = psy->desc;
283 struct power_supply_hwmon *psyhw;
284 struct device *dev = &psy->dev;
285 struct device *hwmon;
286 int ret, i;
287 const char *name;
288
289 if (!devres_open_group(dev, power_supply_add_hwmon_sysfs,
290 GFP_KERNEL))
291 return -ENOMEM;
292
293 psyhw = devm_kzalloc(dev, sizeof(*psyhw), GFP_KERNEL);
294 if (!psyhw) {
295 ret = -ENOMEM;
296 goto error;
297 }
298
299 psyhw->psy = psy;
300 psyhw->props = bitmap_zalloc(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG + 1,
301 GFP_KERNEL);
302 if (!psyhw->props) {
303 ret = -ENOMEM;
304 goto error;
305 }
306
307 ret = devm_add_action(dev, power_supply_hwmon_bitmap_free,
308 psyhw->props);
309 if (ret)
310 goto error;
311
312 for (i = 0; i < desc->num_properties; i++) {
313 const enum power_supply_property prop = desc->properties[i];
314
315 switch (prop) {
316 case POWER_SUPPLY_PROP_CURRENT_AVG:
317 case POWER_SUPPLY_PROP_CURRENT_MAX:
318 case POWER_SUPPLY_PROP_CURRENT_NOW:
319 case POWER_SUPPLY_PROP_TEMP:
320 case POWER_SUPPLY_PROP_TEMP_MAX:
321 case POWER_SUPPLY_PROP_TEMP_MIN:
322 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
323 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
324 case POWER_SUPPLY_PROP_TEMP_AMBIENT:
325 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN:
326 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX:
327 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
328 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
329 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
330 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
331 set_bit(prop, psyhw->props);
332 break;
333 default:
334 break;
335 }
336 }
337
338 name = psy->desc->name;
339 if (strchr(name, '-')) {
340 char *new_name;
341
342 new_name = devm_kstrdup(dev, name, GFP_KERNEL);
343 if (!new_name) {
344 ret = -ENOMEM;
345 goto error;
346 }
347 strreplace(new_name, '-', '_');
348 name = new_name;
349 }
350 hwmon = devm_hwmon_device_register_with_info(dev, name,
351 psyhw,
352 &power_supply_hwmon_chip_info,
353 NULL);
354 ret = PTR_ERR_OR_ZERO(hwmon);
355 if (ret)
356 goto error;
357
358 devres_close_group(dev, power_supply_add_hwmon_sysfs);
359 return 0;
360 error:
361 devres_release_group(dev, NULL);
362 return ret;
363 }
364
365 void power_supply_remove_hwmon_sysfs(struct power_supply *psy)
366 {
367 devres_release_group(&psy->dev, power_supply_add_hwmon_sysfs);
368 }