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