1
2
3
4
5
6
7
8
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
25#define EC_BAT_CURRENT 0x11
26#define EC_BAT_ACR 0x12
27#define EC_BAT_TEMP 0x13
28#define EC_AMB_TEMP 0x14
29#define EC_BAT_STATUS 0x15
30#define EC_BAT_SOC 0x16
31#define EC_BAT_SERIAL 0x17
32#define EC_BAT_EEPROM 0x18
33#define EC_BAT_ERRCODE 0x1f
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
56
57
58static 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
80static enum power_supply_property olpc_ac_props[] = {
81 POWER_SUPPLY_PROP_ONLINE,
82};
83
84static 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
92static struct power_supply *olpc_ac;
93
94static char bat_serial[17];
95
96static 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
106 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
107 } else {
108
109 if (!(ec_byte & BAT_STAT_AC))
110 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
111 else if (ec_byte & BAT_STAT_FULL)
112 val->intval = POWER_SUPPLY_STATUS_FULL;
113 else
114 val->intval = POWER_SUPPLY_STATUS_CHARGING;
115 }
116
117 return 0;
118}
119
120static 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
151 ret = -EIO;
152 }
153
154 return ret;
155}
156
157static 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
182static 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
207static 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:
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:
238 case 2:
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
253static 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
271static 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:
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:
303 val->intval = 6400000;
304 break;
305 case 2:
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
322
323static 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
337
338
339
340
341
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
467static 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
490static 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
512
513#define EEPROM_START 0x20
514#define EEPROM_END 0x80
515#define EEPROM_SIZE (EEPROM_END - EEPROM_START)
516
517static 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 for (i = 0; i < count; i++) {
525 ec_byte = EEPROM_START + off + i;
526 ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &buf[i], 1);
527 if (ret) {
528 pr_err("olpc-battery: "
529 "EC_BAT_EEPROM cmd @ 0x%x failed - %d!\n",
530 ec_byte, ret);
531 return -EIO;
532 }
533 }
534
535 return count;
536}
537
538static const struct bin_attribute olpc_bat_eeprom = {
539 .attr = {
540 .name = "eeprom",
541 .mode = S_IRUGO,
542 },
543 .size = EEPROM_SIZE,
544 .read = olpc_bat_eeprom_read,
545};
546
547
548
549static ssize_t olpc_bat_error_read(struct device *dev,
550 struct device_attribute *attr, char *buf)
551{
552 uint8_t ec_byte;
553 ssize_t ret;
554
555 ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1);
556 if (ret < 0)
557 return ret;
558
559 return sprintf(buf, "%d\n", ec_byte);
560}
561
562static const struct device_attribute olpc_bat_error = {
563 .attr = {
564 .name = "error",
565 .mode = S_IRUGO,
566 },
567 .show = olpc_bat_error_read,
568};
569
570
571
572
573
574static struct power_supply_desc olpc_bat_desc = {
575 .name = "olpc-battery",
576 .get_property = olpc_bat_get_property,
577 .use_for_apm = 1,
578};
579
580static struct power_supply *olpc_bat;
581
582static int olpc_battery_suspend(struct platform_device *pdev,
583 pm_message_t state)
584{
585 if (device_may_wakeup(&olpc_ac->dev))
586 olpc_ec_wakeup_set(EC_SCI_SRC_ACPWR);
587 else
588 olpc_ec_wakeup_clear(EC_SCI_SRC_ACPWR);
589
590 if (device_may_wakeup(&olpc_bat->dev))
591 olpc_ec_wakeup_set(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC
592 | EC_SCI_SRC_BATERR);
593 else
594 olpc_ec_wakeup_clear(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC
595 | EC_SCI_SRC_BATERR);
596
597 return 0;
598}
599
600static int olpc_battery_probe(struct platform_device *pdev)
601{
602 int ret;
603 uint8_t status;
604
605
606
607
608
609 if (olpc_platform_info.ecver < 0x44) {
610 printk(KERN_NOTICE "OLPC EC version 0x%02x too old for "
611 "battery driver.\n", olpc_platform_info.ecver);
612 return -ENXIO;
613 }
614
615 ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1);
616 if (ret)
617 return ret;
618
619
620
621 olpc_ac = power_supply_register(&pdev->dev, &olpc_ac_desc, NULL);
622 if (IS_ERR(olpc_ac))
623 return PTR_ERR(olpc_ac);
624
625 if (olpc_board_at_least(olpc_board_pre(0xd0))) {
626 olpc_bat_desc.properties = olpc_xo15_bat_props;
627 olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo15_bat_props);
628 } else {
629 olpc_bat_desc.properties = olpc_xo1_bat_props;
630 olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo1_bat_props);
631 }
632
633 olpc_bat = power_supply_register(&pdev->dev, &olpc_bat_desc, NULL);
634 if (IS_ERR(olpc_bat)) {
635 ret = PTR_ERR(olpc_bat);
636 goto battery_failed;
637 }
638
639 ret = device_create_bin_file(&olpc_bat->dev, &olpc_bat_eeprom);
640 if (ret)
641 goto eeprom_failed;
642
643 ret = device_create_file(&olpc_bat->dev, &olpc_bat_error);
644 if (ret)
645 goto error_failed;
646
647 if (olpc_ec_wakeup_available()) {
648 device_set_wakeup_capable(&olpc_ac->dev, true);
649 device_set_wakeup_capable(&olpc_bat->dev, true);
650 }
651
652 return 0;
653
654error_failed:
655 device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom);
656eeprom_failed:
657 power_supply_unregister(olpc_bat);
658battery_failed:
659 power_supply_unregister(olpc_ac);
660 return ret;
661}
662
663static int olpc_battery_remove(struct platform_device *pdev)
664{
665 device_remove_file(&olpc_bat->dev, &olpc_bat_error);
666 device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom);
667 power_supply_unregister(olpc_bat);
668 power_supply_unregister(olpc_ac);
669 return 0;
670}
671
672static const struct of_device_id olpc_battery_ids[] = {
673 { .compatible = "olpc,xo1-battery" },
674 {}
675};
676MODULE_DEVICE_TABLE(of, olpc_battery_ids);
677
678static struct platform_driver olpc_battery_driver = {
679 .driver = {
680 .name = "olpc-battery",
681 .of_match_table = olpc_battery_ids,
682 },
683 .probe = olpc_battery_probe,
684 .remove = olpc_battery_remove,
685 .suspend = olpc_battery_suspend,
686};
687
688module_platform_driver(olpc_battery_driver);
689
690MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
691MODULE_LICENSE("GPL");
692MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine");
693
