Commit | Line | Data |
---|---|---|
4a11b59d AV |
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> | |
51990e82 | 15 | #include <linux/device.h> |
4a11b59d | 16 | #include <linux/power_supply.h> |
5a0e3ad6 | 17 | #include <linux/slab.h> |
778f523d | 18 | #include <linux/stat.h> |
4a11b59d | 19 | |
25f12141 AB |
20 | #include "power_supply.h" |
21 | ||
4a11b59d AV |
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 | { \ | |
5f487cd3 | 36 | .attr = { .name = #_name }, \ |
4a11b59d | 37 | .show = power_supply_show_property, \ |
0011d2d4 | 38 | .store = power_supply_store_property, \ |
4a11b59d AV |
39 | } |
40 | ||
41 | static struct device_attribute power_supply_attrs[]; | |
42 | ||
43 | static ssize_t power_supply_show_property(struct device *dev, | |
44 | struct device_attribute *attr, | |
45 | char *buf) { | |
5f487cd3 | 46 | static char *type_text[] = { |
9b887227 | 47 | "Unknown", "Battery", "UPS", "Mains", "USB", |
6fa3eb70 | 48 | "USB_DCP", "USB_CDP", "USB_ACA", "Wireless" |
5f487cd3 | 49 | }; |
4a11b59d | 50 | static char *status_text[] = { |
6fa3eb70 | 51 | "Unknown", "Charging", "Discharging", "Not charging", "Full", "Cmd discharging" |
4a11b59d | 52 | }; |
ee8076ed AS |
53 | static char *charge_type[] = { |
54 | "Unknown", "N/A", "Trickle", "Fast" | |
55 | }; | |
4a11b59d AV |
56 | static char *health_text[] = { |
57 | "Unknown", "Good", "Overheat", "Dead", "Over voltage", | |
a05be991 RP |
58 | "Unspecified failure", "Cold", "Watchdog timer expire", |
59 | "Safety timer expire" | |
4a11b59d AV |
60 | }; |
61 | static char *technology_text[] = { | |
c7cc930f DES |
62 | "Unknown", "NiMH", "Li-ion", "Li-poly", "LiFe", "NiCd", |
63 | "LiMn" | |
4a11b59d | 64 | }; |
b294a290 AS |
65 | static char *capacity_level_text[] = { |
66 | "Unknown", "Critical", "Low", "Normal", "High", "Full" | |
67 | }; | |
25a0bc2d JF |
68 | static char *scope_text[] = { |
69 | "Unknown", "System", "Device" | |
70 | }; | |
5f487cd3 | 71 | ssize_t ret = 0; |
4a11b59d AV |
72 | struct power_supply *psy = dev_get_drvdata(dev); |
73 | const ptrdiff_t off = attr - power_supply_attrs; | |
74 | union power_supply_propval value; | |
75 | ||
5f487cd3 AV |
76 | if (off == POWER_SUPPLY_PROP_TYPE) |
77 | value.intval = psy->type; | |
78 | else | |
79 | ret = psy->get_property(psy, off, &value); | |
4a11b59d AV |
80 | |
81 | if (ret < 0) { | |
9d233e8b AV |
82 | if (ret == -ENODATA) |
83 | dev_dbg(dev, "driver has no data for `%s' property\n", | |
84 | attr->attr.name); | |
85 | else if (ret != -ENODEV) | |
85b5fbf7 | 86 | dev_err(dev, "driver failed to report `%s' property: %zd\n", |
35c3ae5e | 87 | attr->attr.name, ret); |
4a11b59d AV |
88 | return ret; |
89 | } | |
90 | ||
91 | if (off == POWER_SUPPLY_PROP_STATUS) | |
92 | return sprintf(buf, "%s\n", status_text[value.intval]); | |
ee8076ed AS |
93 | else if (off == POWER_SUPPLY_PROP_CHARGE_TYPE) |
94 | return sprintf(buf, "%s\n", charge_type[value.intval]); | |
4a11b59d AV |
95 | else if (off == POWER_SUPPLY_PROP_HEALTH) |
96 | return sprintf(buf, "%s\n", health_text[value.intval]); | |
97 | else if (off == POWER_SUPPLY_PROP_TECHNOLOGY) | |
98 | return sprintf(buf, "%s\n", technology_text[value.intval]); | |
b294a290 AS |
99 | else if (off == POWER_SUPPLY_PROP_CAPACITY_LEVEL) |
100 | return sprintf(buf, "%s\n", capacity_level_text[value.intval]); | |
5f487cd3 AV |
101 | else if (off == POWER_SUPPLY_PROP_TYPE) |
102 | return sprintf(buf, "%s\n", type_text[value.intval]); | |
25a0bc2d JF |
103 | else if (off == POWER_SUPPLY_PROP_SCOPE) |
104 | return sprintf(buf, "%s\n", scope_text[value.intval]); | |
4a11b59d AV |
105 | else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) |
106 | return sprintf(buf, "%s\n", value.strval); | |
6fa3eb70 S |
107 | else if (off == POWER_SUPPLY_PROP_status_smb) |
108 | return sprintf(buf, "%s\n", status_text[value.intval]); | |
4a11b59d | 109 | |
6fa3eb70 S |
110 | if (off == POWER_SUPPLY_PROP_CHARGE_COUNTER_EXT) |
111 | return sprintf(buf, "%lld\n", value.int64val); | |
557d9dfd S |
112 | else if (off == POWER_SUPPLY_PROP_batt_vol) |
113 | return sprintf(buf, "%d\n", (value.intval * 1000)); | |
6fa3eb70 S |
114 | else |
115 | return sprintf(buf, "%d\n", value.intval); | |
4a11b59d AV |
116 | } |
117 | ||
0011d2d4 DM |
118 | static ssize_t power_supply_store_property(struct device *dev, |
119 | struct device_attribute *attr, | |
120 | const char *buf, size_t count) { | |
121 | ssize_t ret; | |
122 | struct power_supply *psy = dev_get_drvdata(dev); | |
123 | const ptrdiff_t off = attr - power_supply_attrs; | |
124 | union power_supply_propval value; | |
125 | long long_val; | |
126 | ||
127 | /* TODO: support other types than int */ | |
128 | ret = strict_strtol(buf, 10, &long_val); | |
129 | if (ret < 0) | |
130 | return ret; | |
131 | ||
132 | value.intval = long_val; | |
133 | ||
134 | ret = psy->set_property(psy, off, &value); | |
135 | if (ret < 0) | |
136 | return ret; | |
137 | ||
138 | return count; | |
139 | } | |
140 | ||
4a11b59d AV |
141 | /* Must be in the same order as POWER_SUPPLY_PROP_* */ |
142 | static struct device_attribute power_supply_attrs[] = { | |
143 | /* Properties of type `int' */ | |
144 | POWER_SUPPLY_ATTR(status), | |
ee8076ed | 145 | POWER_SUPPLY_ATTR(charge_type), |
4a11b59d AV |
146 | POWER_SUPPLY_ATTR(health), |
147 | POWER_SUPPLY_ATTR(present), | |
148 | POWER_SUPPLY_ATTR(online), | |
b1b56872 | 149 | POWER_SUPPLY_ATTR(authentic), |
4a11b59d | 150 | POWER_SUPPLY_ATTR(technology), |
c955fe8e | 151 | POWER_SUPPLY_ATTR(cycle_count), |
c7cc930f DES |
152 | POWER_SUPPLY_ATTR(voltage_max), |
153 | POWER_SUPPLY_ATTR(voltage_min), | |
4a11b59d AV |
154 | POWER_SUPPLY_ATTR(voltage_max_design), |
155 | POWER_SUPPLY_ATTR(voltage_min_design), | |
156 | POWER_SUPPLY_ATTR(voltage_now), | |
157 | POWER_SUPPLY_ATTR(voltage_avg), | |
a2ebfe2f | 158 | POWER_SUPPLY_ATTR(voltage_ocv), |
fe3f6d09 | 159 | POWER_SUPPLY_ATTR(current_max), |
4a11b59d AV |
160 | POWER_SUPPLY_ATTR(current_now), |
161 | POWER_SUPPLY_ATTR(current_avg), | |
7faa144a AS |
162 | POWER_SUPPLY_ATTR(power_now), |
163 | POWER_SUPPLY_ATTR(power_avg), | |
4a11b59d AV |
164 | POWER_SUPPLY_ATTR(charge_full_design), |
165 | POWER_SUPPLY_ATTR(charge_empty_design), | |
166 | POWER_SUPPLY_ATTR(charge_full), | |
167 | POWER_SUPPLY_ATTR(charge_empty), | |
168 | POWER_SUPPLY_ATTR(charge_now), | |
169 | POWER_SUPPLY_ATTR(charge_avg), | |
8e552c36 | 170 | POWER_SUPPLY_ATTR(charge_counter), |
3824c477 | 171 | POWER_SUPPLY_ATTR(constant_charge_current), |
2815b786 | 172 | POWER_SUPPLY_ATTR(constant_charge_current_max), |
3824c477 | 173 | POWER_SUPPLY_ATTR(constant_charge_voltage), |
2815b786 | 174 | POWER_SUPPLY_ATTR(constant_charge_voltage_max), |
ea2ce92e RP |
175 | POWER_SUPPLY_ATTR(charge_control_limit), |
176 | POWER_SUPPLY_ATTR(charge_control_limit_max), | |
4a11b59d AV |
177 | POWER_SUPPLY_ATTR(energy_full_design), |
178 | POWER_SUPPLY_ATTR(energy_empty_design), | |
179 | POWER_SUPPLY_ATTR(energy_full), | |
180 | POWER_SUPPLY_ATTR(energy_empty), | |
181 | POWER_SUPPLY_ATTR(energy_now), | |
182 | POWER_SUPPLY_ATTR(energy_avg), | |
183 | POWER_SUPPLY_ATTR(capacity), | |
e908c418 RP |
184 | POWER_SUPPLY_ATTR(capacity_alert_min), |
185 | POWER_SUPPLY_ATTR(capacity_alert_max), | |
b294a290 | 186 | POWER_SUPPLY_ATTR(capacity_level), |
4a11b59d | 187 | POWER_SUPPLY_ATTR(temp), |
e908c418 RP |
188 | POWER_SUPPLY_ATTR(temp_alert_min), |
189 | POWER_SUPPLY_ATTR(temp_alert_max), | |
4a11b59d | 190 | POWER_SUPPLY_ATTR(temp_ambient), |
e908c418 RP |
191 | POWER_SUPPLY_ATTR(temp_ambient_alert_min), |
192 | POWER_SUPPLY_ATTR(temp_ambient_alert_max), | |
4a11b59d AV |
193 | POWER_SUPPLY_ATTR(time_to_empty_now), |
194 | POWER_SUPPLY_ATTR(time_to_empty_avg), | |
195 | POWER_SUPPLY_ATTR(time_to_full_now), | |
196 | POWER_SUPPLY_ATTR(time_to_full_avg), | |
5f487cd3 | 197 | POWER_SUPPLY_ATTR(type), |
25a0bc2d | 198 | POWER_SUPPLY_ATTR(scope), |
6fa3eb70 S |
199 | /* Local extensions */ |
200 | POWER_SUPPLY_ATTR(usb_hc), | |
201 | POWER_SUPPLY_ATTR(usb_otg), | |
202 | POWER_SUPPLY_ATTR(charge_enabled), | |
203 | /* Local extensions of type int64_t */ | |
204 | POWER_SUPPLY_ATTR(charge_counter_ext), | |
205 | /* 20100723 James Lo */ | |
206 | POWER_SUPPLY_ATTR(batt_vol), | |
207 | POWER_SUPPLY_ATTR(batt_temp), | |
208 | /* 20100405 Add for EM */ | |
209 | POWER_SUPPLY_ATTR(TemperatureR), | |
210 | POWER_SUPPLY_ATTR(TempBattVoltage), | |
211 | POWER_SUPPLY_ATTR(InstatVolt), | |
212 | POWER_SUPPLY_ATTR(BatteryAverageCurrent), | |
213 | POWER_SUPPLY_ATTR(BatterySenseVoltage), | |
214 | POWER_SUPPLY_ATTR(ISenseVoltage), | |
215 | POWER_SUPPLY_ATTR(ChargerVoltage), | |
216 | /* Dual battery */ | |
217 | POWER_SUPPLY_ATTR(status_smb), | |
218 | POWER_SUPPLY_ATTR(capacity_smb), | |
219 | POWER_SUPPLY_ATTR(present_smb), | |
220 | /* ADB CMD Discharging */ | |
221 | POWER_SUPPLY_ATTR(adjust_power), | |
4a11b59d AV |
222 | /* Properties of type `const char *' */ |
223 | POWER_SUPPLY_ATTR(model_name), | |
224 | POWER_SUPPLY_ATTR(manufacturer), | |
7c2670bb | 225 | POWER_SUPPLY_ATTR(serial_number), |
4a11b59d AV |
226 | }; |
227 | ||
5f487cd3 AV |
228 | static struct attribute * |
229 | __power_supply_attrs[ARRAY_SIZE(power_supply_attrs) + 1]; | |
4a11b59d | 230 | |
587a1f16 | 231 | static umode_t power_supply_attr_is_visible(struct kobject *kobj, |
5f487cd3 AV |
232 | struct attribute *attr, |
233 | int attrno) | |
4a11b59d | 234 | { |
5f487cd3 AV |
235 | struct device *dev = container_of(kobj, struct device, kobj); |
236 | struct power_supply *psy = dev_get_drvdata(dev); | |
587a1f16 | 237 | umode_t mode = S_IRUSR | S_IRGRP | S_IROTH; |
5f487cd3 | 238 | int i; |
4a11b59d | 239 | |
bbabb158 DM |
240 | if (attrno == POWER_SUPPLY_PROP_TYPE) |
241 | return mode; | |
242 | ||
5f487cd3 | 243 | for (i = 0; i < psy->num_properties; i++) { |
0011d2d4 DM |
244 | int property = psy->properties[i]; |
245 | ||
246 | if (property == attrno) { | |
0011d2d4 DM |
247 | if (psy->property_is_writeable && |
248 | psy->property_is_writeable(psy, property) > 0) | |
249 | mode |= S_IWUSR; | |
250 | ||
251 | return mode; | |
252 | } | |
4a11b59d AV |
253 | } |
254 | ||
5f487cd3 | 255 | return 0; |
4a11b59d AV |
256 | } |
257 | ||
5f487cd3 AV |
258 | static struct attribute_group power_supply_attr_group = { |
259 | .attrs = __power_supply_attrs, | |
260 | .is_visible = power_supply_attr_is_visible, | |
261 | }; | |
262 | ||
263 | static const struct attribute_group *power_supply_attr_groups[] = { | |
264 | &power_supply_attr_group, | |
265 | NULL, | |
266 | }; | |
267 | ||
268 | void power_supply_init_attrs(struct device_type *dev_type) | |
4a11b59d AV |
269 | { |
270 | int i; | |
271 | ||
5f487cd3 | 272 | dev_type->groups = power_supply_attr_groups; |
4a11b59d | 273 | |
5f487cd3 AV |
274 | for (i = 0; i < ARRAY_SIZE(power_supply_attrs); i++) |
275 | __power_supply_attrs[i] = &power_supply_attrs[i].attr; | |
4a11b59d AV |
276 | } |
277 | ||
278 | static char *kstruprdup(const char *str, gfp_t gfp) | |
279 | { | |
280 | char *ret, *ustr; | |
281 | ||
282 | ustr = ret = kmalloc(strlen(str) + 1, gfp); | |
283 | ||
284 | if (!ret) | |
285 | return NULL; | |
286 | ||
287 | while (*str) | |
288 | *ustr++ = toupper(*str++); | |
289 | ||
290 | *ustr = 0; | |
291 | ||
292 | return ret; | |
293 | } | |
294 | ||
7eff2e7a | 295 | int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env) |
4a11b59d AV |
296 | { |
297 | struct power_supply *psy = dev_get_drvdata(dev); | |
7eff2e7a | 298 | int ret = 0, j; |
4a11b59d AV |
299 | char *prop_buf; |
300 | char *attrname; | |
301 | ||
302 | dev_dbg(dev, "uevent\n"); | |
303 | ||
56fa18e8 | 304 | if (!psy || !psy->dev) { |
4a11b59d AV |
305 | dev_dbg(dev, "No power supply yet\n"); |
306 | return ret; | |
307 | } | |
308 | ||
309 | dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->name); | |
310 | ||
7eff2e7a | 311 | ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name); |
4a11b59d AV |
312 | if (ret) |
313 | return ret; | |
314 | ||
315 | prop_buf = (char *)get_zeroed_page(GFP_KERNEL); | |
316 | if (!prop_buf) | |
317 | return -ENOMEM; | |
318 | ||
4a11b59d AV |
319 | for (j = 0; j < psy->num_properties; j++) { |
320 | struct device_attribute *attr; | |
321 | char *line; | |
322 | ||
323 | attr = &power_supply_attrs[psy->properties[j]]; | |
324 | ||
325 | ret = power_supply_show_property(dev, attr, prop_buf); | |
f722e17f | 326 | if (ret == -ENODEV || ret == -ENODATA) { |
4a11b59d AV |
327 | /* When a battery is absent, we expect -ENODEV. Don't abort; |
328 | send the uevent with at least the the PRESENT=0 property */ | |
329 | ret = 0; | |
330 | continue; | |
331 | } | |
332 | ||
333 | if (ret < 0) | |
334 | goto out; | |
335 | ||
336 | line = strchr(prop_buf, '\n'); | |
337 | if (line) | |
338 | *line = 0; | |
339 | ||
340 | attrname = kstruprdup(attr->attr.name, GFP_KERNEL); | |
341 | if (!attrname) { | |
342 | ret = -ENOMEM; | |
343 | goto out; | |
344 | } | |
345 | ||
346 | dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf); | |
347 | ||
7eff2e7a | 348 | ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf); |
4a11b59d AV |
349 | kfree(attrname); |
350 | if (ret) | |
351 | goto out; | |
352 | } | |
353 | ||
354 | out: | |
355 | free_page((unsigned long)prop_buf); | |
356 | ||
357 | return ret; | |
358 | } |