Commit | Line | Data |
---|---|---|
fb972873 DW |
1 | /* |
2 | * Battery driver for One Laptop Per Child board. | |
3 | * | |
690e85a3 | 4 | * Copyright © 2006-2010 David Woodhouse <dwmw2@infradead.org> |
fb972873 DW |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | */ | |
10 | ||
04a820ea | 11 | #include <linux/kernel.h> |
fb972873 | 12 | #include <linux/module.h> |
144bbeae | 13 | #include <linux/types.h> |
fb972873 | 14 | #include <linux/err.h> |
144bbeae | 15 | #include <linux/device.h> |
fb972873 DW |
16 | #include <linux/platform_device.h> |
17 | #include <linux/power_supply.h> | |
18 | #include <linux/jiffies.h> | |
19 | #include <linux/sched.h> | |
3bf9428f | 20 | #include <linux/olpc-ec.h> |
fb972873 DW |
21 | #include <asm/olpc.h> |
22 | ||
23 | ||
24 | #define EC_BAT_VOLTAGE 0x10 /* uint16_t, *9.76/32, mV */ | |
25 | #define EC_BAT_CURRENT 0x11 /* int16_t, *15.625/120, mA */ | |
75d88079 | 26 | #define EC_BAT_ACR 0x12 /* int16_t, *6250/15, µAh */ |
fb972873 DW |
27 | #define EC_BAT_TEMP 0x13 /* uint16_t, *100/256, °C */ |
28 | #define EC_AMB_TEMP 0x14 /* uint16_t, *100/256, °C */ | |
29 | #define EC_BAT_STATUS 0x15 /* uint8_t, bitmask */ | |
30 | #define EC_BAT_SOC 0x16 /* uint8_t, percentage */ | |
31 | #define EC_BAT_SERIAL 0x17 /* uint8_t[6] */ | |
32 | #define EC_BAT_EEPROM 0x18 /* uint8_t adr as input, uint8_t output */ | |
33 | #define EC_BAT_ERRCODE 0x1f /* uint8_t, bitmask */ | |
34 | ||
35 | #define BAT_STAT_PRESENT 0x01 | |
36 | #define BAT_STAT_FULL 0x02 | |
37 | #define BAT_STAT_LOW 0x04 | |
38 | #define BAT_STAT_DESTROY 0x08 | |
39 | #define BAT_STAT_AC 0x10 | |
40 | #define BAT_STAT_CHARGING 0x20 | |
41 | #define BAT_STAT_DISCHARGING 0x40 | |
8f7e5798 | 42 | #define BAT_STAT_TRICKLE 0x80 |
fb972873 DW |
43 | |
44 | #define BAT_ERR_INFOFAIL 0x02 | |
45 | #define BAT_ERR_OVERVOLTAGE 0x04 | |
46 | #define BAT_ERR_OVERTEMP 0x05 | |
47 | #define BAT_ERR_GAUGESTOP 0x06 | |
48 | #define BAT_ERR_OUT_OF_CONTROL 0x07 | |
49 | #define BAT_ERR_ID_FAIL 0x09 | |
50 | #define BAT_ERR_ACR_FAIL 0x10 | |
51 | ||
52 | #define BAT_ADDR_MFR_TYPE 0x5F | |
53 | ||
54 | /********************************************************************* | |
55 | * Power | |
56 | *********************************************************************/ | |
57 | ||
58 | static int olpc_ac_get_prop(struct power_supply *psy, | |
59 | enum power_supply_property psp, | |
60 | union power_supply_propval *val) | |
61 | { | |
62 | int ret = 0; | |
63 | uint8_t status; | |
64 | ||
65 | switch (psp) { | |
66 | case POWER_SUPPLY_PROP_ONLINE: | |
67 | ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1); | |
68 | if (ret) | |
69 | return ret; | |
70 | ||
71 | val->intval = !!(status & BAT_STAT_AC); | |
72 | break; | |
73 | default: | |
74 | ret = -EINVAL; | |
75 | break; | |
76 | } | |
77 | return ret; | |
78 | } | |
79 | ||
80 | static enum power_supply_property olpc_ac_props[] = { | |
81 | POWER_SUPPLY_PROP_ONLINE, | |
82 | }; | |
83 | ||
297d716f | 84 | static const struct power_supply_desc olpc_ac_desc = { |
fb972873 DW |
85 | .name = "olpc-ac", |
86 | .type = POWER_SUPPLY_TYPE_MAINS, | |
87 | .properties = olpc_ac_props, | |
88 | .num_properties = ARRAY_SIZE(olpc_ac_props), | |
89 | .get_property = olpc_ac_get_prop, | |
90 | }; | |
91 | ||
297d716f KK |
92 | static struct power_supply *olpc_ac; |
93 | ||
1ca5b9d2 DW |
94 | static char bat_serial[17]; /* Ick */ |
95 | ||
b2bd8a3b AS |
96 | static int olpc_bat_get_status(union power_supply_propval *val, uint8_t ec_byte) |
97 | { | |
98 | if (olpc_platform_info.ecver > 0x44) { | |
8f7e5798 | 99 | if (ec_byte & (BAT_STAT_CHARGING | BAT_STAT_TRICKLE)) |
b2bd8a3b AS |
100 | val->intval = POWER_SUPPLY_STATUS_CHARGING; |
101 | else if (ec_byte & BAT_STAT_DISCHARGING) | |
102 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; | |
103 | else if (ec_byte & BAT_STAT_FULL) | |
104 | val->intval = POWER_SUPPLY_STATUS_FULL; | |
105 | else /* er,... */ | |
106 | val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; | |
107 | } else { | |
108 | /* Older EC didn't report charge/discharge bits */ | |
109 | if (!(ec_byte & BAT_STAT_AC)) /* No AC means discharging */ | |
110 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; | |
111 | else if (ec_byte & BAT_STAT_FULL) | |
112 | val->intval = POWER_SUPPLY_STATUS_FULL; | |
113 | else /* Not _necessarily_ true but EC doesn't tell all yet */ | |
114 | val->intval = POWER_SUPPLY_STATUS_CHARGING; | |
115 | } | |
116 | ||
117 | return 0; | |
118 | } | |
119 | ||
120 | static int olpc_bat_get_health(union power_supply_propval *val) | |
121 | { | |
122 | uint8_t ec_byte; | |
123 | int ret; | |
124 | ||
125 | ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1); | |
126 | if (ret) | |
127 | return ret; | |
128 | ||
129 | switch (ec_byte) { | |
130 | case 0: | |
131 | val->intval = POWER_SUPPLY_HEALTH_GOOD; | |
132 | break; | |
133 | ||
134 | case BAT_ERR_OVERTEMP: | |
135 | val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; | |
136 | break; | |
137 | ||
138 | case BAT_ERR_OVERVOLTAGE: | |
139 | val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; | |
140 | break; | |
141 | ||
142 | case BAT_ERR_INFOFAIL: | |
143 | case BAT_ERR_OUT_OF_CONTROL: | |
144 | case BAT_ERR_ID_FAIL: | |
145 | case BAT_ERR_ACR_FAIL: | |
146 | val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; | |
147 | break; | |
148 | ||
149 | default: | |
150 | /* Eep. We don't know this failure code */ | |
151 | ret = -EIO; | |
152 | } | |
153 | ||
154 | return ret; | |
155 | } | |
156 | ||
157 | static int olpc_bat_get_mfr(union power_supply_propval *val) | |
158 | { | |
159 | uint8_t ec_byte; | |
160 | int ret; | |
161 | ||
162 | ec_byte = BAT_ADDR_MFR_TYPE; | |
163 | ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1); | |
164 | if (ret) | |
165 | return ret; | |
166 | ||
167 | switch (ec_byte >> 4) { | |
168 | case 1: | |
169 | val->strval = "Gold Peak"; | |
170 | break; | |
171 | case 2: | |
172 | val->strval = "BYD"; | |
173 | break; | |
174 | default: | |
175 | val->strval = "Unknown"; | |
176 | break; | |
177 | } | |
178 | ||
179 | return ret; | |
180 | } | |
181 | ||
182 | static int olpc_bat_get_tech(union power_supply_propval *val) | |
183 | { | |
184 | uint8_t ec_byte; | |
185 | int ret; | |
186 | ||
187 | ec_byte = BAT_ADDR_MFR_TYPE; | |
188 | ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1); | |
189 | if (ret) | |
190 | return ret; | |
191 | ||
192 | switch (ec_byte & 0xf) { | |
193 | case 1: | |
194 | val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH; | |
195 | break; | |
196 | case 2: | |
197 | val->intval = POWER_SUPPLY_TECHNOLOGY_LiFe; | |
198 | break; | |
199 | default: | |
200 | val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; | |
201 | break; | |
202 | } | |
203 | ||
204 | return ret; | |
205 | } | |
206 | ||
b202a5e6 SS |
207 | static int olpc_bat_get_charge_full_design(union power_supply_propval *val) |
208 | { | |
209 | uint8_t ec_byte; | |
210 | union power_supply_propval tech; | |
211 | int ret, mfr; | |
212 | ||
213 | ret = olpc_bat_get_tech(&tech); | |
214 | if (ret) | |
215 | return ret; | |
216 | ||
217 | ec_byte = BAT_ADDR_MFR_TYPE; | |
218 | ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1); | |
219 | if (ret) | |
220 | return ret; | |
221 | ||
222 | mfr = ec_byte >> 4; | |
223 | ||
224 | switch (tech.intval) { | |
225 | case POWER_SUPPLY_TECHNOLOGY_NiMH: | |
226 | switch (mfr) { | |
227 | case 1: /* Gold Peak */ | |
228 | val->intval = 3000000*.8; | |
229 | break; | |
230 | default: | |
231 | return -EIO; | |
232 | } | |
233 | break; | |
234 | ||
235 | case POWER_SUPPLY_TECHNOLOGY_LiFe: | |
236 | switch (mfr) { | |
ecc2edd5 | 237 | case 1: /* Gold Peak, fall through */ |
b202a5e6 | 238 | case 2: /* BYD */ |
ecc2edd5 | 239 | val->intval = 2800000; |
b202a5e6 SS |
240 | break; |
241 | default: | |
242 | return -EIO; | |
243 | } | |
244 | break; | |
245 | ||
246 | default: | |
247 | return -EIO; | |
248 | } | |
249 | ||
250 | return ret; | |
251 | } | |
252 | ||
20fd9830 SS |
253 | static int olpc_bat_get_charge_now(union power_supply_propval *val) |
254 | { | |
255 | uint8_t soc; | |
256 | union power_supply_propval full; | |
257 | int ret; | |
258 | ||
259 | ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &soc, 1); | |
260 | if (ret) | |
261 | return ret; | |
262 | ||
263 | ret = olpc_bat_get_charge_full_design(&full); | |
264 | if (ret) | |
265 | return ret; | |
266 | ||
267 | val->intval = soc * (full.intval / 100); | |
268 | return 0; | |
269 | } | |
270 | ||
5619d0ba RS |
271 | static int olpc_bat_get_voltage_max_design(union power_supply_propval *val) |
272 | { | |
273 | uint8_t ec_byte; | |
274 | union power_supply_propval tech; | |
275 | int mfr; | |
276 | int ret; | |
277 | ||
278 | ret = olpc_bat_get_tech(&tech); | |
279 | if (ret) | |
280 | return ret; | |
281 | ||
282 | ec_byte = BAT_ADDR_MFR_TYPE; | |
283 | ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1); | |
284 | if (ret) | |
285 | return ret; | |
286 | ||
287 | mfr = ec_byte >> 4; | |
288 | ||
289 | switch (tech.intval) { | |
290 | case POWER_SUPPLY_TECHNOLOGY_NiMH: | |
291 | switch (mfr) { | |
292 | case 1: /* Gold Peak */ | |
293 | val->intval = 6000000; | |
294 | break; | |
295 | default: | |
296 | return -EIO; | |
297 | } | |
298 | break; | |
299 | ||
300 | case POWER_SUPPLY_TECHNOLOGY_LiFe: | |
301 | switch (mfr) { | |
302 | case 1: /* Gold Peak */ | |
303 | val->intval = 6400000; | |
304 | break; | |
305 | case 2: /* BYD */ | |
306 | val->intval = 6500000; | |
307 | break; | |
308 | default: | |
309 | return -EIO; | |
310 | } | |
311 | break; | |
312 | ||
313 | default: | |
314 | return -EIO; | |
315 | } | |
316 | ||
317 | return ret; | |
318 | } | |
319 | ||
fb972873 DW |
320 | /********************************************************************* |
321 | * Battery properties | |
322 | *********************************************************************/ | |
323 | static int olpc_bat_get_property(struct power_supply *psy, | |
324 | enum power_supply_property psp, | |
325 | union power_supply_propval *val) | |
326 | { | |
327 | int ret = 0; | |
8e9c7716 | 328 | __be16 ec_word; |
fb972873 | 329 | uint8_t ec_byte; |
8e9c7716 | 330 | __be64 ser_buf; |
fb972873 DW |
331 | |
332 | ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &ec_byte, 1); | |
333 | if (ret) | |
334 | return ret; | |
335 | ||
336 | /* Theoretically there's a race here -- the battery could be | |
337 | removed immediately after we check whether it's present, and | |
338 | then we query for some other property of the now-absent battery. | |
339 | It doesn't matter though -- the EC will return the last-known | |
340 | information, and it's as if we just ran that _little_ bit faster | |
341 | and managed to read it out before the battery went away. */ | |
8f7e5798 AS |
342 | if (!(ec_byte & (BAT_STAT_PRESENT | BAT_STAT_TRICKLE)) && |
343 | psp != POWER_SUPPLY_PROP_PRESENT) | |
fb972873 DW |
344 | return -ENODEV; |
345 | ||
346 | switch (psp) { | |
347 | case POWER_SUPPLY_PROP_STATUS: | |
b2bd8a3b AS |
348 | ret = olpc_bat_get_status(val, ec_byte); |
349 | if (ret) | |
350 | return ret; | |
351 | break; | |
ee8076ed AS |
352 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
353 | if (ec_byte & BAT_STAT_TRICKLE) | |
354 | val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; | |
355 | else if (ec_byte & BAT_STAT_CHARGING) | |
356 | val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; | |
357 | else | |
358 | val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; | |
359 | break; | |
fb972873 | 360 | case POWER_SUPPLY_PROP_PRESENT: |
8f7e5798 AS |
361 | val->intval = !!(ec_byte & (BAT_STAT_PRESENT | |
362 | BAT_STAT_TRICKLE)); | |
fb972873 DW |
363 | break; |
364 | ||
365 | case POWER_SUPPLY_PROP_HEALTH: | |
366 | if (ec_byte & BAT_STAT_DESTROY) | |
367 | val->intval = POWER_SUPPLY_HEALTH_DEAD; | |
368 | else { | |
b2bd8a3b | 369 | ret = olpc_bat_get_health(val); |
fb972873 DW |
370 | if (ret) |
371 | return ret; | |
fb972873 DW |
372 | } |
373 | break; | |
374 | ||
375 | case POWER_SUPPLY_PROP_MANUFACTURER: | |
b2bd8a3b | 376 | ret = olpc_bat_get_mfr(val); |
fb972873 DW |
377 | if (ret) |
378 | return ret; | |
fb972873 DW |
379 | break; |
380 | case POWER_SUPPLY_PROP_TECHNOLOGY: | |
b2bd8a3b | 381 | ret = olpc_bat_get_tech(val); |
fb972873 DW |
382 | if (ret) |
383 | return ret; | |
fb972873 DW |
384 | break; |
385 | case POWER_SUPPLY_PROP_VOLTAGE_AVG: | |
22fadd76 | 386 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
fb972873 DW |
387 | ret = olpc_ec_cmd(EC_BAT_VOLTAGE, NULL, 0, (void *)&ec_word, 2); |
388 | if (ret) | |
389 | return ret; | |
390 | ||
7cfbb294 | 391 | val->intval = (s16)be16_to_cpu(ec_word) * 9760L / 32; |
fb972873 DW |
392 | break; |
393 | case POWER_SUPPLY_PROP_CURRENT_AVG: | |
22fadd76 | 394 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
fb972873 DW |
395 | ret = olpc_ec_cmd(EC_BAT_CURRENT, NULL, 0, (void *)&ec_word, 2); |
396 | if (ret) | |
397 | return ret; | |
398 | ||
7cfbb294 | 399 | val->intval = (s16)be16_to_cpu(ec_word) * 15625L / 120; |
fb972873 DW |
400 | break; |
401 | case POWER_SUPPLY_PROP_CAPACITY: | |
402 | ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &ec_byte, 1); | |
403 | if (ret) | |
404 | return ret; | |
405 | val->intval = ec_byte; | |
406 | break; | |
b294a290 AS |
407 | case POWER_SUPPLY_PROP_CAPACITY_LEVEL: |
408 | if (ec_byte & BAT_STAT_FULL) | |
409 | val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL; | |
410 | else if (ec_byte & BAT_STAT_LOW) | |
411 | val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW; | |
412 | else | |
413 | val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; | |
414 | break; | |
b202a5e6 SS |
415 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: |
416 | ret = olpc_bat_get_charge_full_design(val); | |
417 | if (ret) | |
418 | return ret; | |
419 | break; | |
20fd9830 SS |
420 | case POWER_SUPPLY_PROP_CHARGE_NOW: |
421 | ret = olpc_bat_get_charge_now(val); | |
422 | if (ret) | |
423 | return ret; | |
424 | break; | |
fb972873 DW |
425 | case POWER_SUPPLY_PROP_TEMP: |
426 | ret = olpc_ec_cmd(EC_BAT_TEMP, NULL, 0, (void *)&ec_word, 2); | |
427 | if (ret) | |
428 | return ret; | |
8e9c7716 | 429 | |
7cfbb294 | 430 | val->intval = (s16)be16_to_cpu(ec_word) * 100 / 256; |
fb972873 DW |
431 | break; |
432 | case POWER_SUPPLY_PROP_TEMP_AMBIENT: | |
433 | ret = olpc_ec_cmd(EC_AMB_TEMP, NULL, 0, (void *)&ec_word, 2); | |
434 | if (ret) | |
435 | return ret; | |
436 | ||
8e9c7716 | 437 | val->intval = (int)be16_to_cpu(ec_word) * 100 / 256; |
fb972873 | 438 | break; |
8e552c36 AS |
439 | case POWER_SUPPLY_PROP_CHARGE_COUNTER: |
440 | ret = olpc_ec_cmd(EC_BAT_ACR, NULL, 0, (void *)&ec_word, 2); | |
441 | if (ret) | |
442 | return ret; | |
443 | ||
7cfbb294 | 444 | val->intval = (s16)be16_to_cpu(ec_word) * 6250 / 15; |
8e552c36 | 445 | break; |
1ca5b9d2 DW |
446 | case POWER_SUPPLY_PROP_SERIAL_NUMBER: |
447 | ret = olpc_ec_cmd(EC_BAT_SERIAL, NULL, 0, (void *)&ser_buf, 8); | |
448 | if (ret) | |
449 | return ret; | |
450 | ||
451 | sprintf(bat_serial, "%016llx", (long long)be64_to_cpu(ser_buf)); | |
452 | val->strval = bat_serial; | |
453 | break; | |
5619d0ba RS |
454 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
455 | ret = olpc_bat_get_voltage_max_design(val); | |
456 | if (ret) | |
457 | return ret; | |
458 | break; | |
fb972873 DW |
459 | default: |
460 | ret = -EINVAL; | |
461 | break; | |
462 | } | |
463 | ||
464 | return ret; | |
465 | } | |
466 | ||
c566d299 | 467 | static enum power_supply_property olpc_xo1_bat_props[] = { |
fb972873 | 468 | POWER_SUPPLY_PROP_STATUS, |
ee8076ed | 469 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
fb972873 DW |
470 | POWER_SUPPLY_PROP_PRESENT, |
471 | POWER_SUPPLY_PROP_HEALTH, | |
472 | POWER_SUPPLY_PROP_TECHNOLOGY, | |
473 | POWER_SUPPLY_PROP_VOLTAGE_AVG, | |
22fadd76 | 474 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
fb972873 | 475 | POWER_SUPPLY_PROP_CURRENT_AVG, |
22fadd76 | 476 | POWER_SUPPLY_PROP_CURRENT_NOW, |
fb972873 | 477 | POWER_SUPPLY_PROP_CAPACITY, |
b294a290 | 478 | POWER_SUPPLY_PROP_CAPACITY_LEVEL, |
b202a5e6 | 479 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, |
20fd9830 | 480 | POWER_SUPPLY_PROP_CHARGE_NOW, |
fb972873 DW |
481 | POWER_SUPPLY_PROP_TEMP, |
482 | POWER_SUPPLY_PROP_TEMP_AMBIENT, | |
483 | POWER_SUPPLY_PROP_MANUFACTURER, | |
1ca5b9d2 | 484 | POWER_SUPPLY_PROP_SERIAL_NUMBER, |
8e552c36 | 485 | POWER_SUPPLY_PROP_CHARGE_COUNTER, |
5619d0ba | 486 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, |
fb972873 DW |
487 | }; |
488 | ||
c566d299 DD |
489 | /* XO-1.5 does not have ambient temperature property */ |
490 | static enum power_supply_property olpc_xo15_bat_props[] = { | |
491 | POWER_SUPPLY_PROP_STATUS, | |
492 | POWER_SUPPLY_PROP_CHARGE_TYPE, | |
493 | POWER_SUPPLY_PROP_PRESENT, | |
494 | POWER_SUPPLY_PROP_HEALTH, | |
495 | POWER_SUPPLY_PROP_TECHNOLOGY, | |
496 | POWER_SUPPLY_PROP_VOLTAGE_AVG, | |
bf542a4e | 497 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
c566d299 | 498 | POWER_SUPPLY_PROP_CURRENT_AVG, |
bf542a4e | 499 | POWER_SUPPLY_PROP_CURRENT_NOW, |
c566d299 DD |
500 | POWER_SUPPLY_PROP_CAPACITY, |
501 | POWER_SUPPLY_PROP_CAPACITY_LEVEL, | |
bf542a4e SS |
502 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, |
503 | POWER_SUPPLY_PROP_CHARGE_NOW, | |
c566d299 DD |
504 | POWER_SUPPLY_PROP_TEMP, |
505 | POWER_SUPPLY_PROP_MANUFACTURER, | |
506 | POWER_SUPPLY_PROP_SERIAL_NUMBER, | |
507 | POWER_SUPPLY_PROP_CHARGE_COUNTER, | |
5619d0ba | 508 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, |
c566d299 DD |
509 | }; |
510 | ||
d7eb9e36 AS |
511 | /* EEPROM reading goes completely around the power_supply API, sadly */ |
512 | ||
513 | #define EEPROM_START 0x20 | |
514 | #define EEPROM_END 0x80 | |
515 | #define EEPROM_SIZE (EEPROM_END - EEPROM_START) | |
516 | ||
2c3c8bea | 517 | static ssize_t olpc_bat_eeprom_read(struct file *filp, struct kobject *kobj, |
d7eb9e36 AS |
518 | struct bin_attribute *attr, char *buf, loff_t off, size_t count) |
519 | { | |
520 | uint8_t ec_byte; | |
04a820ea AS |
521 | int ret; |
522 | int i; | |
d7eb9e36 AS |
523 | |
524 | if (off >= EEPROM_SIZE) | |
525 | return 0; | |
526 | if (off + count > EEPROM_SIZE) | |
527 | count = EEPROM_SIZE - off; | |
528 | ||
04a820ea AS |
529 | for (i = 0; i < count; i++) { |
530 | ec_byte = EEPROM_START + off + i; | |
531 | ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &buf[i], 1); | |
d7eb9e36 | 532 | if (ret) { |
04a820ea AS |
533 | pr_err("olpc-battery: " |
534 | "EC_BAT_EEPROM cmd @ 0x%x failed - %d!\n", | |
535 | ec_byte, ret); | |
d7eb9e36 AS |
536 | return -EIO; |
537 | } | |
538 | } | |
539 | ||
540 | return count; | |
541 | } | |
542 | ||
543 | static struct bin_attribute olpc_bat_eeprom = { | |
544 | .attr = { | |
545 | .name = "eeprom", | |
546 | .mode = S_IRUGO, | |
d7eb9e36 AS |
547 | }, |
548 | .size = 0, | |
549 | .read = olpc_bat_eeprom_read, | |
550 | }; | |
551 | ||
144bbeae AS |
552 | /* Allow userspace to see the specific error value pulled from the EC */ |
553 | ||
554 | static ssize_t olpc_bat_error_read(struct device *dev, | |
555 | struct device_attribute *attr, char *buf) | |
556 | { | |
557 | uint8_t ec_byte; | |
558 | ssize_t ret; | |
559 | ||
560 | ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1); | |
561 | if (ret < 0) | |
562 | return ret; | |
563 | ||
564 | return sprintf(buf, "%d\n", ec_byte); | |
565 | } | |
566 | ||
567 | static struct device_attribute olpc_bat_error = { | |
568 | .attr = { | |
569 | .name = "error", | |
570 | .mode = S_IRUGO, | |
571 | }, | |
572 | .show = olpc_bat_error_read, | |
573 | }; | |
574 | ||
fb972873 DW |
575 | /********************************************************************* |
576 | * Initialisation | |
577 | *********************************************************************/ | |
578 | ||
297d716f | 579 | static struct power_supply_desc olpc_bat_desc = { |
c3503fd0 | 580 | .name = "olpc-battery", |
fb972873 DW |
581 | .get_property = olpc_bat_get_property, |
582 | .use_for_apm = 1, | |
583 | }; | |
584 | ||
297d716f KK |
585 | static struct power_supply *olpc_bat; |
586 | ||
cae659af DD |
587 | static int olpc_battery_suspend(struct platform_device *pdev, |
588 | pm_message_t state) | |
589 | { | |
297d716f | 590 | if (device_may_wakeup(&olpc_ac->dev)) |
cae659af DD |
591 | olpc_ec_wakeup_set(EC_SCI_SRC_ACPWR); |
592 | else | |
593 | olpc_ec_wakeup_clear(EC_SCI_SRC_ACPWR); | |
594 | ||
297d716f | 595 | if (device_may_wakeup(&olpc_bat->dev)) |
cae659af DD |
596 | olpc_ec_wakeup_set(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC |
597 | | EC_SCI_SRC_BATERR); | |
598 | else | |
599 | olpc_ec_wakeup_clear(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC | |
600 | | EC_SCI_SRC_BATERR); | |
601 | ||
602 | return 0; | |
603 | } | |
604 | ||
c8afa640 | 605 | static int olpc_battery_probe(struct platform_device *pdev) |
fb972873 | 606 | { |
c3503fd0 | 607 | int ret; |
fb972873 DW |
608 | uint8_t status; |
609 | ||
484d6d50 AS |
610 | /* |
611 | * We've seen a number of EC protocol changes; this driver requires | |
612 | * the latest EC protocol, supported by 0x44 and above. | |
613 | */ | |
614 | if (olpc_platform_info.ecver < 0x44) { | |
615 | printk(KERN_NOTICE "OLPC EC version 0x%02x too old for " | |
616 | "battery driver.\n", olpc_platform_info.ecver); | |
fb972873 DW |
617 | return -ENXIO; |
618 | } | |
619 | ||
620 | ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1); | |
621 | if (ret) | |
622 | return ret; | |
623 | ||
624 | /* Ignore the status. It doesn't actually matter */ | |
625 | ||
297d716f KK |
626 | olpc_ac = power_supply_register(&pdev->dev, &olpc_ac_desc, NULL); |
627 | if (IS_ERR(olpc_ac)) | |
628 | return PTR_ERR(olpc_ac); | |
fb972873 | 629 | |
c566d299 | 630 | if (olpc_board_at_least(olpc_board_pre(0xd0))) { /* XO-1.5 */ |
297d716f KK |
631 | olpc_bat_desc.properties = olpc_xo15_bat_props; |
632 | olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo15_bat_props); | |
c566d299 | 633 | } else { /* XO-1 */ |
297d716f KK |
634 | olpc_bat_desc.properties = olpc_xo1_bat_props; |
635 | olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo1_bat_props); | |
c566d299 | 636 | } |
fb972873 | 637 | |
297d716f KK |
638 | olpc_bat = power_supply_register(&pdev->dev, &olpc_bat_desc, NULL); |
639 | if (IS_ERR(olpc_bat)) { | |
640 | ret = PTR_ERR(olpc_bat); | |
fb972873 | 641 | goto battery_failed; |
297d716f | 642 | } |
fb972873 | 643 | |
297d716f | 644 | ret = device_create_bin_file(&olpc_bat->dev, &olpc_bat_eeprom); |
d7eb9e36 AS |
645 | if (ret) |
646 | goto eeprom_failed; | |
647 | ||
297d716f | 648 | ret = device_create_file(&olpc_bat->dev, &olpc_bat_error); |
144bbeae AS |
649 | if (ret) |
650 | goto error_failed; | |
651 | ||
cae659af | 652 | if (olpc_ec_wakeup_available()) { |
297d716f KK |
653 | device_set_wakeup_capable(&olpc_ac->dev, true); |
654 | device_set_wakeup_capable(&olpc_bat->dev, true); | |
cae659af DD |
655 | } |
656 | ||
c3503fd0 | 657 | return 0; |
fb972873 | 658 | |
144bbeae | 659 | error_failed: |
297d716f | 660 | device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom); |
d7eb9e36 | 661 | eeprom_failed: |
297d716f | 662 | power_supply_unregister(olpc_bat); |
fb972873 | 663 | battery_failed: |
297d716f | 664 | power_supply_unregister(olpc_ac); |
fb972873 DW |
665 | return ret; |
666 | } | |
667 | ||
415ec69f | 668 | static int olpc_battery_remove(struct platform_device *pdev) |
fb972873 | 669 | { |
297d716f KK |
670 | device_remove_file(&olpc_bat->dev, &olpc_bat_error); |
671 | device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom); | |
672 | power_supply_unregister(olpc_bat); | |
673 | power_supply_unregister(olpc_ac); | |
c3503fd0 | 674 | return 0; |
fb972873 DW |
675 | } |
676 | ||
6d2cea4f | 677 | static const struct of_device_id olpc_battery_ids[] = { |
c3503fd0 DD |
678 | { .compatible = "olpc,xo1-battery" }, |
679 | {} | |
680 | }; | |
681 | MODULE_DEVICE_TABLE(of, olpc_battery_ids); | |
682 | ||
5519d00e | 683 | static struct platform_driver olpc_battery_driver = { |
c3503fd0 DD |
684 | .driver = { |
685 | .name = "olpc-battery", | |
c3503fd0 DD |
686 | .of_match_table = olpc_battery_ids, |
687 | }, | |
688 | .probe = olpc_battery_probe, | |
28ea73f4 | 689 | .remove = olpc_battery_remove, |
cae659af | 690 | .suspend = olpc_battery_suspend, |
c3503fd0 DD |
691 | }; |
692 | ||
300bac7f | 693 | module_platform_driver(olpc_battery_driver); |
fb972873 DW |
694 | |
695 | MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); | |
696 | MODULE_LICENSE("GPL"); | |
697 | MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine"); |