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> | |
15 | #include <linux/power_supply.h> | |
16 | ||
25f12141 AB |
17 | #include "power_supply.h" |
18 | ||
4a11b59d AV |
19 | /* |
20 | * This is because the name "current" breaks the device attr macro. | |
21 | * The "current" word resolves to "(get_current())" so instead of | |
22 | * "current" "(get_current())" appears in the sysfs. | |
23 | * | |
24 | * The source of this definition is the device.h which calls __ATTR | |
25 | * macro in sysfs.h which calls the __stringify macro. | |
26 | * | |
27 | * Only modification that the name is not tried to be resolved | |
28 | * (as a macro let's say). | |
29 | */ | |
30 | ||
31 | #define POWER_SUPPLY_ATTR(_name) \ | |
32 | { \ | |
01e8ef11 | 33 | .attr = { .name = #_name, .mode = 0444 }, \ |
4a11b59d AV |
34 | .show = power_supply_show_property, \ |
35 | .store = NULL, \ | |
36 | } | |
37 | ||
38 | static struct device_attribute power_supply_attrs[]; | |
39 | ||
40 | static ssize_t power_supply_show_property(struct device *dev, | |
41 | struct device_attribute *attr, | |
42 | char *buf) { | |
43 | static char *status_text[] = { | |
44 | "Unknown", "Charging", "Discharging", "Not charging", "Full" | |
45 | }; | |
46 | static char *health_text[] = { | |
47 | "Unknown", "Good", "Overheat", "Dead", "Over voltage", | |
7e386e6e | 48 | "Unspecified failure", "Cold", |
4a11b59d AV |
49 | }; |
50 | static char *technology_text[] = { | |
c7cc930f DB |
51 | "Unknown", "NiMH", "Li-ion", "Li-poly", "LiFe", "NiCd", |
52 | "LiMn" | |
4a11b59d | 53 | }; |
4a11b59d AV |
54 | ssize_t ret; |
55 | struct power_supply *psy = dev_get_drvdata(dev); | |
56 | const ptrdiff_t off = attr - power_supply_attrs; | |
57 | union power_supply_propval value; | |
58 | ||
59 | ret = psy->get_property(psy, off, &value); | |
60 | ||
61 | if (ret < 0) { | |
62 | if (ret != -ENODEV) | |
63 | dev_err(dev, "driver failed to report `%s' property\n", | |
64 | attr->attr.name); | |
65 | return ret; | |
66 | } | |
67 | ||
68 | if (off == POWER_SUPPLY_PROP_STATUS) | |
69 | return sprintf(buf, "%s\n", status_text[value.intval]); | |
70 | else if (off == POWER_SUPPLY_PROP_HEALTH) | |
71 | return sprintf(buf, "%s\n", health_text[value.intval]); | |
72 | else if (off == POWER_SUPPLY_PROP_TECHNOLOGY) | |
73 | return sprintf(buf, "%s\n", technology_text[value.intval]); | |
4a11b59d AV |
74 | else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) |
75 | return sprintf(buf, "%s\n", value.strval); | |
76 | ||
77 | return sprintf(buf, "%d\n", value.intval); | |
78 | } | |
79 | ||
80 | /* Must be in the same order as POWER_SUPPLY_PROP_* */ | |
81 | static struct device_attribute power_supply_attrs[] = { | |
82 | /* Properties of type `int' */ | |
83 | POWER_SUPPLY_ATTR(status), | |
84 | POWER_SUPPLY_ATTR(health), | |
85 | POWER_SUPPLY_ATTR(present), | |
86 | POWER_SUPPLY_ATTR(online), | |
87 | POWER_SUPPLY_ATTR(technology), | |
c7cc930f DB |
88 | POWER_SUPPLY_ATTR(voltage_max), |
89 | POWER_SUPPLY_ATTR(voltage_min), | |
4a11b59d AV |
90 | POWER_SUPPLY_ATTR(voltage_max_design), |
91 | POWER_SUPPLY_ATTR(voltage_min_design), | |
92 | POWER_SUPPLY_ATTR(voltage_now), | |
93 | POWER_SUPPLY_ATTR(voltage_avg), | |
94 | POWER_SUPPLY_ATTR(current_now), | |
95 | POWER_SUPPLY_ATTR(current_avg), | |
7faa144a AS |
96 | POWER_SUPPLY_ATTR(power_now), |
97 | POWER_SUPPLY_ATTR(power_avg), | |
4a11b59d AV |
98 | POWER_SUPPLY_ATTR(charge_full_design), |
99 | POWER_SUPPLY_ATTR(charge_empty_design), | |
100 | POWER_SUPPLY_ATTR(charge_full), | |
101 | POWER_SUPPLY_ATTR(charge_empty), | |
102 | POWER_SUPPLY_ATTR(charge_now), | |
103 | POWER_SUPPLY_ATTR(charge_avg), | |
8e552c36 | 104 | POWER_SUPPLY_ATTR(charge_counter), |
4a11b59d AV |
105 | POWER_SUPPLY_ATTR(energy_full_design), |
106 | POWER_SUPPLY_ATTR(energy_empty_design), | |
107 | POWER_SUPPLY_ATTR(energy_full), | |
108 | POWER_SUPPLY_ATTR(energy_empty), | |
109 | POWER_SUPPLY_ATTR(energy_now), | |
110 | POWER_SUPPLY_ATTR(energy_avg), | |
111 | POWER_SUPPLY_ATTR(capacity), | |
4a11b59d AV |
112 | POWER_SUPPLY_ATTR(temp), |
113 | POWER_SUPPLY_ATTR(temp_ambient), | |
114 | POWER_SUPPLY_ATTR(time_to_empty_now), | |
115 | POWER_SUPPLY_ATTR(time_to_empty_avg), | |
116 | POWER_SUPPLY_ATTR(time_to_full_now), | |
117 | POWER_SUPPLY_ATTR(time_to_full_avg), | |
118 | /* Properties of type `const char *' */ | |
119 | POWER_SUPPLY_ATTR(model_name), | |
120 | POWER_SUPPLY_ATTR(manufacturer), | |
7c2670bb | 121 | POWER_SUPPLY_ATTR(serial_number), |
4a11b59d AV |
122 | }; |
123 | ||
124 | static ssize_t power_supply_show_static_attrs(struct device *dev, | |
125 | struct device_attribute *attr, | |
126 | char *buf) { | |
127 | static char *type_text[] = { "Battery", "UPS", "Mains", "USB" }; | |
128 | struct power_supply *psy = dev_get_drvdata(dev); | |
129 | ||
130 | return sprintf(buf, "%s\n", type_text[psy->type]); | |
131 | } | |
132 | ||
133 | static struct device_attribute power_supply_static_attrs[] = { | |
134 | __ATTR(type, 0444, power_supply_show_static_attrs, NULL), | |
135 | }; | |
136 | ||
137 | int power_supply_create_attrs(struct power_supply *psy) | |
138 | { | |
139 | int rc = 0; | |
140 | int i, j; | |
141 | ||
142 | for (i = 0; i < ARRAY_SIZE(power_supply_static_attrs); i++) { | |
143 | rc = device_create_file(psy->dev, | |
144 | &power_supply_static_attrs[i]); | |
145 | if (rc) | |
146 | goto statics_failed; | |
147 | } | |
148 | ||
149 | for (j = 0; j < psy->num_properties; j++) { | |
150 | rc = device_create_file(psy->dev, | |
151 | &power_supply_attrs[psy->properties[j]]); | |
152 | if (rc) | |
153 | goto dynamics_failed; | |
154 | } | |
155 | ||
156 | goto succeed; | |
157 | ||
158 | dynamics_failed: | |
159 | while (j--) | |
160 | device_remove_file(psy->dev, | |
161 | &power_supply_attrs[psy->properties[j]]); | |
162 | statics_failed: | |
163 | while (i--) | |
839dc9f1 | 164 | device_remove_file(psy->dev, &power_supply_static_attrs[i]); |
4a11b59d AV |
165 | succeed: |
166 | return rc; | |
167 | } | |
168 | ||
169 | void power_supply_remove_attrs(struct power_supply *psy) | |
170 | { | |
171 | int i; | |
172 | ||
173 | for (i = 0; i < ARRAY_SIZE(power_supply_static_attrs); i++) | |
839dc9f1 | 174 | device_remove_file(psy->dev, &power_supply_static_attrs[i]); |
4a11b59d AV |
175 | |
176 | for (i = 0; i < psy->num_properties; i++) | |
177 | device_remove_file(psy->dev, | |
178 | &power_supply_attrs[psy->properties[i]]); | |
4a11b59d AV |
179 | } |
180 | ||
181 | static char *kstruprdup(const char *str, gfp_t gfp) | |
182 | { | |
183 | char *ret, *ustr; | |
184 | ||
185 | ustr = ret = kmalloc(strlen(str) + 1, gfp); | |
186 | ||
187 | if (!ret) | |
188 | return NULL; | |
189 | ||
190 | while (*str) | |
191 | *ustr++ = toupper(*str++); | |
192 | ||
193 | *ustr = 0; | |
194 | ||
195 | return ret; | |
196 | } | |
197 | ||
7eff2e7a | 198 | int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env) |
4a11b59d AV |
199 | { |
200 | struct power_supply *psy = dev_get_drvdata(dev); | |
7eff2e7a | 201 | int ret = 0, j; |
4a11b59d AV |
202 | char *prop_buf; |
203 | char *attrname; | |
204 | ||
205 | dev_dbg(dev, "uevent\n"); | |
206 | ||
56fa18e8 | 207 | if (!psy || !psy->dev) { |
4a11b59d AV |
208 | dev_dbg(dev, "No power supply yet\n"); |
209 | return ret; | |
210 | } | |
211 | ||
212 | dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->name); | |
213 | ||
7eff2e7a | 214 | ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name); |
4a11b59d AV |
215 | if (ret) |
216 | return ret; | |
217 | ||
218 | prop_buf = (char *)get_zeroed_page(GFP_KERNEL); | |
219 | if (!prop_buf) | |
220 | return -ENOMEM; | |
221 | ||
222 | for (j = 0; j < ARRAY_SIZE(power_supply_static_attrs); j++) { | |
223 | struct device_attribute *attr; | |
224 | char *line; | |
225 | ||
226 | attr = &power_supply_static_attrs[j]; | |
227 | ||
228 | ret = power_supply_show_static_attrs(dev, attr, prop_buf); | |
229 | if (ret < 0) | |
230 | goto out; | |
231 | ||
232 | line = strchr(prop_buf, '\n'); | |
233 | if (line) | |
234 | *line = 0; | |
235 | ||
236 | attrname = kstruprdup(attr->attr.name, GFP_KERNEL); | |
237 | if (!attrname) { | |
238 | ret = -ENOMEM; | |
239 | goto out; | |
240 | } | |
241 | ||
242 | dev_dbg(dev, "Static prop %s=%s\n", attrname, prop_buf); | |
243 | ||
7eff2e7a | 244 | ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf); |
4a11b59d AV |
245 | kfree(attrname); |
246 | if (ret) | |
247 | goto out; | |
248 | } | |
249 | ||
250 | dev_dbg(dev, "%zd dynamic props\n", psy->num_properties); | |
251 | ||
252 | for (j = 0; j < psy->num_properties; j++) { | |
253 | struct device_attribute *attr; | |
254 | char *line; | |
255 | ||
256 | attr = &power_supply_attrs[psy->properties[j]]; | |
257 | ||
258 | ret = power_supply_show_property(dev, attr, prop_buf); | |
259 | if (ret == -ENODEV) { | |
260 | /* When a battery is absent, we expect -ENODEV. Don't abort; | |
261 | send the uevent with at least the the PRESENT=0 property */ | |
262 | ret = 0; | |
263 | continue; | |
264 | } | |
265 | ||
266 | if (ret < 0) | |
267 | goto out; | |
268 | ||
269 | line = strchr(prop_buf, '\n'); | |
270 | if (line) | |
271 | *line = 0; | |
272 | ||
273 | attrname = kstruprdup(attr->attr.name, GFP_KERNEL); | |
274 | if (!attrname) { | |
275 | ret = -ENOMEM; | |
276 | goto out; | |
277 | } | |
278 | ||
279 | dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf); | |
280 | ||
7eff2e7a | 281 | ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf); |
4a11b59d AV |
282 | kfree(attrname); |
283 | if (ret) | |
284 | goto out; | |
285 | } | |
286 | ||
287 | out: | |
288 | free_page((unsigned long)prop_buf); | |
289 | ||
290 | return ret; | |
291 | } |