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 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]; /* Ick */ 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 /* 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 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 /* Eep. We don't know this failure code */ 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: /* 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 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: /* 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 *********************************************************************/ 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 /* 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 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/* XO-1.5 does not have ambient temperature property */ 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/* 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 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 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 543static 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 554static 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 567static 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 579static 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 585static struct power_supply *olpc_bat; 586 587static 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 605static 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 659error_failed: 660 device_remove_bin_file(&olpc_bat->dev, &olpc_bat_eeprom); 661eeprom_failed: 662 power_supply_unregister(olpc_bat); 663battery_failed: 664 power_supply_unregister(olpc_ac); 665 return ret; 666} 667 668static 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 677static const struct of_device_id olpc_battery_ids[] = { 678 { .compatible = "olpc,xo1-battery" }, 679 {} 680}; 681MODULE_DEVICE_TABLE(of, olpc_battery_ids); 682 683static 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 693module_platform_driver(olpc_battery_driver); 694 695MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 696MODULE_LICENSE("GPL"); 697MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine"); 698