?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gro: Allow tunnel stacking in the case of FOU/GUE
[linux/fpc-iii.git] / drivers / power / olpc_battery.c
bloba944338a39de406d80d932c31babebbb50731318
1 /*
2 * Battery driver for One Laptop Per Child board.
3 *
4 * Copyright © 2006-2010 David Woodhouse <dwmw2@infradead.org>
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
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/types.h>
14 #include <linux/err.h>
15 #include <linux/device.h>
16 #include <linux/platform_device.h>
17 #include <linux/power_supply.h>
18 #include <linux/jiffies.h>
19 #include <linux/sched.h>
20 #include <linux/olpc-ec.h>
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 */
26 #define EC_BAT_ACR 0x12 /* int16_t, *6250/15, µAh */
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
42 #define BAT_STAT_TRICKLE 0x80
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
84 static const struct power_supply_desc olpc_ac_desc = {
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
92 static struct power_supply *olpc_ac;
93
94 static char bat_serial[17]; /* Ick */
95
96 static int olpc_bat_get_status(union power_supply_propval *val, uint8_t ec_byte)
97 {
98 if (olpc_platform_info.ecver > 0x44) {
99 if (ec_byte & (BAT_STAT_CHARGING | BAT_STAT_TRICKLE))
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
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) {
237 case 1: /* Gold Peak, fall through */
238 case 2: /* BYD */
239 val->intval = 2800000;
240 break;
241 default:
242 return -EIO;
243 }
244 break;
245
246 default:
247 return -EIO;
248 }
249
250 return ret;
251 }
252
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
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
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;
328 __be16 ec_word;
329 uint8_t ec_byte;
330 __be64 ser_buf;
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. */
342 if (!(ec_byte & (BAT_STAT_PRESENT | BAT_STAT_TRICKLE)) &&
343 psp != POWER_SUPPLY_PROP_PRESENT)
344 return -ENODEV;
345
346 switch (psp) {
347 case POWER_SUPPLY_PROP_STATUS:
348 ret = olpc_bat_get_status(val, ec_byte);
349 if (ret)
350 return ret;
351 break;
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;
360 case POWER_SUPPLY_PROP_PRESENT:
361 val->intval = !!(ec_byte & (BAT_STAT_PRESENT |
362 BAT_STAT_TRICKLE));
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 {
369 ret = olpc_bat_get_health(val);
370 if (ret)
371 return ret;
372 }
373 break;
374
375 case POWER_SUPPLY_PROP_MANUFACTURER:
376 ret = olpc_bat_get_mfr(val);
377 if (ret)
378 return ret;
379 break;
380 case POWER_SUPPLY_PROP_TECHNOLOGY:
381 ret = olpc_bat_get_tech(val);
382 if (ret)
383 return ret;
384 break;
385 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
386 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
387 ret = olpc_ec_cmd(EC_BAT_VOLTAGE, NULL, 0, (void *)&ec_word, 2);
388 if (ret)
389 return ret;
390
391 val->intval = (s16)be16_to_cpu(ec_word) * 9760L / 32;
392 break;
393 case POWER_SUPPLY_PROP_CURRENT_AVG:
394 case POWER_SUPPLY_PROP_CURRENT_NOW:
395 ret = olpc_ec_cmd(EC_BAT_CURRENT, NULL, 0, (void *)&ec_word, 2);
396 if (ret)
397 return ret;
398
399 val->intval = (s16)be16_to_cpu(ec_word) * 15625L / 120;
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;
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;
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;
420 case POWER_SUPPLY_PROP_CHARGE_NOW:
421 ret = olpc_bat_get_charge_now(val);
422 if (ret)
423 return ret;
424 break;
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;
429
430 val->intval = (s16)be16_to_cpu(ec_word) * 100 / 256;
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
437 val->intval = (int)be16_to_cpu(ec_word) * 100 / 256;
438 break;
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
444 val->intval = (s16)be16_to_cpu(ec_word) * 6250 / 15;
445 break;
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;
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;
459 default:
460 ret = -EINVAL;
461 break;
462 }
463
464 return ret;
465 }
466
467 static enum power_supply_property olpc_xo1_bat_props[] = {
468 POWER_SUPPLY_PROP_STATUS,
469 POWER_SUPPLY_PROP_CHARGE_TYPE,
470 POWER_SUPPLY_PROP_PRESENT,
471 POWER_SUPPLY_PROP_HEALTH,
472 POWER_SUPPLY_PROP_TECHNOLOGY,
473 POWER_SUPPLY_PROP_VOLTAGE_AVG,
474 POWER_SUPPLY_PROP_VOLTAGE_NOW,
475 POWER_SUPPLY_PROP_CURRENT_AVG,
476 POWER_SUPPLY_PROP_CURRENT_NOW,
477 POWER_SUPPLY_PROP_CAPACITY,
478 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
479 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
480 POWER_SUPPLY_PROP_CHARGE_NOW,
481 POWER_SUPPLY_PROP_TEMP,
482 POWER_SUPPLY_PROP_TEMP_AMBIENT,
483 POWER_SUPPLY_PROP_MANUFACTURER,
484 POWER_SUPPLY_PROP_SERIAL_NUMBER,
485 POWER_SUPPLY_PROP_CHARGE_COUNTER,
486 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
487 };
488
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,
497 POWER_SUPPLY_PROP_VOLTAGE_NOW,
498 POWER_SUPPLY_PROP_CURRENT_AVG,
499 POWER_SUPPLY_PROP_CURRENT_NOW,
500 POWER_SUPPLY_PROP_CAPACITY,
501 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
502 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
503 POWER_SUPPLY_PROP_CHARGE_NOW,
504 POWER_SUPPLY_PROP_TEMP,
505 POWER_SUPPLY_PROP_MANUFACTURER,
506 POWER_SUPPLY_PROP_SERIAL_NUMBER,
507 POWER_SUPPLY_PROP_CHARGE_COUNTER,
508 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
509 };
510
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
517 static ssize_t olpc_bat_eeprom_read(struct file *filp, struct kobject *kobj,
518 struct bin_attribute *attr, char *buf, loff_t off, size_t count)
519 {
520 uint8_t ec_byte;
521 int ret;
522 int i;
523
524 if (off >= EEPROM_SIZE)
525 return 0;
526 if (off + count > EEPROM_SIZE)
527 count = EEPROM_SIZE - off;
528
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);
532 if (ret) {
533 pr_err("olpc-battery: "
534 "EC_BAT_EEPROM cmd @ 0x%x failed - %d!\n",
535 ec_byte, ret);
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,
547 },
548 .size = 0,
549 .read = olpc_bat_eeprom_read,
550 };
551
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
575 /*********************************************************************
576 * Initialisation
577 *********************************************************************/
578
579 static struct power_supply_desc olpc_bat_desc = {
580 .name = "olpc-battery",
581 .get_property = olpc_bat_get_property,
582 .use_for_apm = 1,
583 };
584
585 static struct power_supply *olpc_bat;
586
587 static int olpc_battery_suspend(struct platform_device *pdev,
588 pm_message_t state)
589 {
590 if (device_may_wakeup(&olpc_ac->dev))
591 olpc_ec_wakeup_set(EC_SCI_SRC_ACPWR);
592 else
593 olpc_ec_wakeup_clear(EC_SCI_SRC_ACPWR);
594
595 if (device_may_wakeup(&olpc_bat->dev))
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
605 static int olpc_battery_probe(struct platform_device *pdev)
606 {
607 int ret;
608 uint8_t status;
609
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);
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
626 olpc_ac = power_supply_register(&pdev->dev, &olpc_ac_desc, NULL);
627 if (IS_ERR(olpc_ac))
628 return PTR_ERR(olpc_ac);
629
630 if (olpc_board_at_least(olpc_board_pre(0xd0))) { /* XO-1.5 */
631 olpc_bat_desc.properties = olpc_xo15_bat_props;
632 olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo15_bat_props);
633 } else { /* XO-1 */
634 olpc_bat_desc.properties = olpc_xo1_bat_props;
635 olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo1_bat_props);
636 }
637
638 olpc_bat = power_supply_register(&pdev->dev, &olpc_bat_desc, NULL);
639 if (IS_ERR(olpc_bat)) {
640 ret = PTR_ERR(olpc_bat);
641 goto battery_failed;
642 }
643
644 ret = device_create_bin_file(&olpc_bat->dev, &olpc_bat_eeprom);
645 if (ret)
646 goto eeprom_failed;
647
648 ret = device_create_file(&olpc_bat->dev, &olpc_bat_error);
649 if (ret)
650 goto error_failed;
651
652 if (olpc_ec_wakeup_available()) {
653 device_set_wakeup_capable(&olpc_ac->dev, true);
654 device_set_wakeup_capable(&olpc_bat->dev, true);
655 }
656
657 return 0;
658
659 error_failed:
660 device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom);
661 eeprom_failed:
662 power_supply_unregister(olpc_bat);
663 battery_failed:
664 power_supply_unregister(olpc_ac);
665 return ret;
666 }
667
668 static int olpc_battery_remove(struct platform_device *pdev)
669 {
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);
674 return 0;
675 }
676
677 static const struct of_device_id olpc_battery_ids[] = {
678 { .compatible = "olpc,xo1-battery" },
679 {}
680 };
681 MODULE_DEVICE_TABLE(of, olpc_battery_ids);
682
683 static struct platform_driver olpc_battery_driver = {
684 .driver = {
685 .name = "olpc-battery",
686 .of_match_table = olpc_battery_ids,
687 },
688 .probe = olpc_battery_probe,
689 .remove = olpc_battery_remove,
690 .suspend = olpc_battery_suspend,
691 };
692
693 module_platform_driver(olpc_battery_driver);
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");
Linux with added FPC-III support