?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / power / supply / power_supply_sysfs.c
blob5358a80d854f99e0157a38bea979eb1b0912f46b
1 /*
2 * Sysfs interface for the universal power supply monitor class
3 *
4 * Copyright © 2007 David Woodhouse <dwmw2@infradead.org>
5 * Copyright © 2007 Anton Vorontsov <cbou@mail.ru>
6 * Copyright © 2004 Szabolcs Gyurko
7 * Copyright © 2003 Ian Molton <spyro@f2s.com>
8 *
9 * Modified: 2004, Oct Szabolcs Gyurko
10 *
11 * You may use this code as per GPL version 2
12 */
13
14 #include <linux/ctype.h>
15 #include <linux/device.h>
16 #include <linux/power_supply.h>
17 #include <linux/slab.h>
18 #include <linux/stat.h>
19
20 #include "power_supply.h"
21
22 /*
23 * This is because the name "current" breaks the device attr macro.
24 * The "current" word resolves to "(get_current())" so instead of
25 * "current" "(get_current())" appears in the sysfs.
26 *
27 * The source of this definition is the device.h which calls __ATTR
28 * macro in sysfs.h which calls the __stringify macro.
29 *
30 * Only modification that the name is not tried to be resolved
31 * (as a macro let's say).
32 */
33
34 #define POWER_SUPPLY_ATTR(_name) \
35 { \
36 .attr = { .name = #_name }, \
37 .show = power_supply_show_property, \
38 .store = power_supply_store_property, \
39 }
40
41 static struct device_attribute power_supply_attrs[];
42
43 static const char * const power_supply_type_text[] = {
44 "Unknown", "Battery", "UPS", "Mains", "USB",
45 "USB_DCP", "USB_CDP", "USB_ACA", "USB_C",
46 "USB_PD", "USB_PD_DRP", "BrickID"
47 };
48
49 static const char * const power_supply_usb_type_text[] = {
50 "Unknown", "SDP", "DCP", "CDP", "ACA", "C",
51 "PD", "PD_DRP", "PD_PPS", "BrickID"
52 };
53
54 static const char * const power_supply_status_text[] = {
55 "Unknown", "Charging", "Discharging", "Not charging", "Full"
56 };
57
58 static const char * const power_supply_charge_type_text[] = {
59 "Unknown", "N/A", "Trickle", "Fast"
60 };
61
62 static const char * const power_supply_health_text[] = {
63 "Unknown", "Good", "Overheat", "Dead", "Over voltage",
64 "Unspecified failure", "Cold", "Watchdog timer expire",
65 "Safety timer expire"
66 };
67
68 static const char * const power_supply_technology_text[] = {
69 "Unknown", "NiMH", "Li-ion", "Li-poly", "LiFe", "NiCd",
70 "LiMn"
71 };
72
73 static const char * const power_supply_capacity_level_text[] = {
74 "Unknown", "Critical", "Low", "Normal", "High", "Full"
75 };
76
77 static const char * const power_supply_scope_text[] = {
78 "Unknown", "System", "Device"
79 };
80
81 static ssize_t power_supply_show_usb_type(struct device *dev,
82 enum power_supply_usb_type *usb_types,
83 ssize_t num_usb_types,
84 union power_supply_propval *value,
85 char *buf)
86 {
87 enum power_supply_usb_type usb_type;
88 ssize_t count = 0;
89 bool match = false;
90 int i;
91
92 for (i = 0; i < num_usb_types; ++i) {
93 usb_type = usb_types[i];
94
95 if (value->intval == usb_type) {
96 count += sprintf(buf + count, "[%s] ",
97 power_supply_usb_type_text[usb_type]);
98 match = true;
99 } else {
100 count += sprintf(buf + count, "%s ",
101 power_supply_usb_type_text[usb_type]);
102 }
103 }
104
105 if (!match) {
106 dev_warn(dev, "driver reporting unsupported connected type\n");
107 return -EINVAL;
108 }
109
110 if (count)
111 buf[count - 1] = '\n';
112
113 return count;
114 }
115
116 static ssize_t power_supply_show_property(struct device *dev,
117 struct device_attribute *attr,
118 char *buf) {
119 ssize_t ret;
120 struct power_supply *psy = dev_get_drvdata(dev);
121 enum power_supply_property psp = attr - power_supply_attrs;
122 union power_supply_propval value;
123
124 if (psp == POWER_SUPPLY_PROP_TYPE) {
125 value.intval = psy->desc->type;
126 } else {
127 ret = power_supply_get_property(psy, psp, &value);
128
129 if (ret < 0) {
130 if (ret == -ENODATA)
131 dev_dbg(dev, "driver has no data for `%s' property\n",
132 attr->attr.name);
133 else if (ret != -ENODEV && ret != -EAGAIN)
134 dev_err_ratelimited(dev,
135 "driver failed to report `%s' property: %zd\n",
136 attr->attr.name, ret);
137 return ret;
138 }
139 }
140
141 switch (psp) {
142 case POWER_SUPPLY_PROP_STATUS:
143 ret = sprintf(buf, "%s\n",
144 power_supply_status_text[value.intval]);
145 break;
146 case POWER_SUPPLY_PROP_CHARGE_TYPE:
147 ret = sprintf(buf, "%s\n",
148 power_supply_charge_type_text[value.intval]);
149 break;
150 case POWER_SUPPLY_PROP_HEALTH:
151 ret = sprintf(buf, "%s\n",
152 power_supply_health_text[value.intval]);
153 break;
154 case POWER_SUPPLY_PROP_TECHNOLOGY:
155 ret = sprintf(buf, "%s\n",
156 power_supply_technology_text[value.intval]);
157 break;
158 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
159 ret = sprintf(buf, "%s\n",
160 power_supply_capacity_level_text[value.intval]);
161 break;
162 case POWER_SUPPLY_PROP_TYPE:
163 ret = sprintf(buf, "%s\n",
164 power_supply_type_text[value.intval]);
165 break;
166 case POWER_SUPPLY_PROP_USB_TYPE:
167 ret = power_supply_show_usb_type(dev, psy->desc->usb_types,
168 psy->desc->num_usb_types,
169 &value, buf);
170 break;
171 case POWER_SUPPLY_PROP_SCOPE:
172 ret = sprintf(buf, "%s\n",
173 power_supply_scope_text[value.intval]);
174 break;
175 case POWER_SUPPLY_PROP_MODEL_NAME ... POWER_SUPPLY_PROP_SERIAL_NUMBER:
176 ret = sprintf(buf, "%s\n", value.strval);
177 break;
178 default:
179 ret = sprintf(buf, "%d\n", value.intval);
180 }
181
182 return ret;
183 }
184
185 static ssize_t power_supply_store_property(struct device *dev,
186 struct device_attribute *attr,
187 const char *buf, size_t count) {
188 ssize_t ret;
189 struct power_supply *psy = dev_get_drvdata(dev);
190 enum power_supply_property psp = attr - power_supply_attrs;
191 union power_supply_propval value;
192
193 switch (psp) {
194 case POWER_SUPPLY_PROP_STATUS:
195 ret = sysfs_match_string(power_supply_status_text, buf);
196 break;
197 case POWER_SUPPLY_PROP_CHARGE_TYPE:
198 ret = sysfs_match_string(power_supply_charge_type_text, buf);
199 break;
200 case POWER_SUPPLY_PROP_HEALTH:
201 ret = sysfs_match_string(power_supply_health_text, buf);
202 break;
203 case POWER_SUPPLY_PROP_TECHNOLOGY:
204 ret = sysfs_match_string(power_supply_technology_text, buf);
205 break;
206 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
207 ret = sysfs_match_string(power_supply_capacity_level_text, buf);
208 break;
209 case POWER_SUPPLY_PROP_SCOPE:
210 ret = sysfs_match_string(power_supply_scope_text, buf);
211 break;
212 default:
213 ret = -EINVAL;
214 }
215
216 /*
217 * If no match was found, then check to see if it is an integer.
218 * Integer values are valid for enums in addition to the text value.
219 */
220 if (ret < 0) {
221 long long_val;
222
223 ret = kstrtol(buf, 10, &long_val);
224 if (ret < 0)
225 return ret;
226
227 ret = long_val;
228 }
229
230 value.intval = ret;
231
232 ret = power_supply_set_property(psy, psp, &value);
233 if (ret < 0)
234 return ret;
235
236 return count;
237 }
238
239 /* Must be in the same order as POWER_SUPPLY_PROP_* */
240 static struct device_attribute power_supply_attrs[] = {
241 /* Properties of type `int' */
242 POWER_SUPPLY_ATTR(status),
243 POWER_SUPPLY_ATTR(charge_type),
244 POWER_SUPPLY_ATTR(health),
245 POWER_SUPPLY_ATTR(present),
246 POWER_SUPPLY_ATTR(online),
247 POWER_SUPPLY_ATTR(authentic),
248 POWER_SUPPLY_ATTR(technology),
249 POWER_SUPPLY_ATTR(cycle_count),
250 POWER_SUPPLY_ATTR(voltage_max),
251 POWER_SUPPLY_ATTR(voltage_min),
252 POWER_SUPPLY_ATTR(voltage_max_design),
253 POWER_SUPPLY_ATTR(voltage_min_design),
254 POWER_SUPPLY_ATTR(voltage_now),
255 POWER_SUPPLY_ATTR(voltage_avg),
256 POWER_SUPPLY_ATTR(voltage_ocv),
257 POWER_SUPPLY_ATTR(voltage_boot),
258 POWER_SUPPLY_ATTR(current_max),
259 POWER_SUPPLY_ATTR(current_now),
260 POWER_SUPPLY_ATTR(current_avg),
261 POWER_SUPPLY_ATTR(current_boot),
262 POWER_SUPPLY_ATTR(power_now),
263 POWER_SUPPLY_ATTR(power_avg),
264 POWER_SUPPLY_ATTR(charge_full_design),
265 POWER_SUPPLY_ATTR(charge_empty_design),
266 POWER_SUPPLY_ATTR(charge_full),
267 POWER_SUPPLY_ATTR(charge_empty),
268 POWER_SUPPLY_ATTR(charge_now),
269 POWER_SUPPLY_ATTR(charge_avg),
270 POWER_SUPPLY_ATTR(charge_counter),
271 POWER_SUPPLY_ATTR(constant_charge_current),
272 POWER_SUPPLY_ATTR(constant_charge_current_max),
273 POWER_SUPPLY_ATTR(constant_charge_voltage),
274 POWER_SUPPLY_ATTR(constant_charge_voltage_max),
275 POWER_SUPPLY_ATTR(charge_control_limit),
276 POWER_SUPPLY_ATTR(charge_control_limit_max),
277 POWER_SUPPLY_ATTR(input_current_limit),
278 POWER_SUPPLY_ATTR(energy_full_design),
279 POWER_SUPPLY_ATTR(energy_empty_design),
280 POWER_SUPPLY_ATTR(energy_full),
281 POWER_SUPPLY_ATTR(energy_empty),
282 POWER_SUPPLY_ATTR(energy_now),
283 POWER_SUPPLY_ATTR(energy_avg),
284 POWER_SUPPLY_ATTR(capacity),
285 POWER_SUPPLY_ATTR(capacity_alert_min),
286 POWER_SUPPLY_ATTR(capacity_alert_max),
287 POWER_SUPPLY_ATTR(capacity_level),
288 POWER_SUPPLY_ATTR(temp),
289 POWER_SUPPLY_ATTR(temp_max),
290 POWER_SUPPLY_ATTR(temp_min),
291 POWER_SUPPLY_ATTR(temp_alert_min),
292 POWER_SUPPLY_ATTR(temp_alert_max),
293 POWER_SUPPLY_ATTR(temp_ambient),
294 POWER_SUPPLY_ATTR(temp_ambient_alert_min),
295 POWER_SUPPLY_ATTR(temp_ambient_alert_max),
296 POWER_SUPPLY_ATTR(time_to_empty_now),
297 POWER_SUPPLY_ATTR(time_to_empty_avg),
298 POWER_SUPPLY_ATTR(time_to_full_now),
299 POWER_SUPPLY_ATTR(time_to_full_avg),
300 POWER_SUPPLY_ATTR(type),
301 POWER_SUPPLY_ATTR(usb_type),
302 POWER_SUPPLY_ATTR(scope),
303 POWER_SUPPLY_ATTR(precharge_current),
304 POWER_SUPPLY_ATTR(charge_term_current),
305 POWER_SUPPLY_ATTR(calibrate),
306 /* Properties of type `const char *' */
307 POWER_SUPPLY_ATTR(model_name),
308 POWER_SUPPLY_ATTR(manufacturer),
309 POWER_SUPPLY_ATTR(serial_number),
310 };
311
312 static struct attribute *
313 __power_supply_attrs[ARRAY_SIZE(power_supply_attrs) + 1];
314
315 static umode_t power_supply_attr_is_visible(struct kobject *kobj,
316 struct attribute *attr,
317 int attrno)
318 {
319 struct device *dev = container_of(kobj, struct device, kobj);
320 struct power_supply *psy = dev_get_drvdata(dev);
321 umode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
322 int i;
323
324 if (attrno == POWER_SUPPLY_PROP_TYPE)
325 return mode;
326
327 for (i = 0; i < psy->desc->num_properties; i++) {
328 int property = psy->desc->properties[i];
329
330 if (property == attrno) {
331 if (psy->desc->property_is_writeable &&
332 psy->desc->property_is_writeable(psy, property) > 0)
333 mode |= S_IWUSR;
334
335 return mode;
336 }
337 }
338
339 return 0;
340 }
341
342 static struct attribute_group power_supply_attr_group = {
343 .attrs = __power_supply_attrs,
344 .is_visible = power_supply_attr_is_visible,
345 };
346
347 static const struct attribute_group *power_supply_attr_groups[] = {
348 &power_supply_attr_group,
349 NULL,
350 };
351
352 void power_supply_init_attrs(struct device_type *dev_type)
353 {
354 int i;
355
356 dev_type->groups = power_supply_attr_groups;
357
358 for (i = 0; i < ARRAY_SIZE(power_supply_attrs); i++)
359 __power_supply_attrs[i] = &power_supply_attrs[i].attr;
360 }
361
362 static char *kstruprdup(const char *str, gfp_t gfp)
363 {
364 char *ret, *ustr;
365
366 ustr = ret = kmalloc(strlen(str) + 1, gfp);
367
368 if (!ret)
369 return NULL;
370
371 while (*str)
372 *ustr++ = toupper(*str++);
373
374 *ustr = 0;
375
376 return ret;
377 }
378
379 int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
380 {
381 struct power_supply *psy = dev_get_drvdata(dev);
382 int ret = 0, j;
383 char *prop_buf;
384 char *attrname;
385
386 if (!psy || !psy->desc) {
387 dev_dbg(dev, "No power supply yet\n");
388 return ret;
389 }
390
391 ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->desc->name);
392 if (ret)
393 return ret;
394
395 prop_buf = (char *)get_zeroed_page(GFP_KERNEL);
396 if (!prop_buf)
397 return -ENOMEM;
398
399 for (j = 0; j < psy->desc->num_properties; j++) {
400 struct device_attribute *attr;
401 char *line;
402
403 attr = &power_supply_attrs[psy->desc->properties[j]];
404
405 ret = power_supply_show_property(dev, attr, prop_buf);
406 if (ret == -ENODEV || ret == -ENODATA) {
407 /* When a battery is absent, we expect -ENODEV. Don't abort;
408 send the uevent with at least the the PRESENT=0 property */
409 ret = 0;
410 continue;
411 }
412
413 if (ret < 0)
414 goto out;
415
416 line = strchr(prop_buf, '\n');
417 if (line)
418 *line = 0;
419
420 attrname = kstruprdup(attr->attr.name, GFP_KERNEL);
421 if (!attrname) {
422 ret = -ENOMEM;
423 goto out;
424 }
425
426 ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
427 kfree(attrname);
428 if (ret)
429 goto out;
430 }
431
432 out:
433 free_page((unsigned long)prop_buf);
434
435 return ret;
436 }
Linux with added FPC-III support