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 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 538 static 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 /* Allow userspace to see the specific error value pulled from the EC */ 548 549 static 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 562 static 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 * Initialisation 572 *********************************************************************/ 573 574 static 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 580 static struct power_supply *olpc_bat; 581 582 static 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 600 static int olpc_battery_probe(struct platform_device *pdev) 601 { 602 int ret; 603 uint8_t status; 604 605 /* 606 * We've seen a number of EC protocol changes; this driver requires 607 * the latest EC protocol, supported by 0x44 and above. 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 /* Ignore the status. It doesn't actually matter */ 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))) { /* XO-1.5 */ 626 olpc_bat_desc.properties = olpc_xo15_bat_props; 627 olpc_bat_desc.num_properties = ARRAY_SIZE(olpc_xo15_bat_props); 628 } else { /* XO-1 */ 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 654 error_failed: 655 device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom); 656 eeprom_failed: 657 power_supply_unregister(olpc_bat); 658 battery_failed: 659 power_supply_unregister(olpc_ac); 660 return ret; 661 } 662 663 static 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 672 static const struct of_device_id olpc_battery_ids[] = { 673 { .compatible = "olpc,xo1-battery" }, 674 {} 675 }; 676 MODULE_DEVICE_TABLE(of, olpc_battery_ids); 677 678 static 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 688 module_platform_driver(olpc_battery_driver); 689 690 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 691 MODULE_LICENSE("GPL"); 692 MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine"); 693