1 /* 2 * battery.c - ACPI Battery Driver (Revision: 2.0) 3 * 4 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de> 5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com> 6 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 7 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License along 22 * with this program; if not, write to the Free Software Foundation, Inc., 23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 24 * 25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 26 */ 27 28 #include <linux/kernel.h> 29 #include <linux/module.h> 30 #include <linux/init.h> 31 #include <linux/types.h> 32 #include <linux/jiffies.h> 33 #include <linux/async.h> 34 #include <linux/dmi.h> 35 #include <linux/slab.h> 36 #include <linux/suspend.h> 37 #include <asm/unaligned.h> 38 39 #ifdef CONFIG_ACPI_PROCFS_POWER 40 #include <linux/proc_fs.h> 41 #include <linux/seq_file.h> 42 #include <asm/uaccess.h> 43 #endif 44 45 #include <linux/acpi.h> 46 #include <linux/power_supply.h> 47 48 #include "battery.h" 49 50 #define PREFIX "ACPI: " 51 52 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF 53 54 #define ACPI_BATTERY_DEVICE_NAME "Battery" 55 56 /* Battery power unit: 0 means mW, 1 means mA */ 57 #define ACPI_BATTERY_POWER_UNIT_MA 1 58 59 #define ACPI_BATTERY_STATE_DISCHARGING 0x1 60 #define ACPI_BATTERY_STATE_CHARGING 0x2 61 #define ACPI_BATTERY_STATE_CRITICAL 0x4 62 63 #define _COMPONENT ACPI_BATTERY_COMPONENT 64 65 ACPI_MODULE_NAME("battery"); 66 67 MODULE_AUTHOR("Paul Diefenbaugh"); 68 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); 69 MODULE_DESCRIPTION("ACPI Battery Driver"); 70 MODULE_LICENSE("GPL"); 71 72 static int battery_bix_broken_package; 73 static unsigned int cache_time = 1000; 74 module_param(cache_time, uint, 0644); 75 MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); 76 77 #ifdef CONFIG_ACPI_PROCFS_POWER 78 extern struct proc_dir_entry *acpi_lock_battery_dir(void); 79 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); 80 81 enum acpi_battery_files { 82 info_tag = 0, 83 state_tag, 84 alarm_tag, 85 ACPI_BATTERY_NUMFILES, 86 }; 87 88 #endif 89 90 static const struct acpi_device_id battery_device_ids[] = { 91 {"PNP0C0A", 0}, 92 {"", 0}, 93 }; 94 95 MODULE_DEVICE_TABLE(acpi, battery_device_ids); 96 97 enum { 98 ACPI_BATTERY_ALARM_PRESENT, 99 ACPI_BATTERY_XINFO_PRESENT, 100 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, 101 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit 102 switches between mWh and mAh depending on whether the system 103 is running on battery or not. When mAh is the unit, most 104 reported values are incorrect and need to be adjusted by 105 10000/design_voltage. Verified on x201, t410, t410s, and x220. 106 Pre-2010 and 2012 models appear to always report in mWh and 107 are thus unaffected (tested with t42, t61, t500, x200, x300, 108 and x230). Also, in mid-2012 Lenovo issued a BIOS update for 109 the 2011 models that fixes the issue (tested on x220 with a 110 post-1.29 BIOS), but as of Nov. 2012, no such update is 111 available for the 2010 models. */ 112 ACPI_BATTERY_QUIRK_THINKPAD_MAH, 113 }; 114 115 struct acpi_battery { 116 struct mutex lock; 117 struct mutex sysfs_lock; 118 struct power_supply bat; 119 struct acpi_device *device; 120 struct notifier_block pm_nb; 121 unsigned long update_time; 122 int revision; 123 int rate_now; 124 int capacity_now; 125 int voltage_now; 126 int design_capacity; 127 int full_charge_capacity; 128 int technology; 129 int design_voltage; 130 int design_capacity_warning; 131 int design_capacity_low; 132 int cycle_count; 133 int measurement_accuracy; 134 int max_sampling_time; 135 int min_sampling_time; 136 int max_averaging_interval; 137 int min_averaging_interval; 138 int capacity_granularity_1; 139 int capacity_granularity_2; 140 int alarm; 141 char model_number[32]; 142 char serial_number[32]; 143 char type[32]; 144 char oem_info[32]; 145 int state; 146 int power_unit; 147 unsigned long flags; 148 }; 149 150 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat) 151 152 static inline int acpi_battery_present(struct acpi_battery *battery) 153 { 154 return battery->device->status.battery_present; 155 } 156 157 static int acpi_battery_technology(struct acpi_battery *battery) 158 { 159 if (!strcasecmp("NiCd", battery->type)) 160 return POWER_SUPPLY_TECHNOLOGY_NiCd; 161 if (!strcasecmp("NiMH", battery->type)) 162 return POWER_SUPPLY_TECHNOLOGY_NiMH; 163 if (!strcasecmp("LION", battery->type)) 164 return POWER_SUPPLY_TECHNOLOGY_LION; 165 if (!strncasecmp("LI-ION", battery->type, 6)) 166 return POWER_SUPPLY_TECHNOLOGY_LION; 167 if (!strcasecmp("LiP", battery->type)) 168 return POWER_SUPPLY_TECHNOLOGY_LIPO; 169 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 170 } 171 172 static int acpi_battery_get_state(struct acpi_battery *battery); 173 174 static int acpi_battery_is_charged(struct acpi_battery *battery) 175 { 176 /* charging, discharging or critical low */ 177 if (battery->state != 0) 178 return 0; 179 180 /* battery not reporting charge */ 181 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN || 182 battery->capacity_now == 0) 183 return 0; 184 185 /* good batteries update full_charge as the batteries degrade */ 186 if (battery->full_charge_capacity == battery->capacity_now) 187 return 1; 188 189 /* fallback to using design values for broken batteries */ 190 if (battery->design_capacity == battery->capacity_now) 191 return 1; 192 193 /* we don't do any sort of metric based on percentages */ 194 return 0; 195 } 196 197 static int acpi_battery_get_property(struct power_supply *psy, 198 enum power_supply_property psp, 199 union power_supply_propval *val) 200 { 201 int ret = 0; 202 struct acpi_battery *battery = to_acpi_battery(psy); 203 204 if (acpi_battery_present(battery)) { 205 /* run battery update only if it is present */ 206 acpi_battery_get_state(battery); 207 } else if (psp != POWER_SUPPLY_PROP_PRESENT) 208 return -ENODEV; 209 switch (psp) { 210 case POWER_SUPPLY_PROP_STATUS: 211 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING) 212 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 213 else if (battery->state & ACPI_BATTERY_STATE_CHARGING) 214 val->intval = POWER_SUPPLY_STATUS_CHARGING; 215 else if (acpi_battery_is_charged(battery)) 216 val->intval = POWER_SUPPLY_STATUS_FULL; 217 else 218 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 219 break; 220 case POWER_SUPPLY_PROP_PRESENT: 221 val->intval = acpi_battery_present(battery); 222 break; 223 case POWER_SUPPLY_PROP_TECHNOLOGY: 224 val->intval = acpi_battery_technology(battery); 225 break; 226 case POWER_SUPPLY_PROP_CYCLE_COUNT: 227 val->intval = battery->cycle_count; 228 break; 229 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 230 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 231 ret = -ENODEV; 232 else 233 val->intval = battery->design_voltage * 1000; 234 break; 235 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 236 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 237 ret = -ENODEV; 238 else 239 val->intval = battery->voltage_now * 1000; 240 break; 241 case POWER_SUPPLY_PROP_CURRENT_NOW: 242 case POWER_SUPPLY_PROP_POWER_NOW: 243 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 244 ret = -ENODEV; 245 else 246 val->intval = battery->rate_now * 1000; 247 break; 248 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 249 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 250 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 251 ret = -ENODEV; 252 else 253 val->intval = battery->design_capacity * 1000; 254 break; 255 case POWER_SUPPLY_PROP_CHARGE_FULL: 256 case POWER_SUPPLY_PROP_ENERGY_FULL: 257 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 258 ret = -ENODEV; 259 else 260 val->intval = battery->full_charge_capacity * 1000; 261 break; 262 case POWER_SUPPLY_PROP_CHARGE_NOW: 263 case POWER_SUPPLY_PROP_ENERGY_NOW: 264 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 265 ret = -ENODEV; 266 else 267 val->intval = battery->capacity_now * 1000; 268 break; 269 case POWER_SUPPLY_PROP_CAPACITY: 270 if (battery->capacity_now && battery->full_charge_capacity) 271 val->intval = battery->capacity_now * 100/ 272 battery->full_charge_capacity; 273 else 274 val->intval = 0; 275 break; 276 case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 277 if (battery->state & ACPI_BATTERY_STATE_CRITICAL) 278 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 279 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) && 280 (battery->capacity_now <= battery->alarm)) 281 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 282 else if (acpi_battery_is_charged(battery)) 283 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 284 else 285 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 286 break; 287 case POWER_SUPPLY_PROP_MODEL_NAME: 288 val->strval = battery->model_number; 289 break; 290 case POWER_SUPPLY_PROP_MANUFACTURER: 291 val->strval = battery->oem_info; 292 break; 293 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 294 val->strval = battery->serial_number; 295 break; 296 default: 297 ret = -EINVAL; 298 } 299 return ret; 300 } 301 302 static enum power_supply_property charge_battery_props[] = { 303 POWER_SUPPLY_PROP_STATUS, 304 POWER_SUPPLY_PROP_PRESENT, 305 POWER_SUPPLY_PROP_TECHNOLOGY, 306 POWER_SUPPLY_PROP_CYCLE_COUNT, 307 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 308 POWER_SUPPLY_PROP_VOLTAGE_NOW, 309 POWER_SUPPLY_PROP_CURRENT_NOW, 310 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 311 POWER_SUPPLY_PROP_CHARGE_FULL, 312 POWER_SUPPLY_PROP_CHARGE_NOW, 313 POWER_SUPPLY_PROP_CAPACITY, 314 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 315 POWER_SUPPLY_PROP_MODEL_NAME, 316 POWER_SUPPLY_PROP_MANUFACTURER, 317 POWER_SUPPLY_PROP_SERIAL_NUMBER, 318 }; 319 320 static enum power_supply_property energy_battery_props[] = { 321 POWER_SUPPLY_PROP_STATUS, 322 POWER_SUPPLY_PROP_PRESENT, 323 POWER_SUPPLY_PROP_TECHNOLOGY, 324 POWER_SUPPLY_PROP_CYCLE_COUNT, 325 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 326 POWER_SUPPLY_PROP_VOLTAGE_NOW, 327 POWER_SUPPLY_PROP_POWER_NOW, 328 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 329 POWER_SUPPLY_PROP_ENERGY_FULL, 330 POWER_SUPPLY_PROP_ENERGY_NOW, 331 POWER_SUPPLY_PROP_CAPACITY, 332 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 333 POWER_SUPPLY_PROP_MODEL_NAME, 334 POWER_SUPPLY_PROP_MANUFACTURER, 335 POWER_SUPPLY_PROP_SERIAL_NUMBER, 336 }; 337 338 #ifdef CONFIG_ACPI_PROCFS_POWER 339 inline char *acpi_battery_units(struct acpi_battery *battery) 340 { 341 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ? 342 "mA" : "mW"; 343 } 344 #endif 345 346 /* -------------------------------------------------------------------------- 347 Battery Management 348 -------------------------------------------------------------------------- */ 349 struct acpi_offsets { 350 size_t offset; /* offset inside struct acpi_sbs_battery */ 351 u8 mode; /* int or string? */ 352 }; 353 354 static struct acpi_offsets state_offsets[] = { 355 {offsetof(struct acpi_battery, state), 0}, 356 {offsetof(struct acpi_battery, rate_now), 0}, 357 {offsetof(struct acpi_battery, capacity_now), 0}, 358 {offsetof(struct acpi_battery, voltage_now), 0}, 359 }; 360 361 static struct acpi_offsets info_offsets[] = { 362 {offsetof(struct acpi_battery, power_unit), 0}, 363 {offsetof(struct acpi_battery, design_capacity), 0}, 364 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 365 {offsetof(struct acpi_battery, technology), 0}, 366 {offsetof(struct acpi_battery, design_voltage), 0}, 367 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 368 {offsetof(struct acpi_battery, design_capacity_low), 0}, 369 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 370 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 371 {offsetof(struct acpi_battery, model_number), 1}, 372 {offsetof(struct acpi_battery, serial_number), 1}, 373 {offsetof(struct acpi_battery, type), 1}, 374 {offsetof(struct acpi_battery, oem_info), 1}, 375 }; 376 377 static struct acpi_offsets extended_info_offsets[] = { 378 {offsetof(struct acpi_battery, revision), 0}, 379 {offsetof(struct acpi_battery, power_unit), 0}, 380 {offsetof(struct acpi_battery, design_capacity), 0}, 381 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 382 {offsetof(struct acpi_battery, technology), 0}, 383 {offsetof(struct acpi_battery, design_voltage), 0}, 384 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 385 {offsetof(struct acpi_battery, design_capacity_low), 0}, 386 {offsetof(struct acpi_battery, cycle_count), 0}, 387 {offsetof(struct acpi_battery, measurement_accuracy), 0}, 388 {offsetof(struct acpi_battery, max_sampling_time), 0}, 389 {offsetof(struct acpi_battery, min_sampling_time), 0}, 390 {offsetof(struct acpi_battery, max_averaging_interval), 0}, 391 {offsetof(struct acpi_battery, min_averaging_interval), 0}, 392 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 393 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 394 {offsetof(struct acpi_battery, model_number), 1}, 395 {offsetof(struct acpi_battery, serial_number), 1}, 396 {offsetof(struct acpi_battery, type), 1}, 397 {offsetof(struct acpi_battery, oem_info), 1}, 398 }; 399 400 static int extract_package(struct acpi_battery *battery, 401 union acpi_object *package, 402 struct acpi_offsets *offsets, int num) 403 { 404 int i; 405 union acpi_object *element; 406 if (package->type != ACPI_TYPE_PACKAGE) 407 return -EFAULT; 408 for (i = 0; i < num; ++i) { 409 if (package->package.count <= i) 410 return -EFAULT; 411 element = &package->package.elements[i]; 412 if (offsets[i].mode) { 413 u8 *ptr = (u8 *)battery + offsets[i].offset; 414 if (element->type == ACPI_TYPE_STRING || 415 element->type == ACPI_TYPE_BUFFER) 416 strncpy(ptr, element->string.pointer, 32); 417 else if (element->type == ACPI_TYPE_INTEGER) { 418 strncpy(ptr, (u8 *)&element->integer.value, 419 sizeof(u64)); 420 ptr[sizeof(u64)] = 0; 421 } else 422 *ptr = 0; /* don't have value */ 423 } else { 424 int *x = (int *)((u8 *)battery + offsets[i].offset); 425 *x = (element->type == ACPI_TYPE_INTEGER) ? 426 element->integer.value : -1; 427 } 428 } 429 return 0; 430 } 431 432 static int acpi_battery_get_status(struct acpi_battery *battery) 433 { 434 if (acpi_bus_get_status(battery->device)) { 435 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); 436 return -ENODEV; 437 } 438 return 0; 439 } 440 441 static int acpi_battery_get_info(struct acpi_battery *battery) 442 { 443 int result = -EFAULT; 444 acpi_status status = 0; 445 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ? 446 "_BIX" : "_BIF"; 447 448 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 449 450 if (!acpi_battery_present(battery)) 451 return 0; 452 mutex_lock(&battery->lock); 453 status = acpi_evaluate_object(battery->device->handle, name, 454 NULL, &buffer); 455 mutex_unlock(&battery->lock); 456 457 if (ACPI_FAILURE(status)) { 458 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); 459 return -ENODEV; 460 } 461 462 if (battery_bix_broken_package) 463 result = extract_package(battery, buffer.pointer, 464 extended_info_offsets + 1, 465 ARRAY_SIZE(extended_info_offsets) - 1); 466 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) 467 result = extract_package(battery, buffer.pointer, 468 extended_info_offsets, 469 ARRAY_SIZE(extended_info_offsets)); 470 else 471 result = extract_package(battery, buffer.pointer, 472 info_offsets, ARRAY_SIZE(info_offsets)); 473 kfree(buffer.pointer); 474 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 475 battery->full_charge_capacity = battery->design_capacity; 476 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 477 battery->power_unit && battery->design_voltage) { 478 battery->design_capacity = battery->design_capacity * 479 10000 / battery->design_voltage; 480 battery->full_charge_capacity = battery->full_charge_capacity * 481 10000 / battery->design_voltage; 482 battery->design_capacity_warning = 483 battery->design_capacity_warning * 484 10000 / battery->design_voltage; 485 /* Curiously, design_capacity_low, unlike the rest of them, 486 is correct. */ 487 /* capacity_granularity_* equal 1 on the systems tested, so 488 it's impossible to tell if they would need an adjustment 489 or not if their values were higher. */ 490 } 491 return result; 492 } 493 494 static int acpi_battery_get_state(struct acpi_battery *battery) 495 { 496 int result = 0; 497 acpi_status status = 0; 498 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 499 500 if (!acpi_battery_present(battery)) 501 return 0; 502 503 if (battery->update_time && 504 time_before(jiffies, battery->update_time + 505 msecs_to_jiffies(cache_time))) 506 return 0; 507 508 mutex_lock(&battery->lock); 509 status = acpi_evaluate_object(battery->device->handle, "_BST", 510 NULL, &buffer); 511 mutex_unlock(&battery->lock); 512 513 if (ACPI_FAILURE(status)) { 514 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); 515 return -ENODEV; 516 } 517 518 result = extract_package(battery, buffer.pointer, 519 state_offsets, ARRAY_SIZE(state_offsets)); 520 battery->update_time = jiffies; 521 kfree(buffer.pointer); 522 523 /* For buggy DSDTs that report negative 16-bit values for either 524 * charging or discharging current and/or report 0 as 65536 525 * due to bad math. 526 */ 527 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA && 528 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN && 529 (s16)(battery->rate_now) < 0) { 530 battery->rate_now = abs((s16)battery->rate_now); 531 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate" 532 " invalid.\n"); 533 } 534 535 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) 536 && battery->capacity_now >= 0 && battery->capacity_now <= 100) 537 battery->capacity_now = (battery->capacity_now * 538 battery->full_charge_capacity) / 100; 539 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 540 battery->power_unit && battery->design_voltage) { 541 battery->capacity_now = battery->capacity_now * 542 10000 / battery->design_voltage; 543 } 544 return result; 545 } 546 547 static int acpi_battery_set_alarm(struct acpi_battery *battery) 548 { 549 acpi_status status = 0; 550 551 if (!acpi_battery_present(battery) || 552 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 553 return -ENODEV; 554 555 mutex_lock(&battery->lock); 556 status = acpi_execute_simple_method(battery->device->handle, "_BTP", 557 battery->alarm); 558 mutex_unlock(&battery->lock); 559 560 if (ACPI_FAILURE(status)) 561 return -ENODEV; 562 563 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 564 return 0; 565 } 566 567 static int acpi_battery_init_alarm(struct acpi_battery *battery) 568 { 569 /* See if alarms are supported, and if so, set default */ 570 if (!acpi_has_method(battery->device->handle, "_BTP")) { 571 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 572 return 0; 573 } 574 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 575 if (!battery->alarm) 576 battery->alarm = battery->design_capacity_warning; 577 return acpi_battery_set_alarm(battery); 578 } 579 580 static ssize_t acpi_battery_alarm_show(struct device *dev, 581 struct device_attribute *attr, 582 char *buf) 583 { 584 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 585 return sprintf(buf, "%d\n", battery->alarm * 1000); 586 } 587 588 static ssize_t acpi_battery_alarm_store(struct device *dev, 589 struct device_attribute *attr, 590 const char *buf, size_t count) 591 { 592 unsigned long x; 593 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 594 if (sscanf(buf, "%lu\n", &x) == 1) 595 battery->alarm = x/1000; 596 if (acpi_battery_present(battery)) 597 acpi_battery_set_alarm(battery); 598 return count; 599 } 600 601 static struct device_attribute alarm_attr = { 602 .attr = {.name = "alarm", .mode = 0644}, 603 .show = acpi_battery_alarm_show, 604 .store = acpi_battery_alarm_store, 605 }; 606 607 static int sysfs_add_battery(struct acpi_battery *battery) 608 { 609 int result; 610 611 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { 612 battery->bat.properties = charge_battery_props; 613 battery->bat.num_properties = 614 ARRAY_SIZE(charge_battery_props); 615 } else { 616 battery->bat.properties = energy_battery_props; 617 battery->bat.num_properties = 618 ARRAY_SIZE(energy_battery_props); 619 } 620 621 battery->bat.name = acpi_device_bid(battery->device); 622 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; 623 battery->bat.get_property = acpi_battery_get_property; 624 625 result = power_supply_register_no_ws(&battery->device->dev, &battery->bat); 626 627 if (result) 628 return result; 629 return device_create_file(battery->bat.dev, &alarm_attr); 630 } 631 632 static void sysfs_remove_battery(struct acpi_battery *battery) 633 { 634 mutex_lock(&battery->sysfs_lock); 635 if (!battery->bat.dev) { 636 mutex_unlock(&battery->sysfs_lock); 637 return; 638 } 639 640 device_remove_file(battery->bat.dev, &alarm_attr); 641 power_supply_unregister(&battery->bat); 642 battery->bat.dev = NULL; 643 mutex_unlock(&battery->sysfs_lock); 644 } 645 646 static void find_battery(const struct dmi_header *dm, void *private) 647 { 648 struct acpi_battery *battery = (struct acpi_battery *)private; 649 /* Note: the hardcoded offsets below have been extracted from 650 the source code of dmidecode. */ 651 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { 652 const u8 *dmi_data = (const u8 *)(dm + 1); 653 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); 654 if (dm->length >= 18) 655 dmi_capacity *= dmi_data[17]; 656 if (battery->design_capacity * battery->design_voltage / 1000 657 != dmi_capacity && 658 battery->design_capacity * 10 == dmi_capacity) 659 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 660 &battery->flags); 661 } 662 } 663 664 /* 665 * According to the ACPI spec, some kinds of primary batteries can 666 * report percentage battery remaining capacity directly to OS. 667 * In this case, it reports the Last Full Charged Capacity == 100 668 * and BatteryPresentRate == 0xFFFFFFFF. 669 * 670 * Now we found some battery reports percentage remaining capacity 671 * even if it's rechargeable. 672 * https://bugzilla.kernel.org/show_bug.cgi?id=15979 673 * 674 * Handle this correctly so that they won't break userspace. 675 */ 676 static void acpi_battery_quirks(struct acpi_battery *battery) 677 { 678 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 679 return; 680 681 if (battery->full_charge_capacity == 100 && 682 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && 683 battery->capacity_now >= 0 && battery->capacity_now <= 100) { 684 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); 685 battery->full_charge_capacity = battery->design_capacity; 686 battery->capacity_now = (battery->capacity_now * 687 battery->full_charge_capacity) / 100; 688 } 689 690 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) 691 return; 692 693 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { 694 const char *s; 695 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 696 if (s && !strnicmp(s, "ThinkPad", 8)) { 697 dmi_walk(find_battery, battery); 698 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 699 &battery->flags) && 700 battery->design_voltage) { 701 battery->design_capacity = 702 battery->design_capacity * 703 10000 / battery->design_voltage; 704 battery->full_charge_capacity = 705 battery->full_charge_capacity * 706 10000 / battery->design_voltage; 707 battery->design_capacity_warning = 708 battery->design_capacity_warning * 709 10000 / battery->design_voltage; 710 battery->capacity_now = battery->capacity_now * 711 10000 / battery->design_voltage; 712 } 713 } 714 } 715 } 716 717 static int acpi_battery_update(struct acpi_battery *battery, bool resume) 718 { 719 int result, old_present = acpi_battery_present(battery); 720 result = acpi_battery_get_status(battery); 721 if (result) 722 return result; 723 if (!acpi_battery_present(battery)) { 724 sysfs_remove_battery(battery); 725 battery->update_time = 0; 726 return 0; 727 } 728 729 if (resume) 730 return 0; 731 732 if (!battery->update_time || 733 old_present != acpi_battery_present(battery)) { 734 result = acpi_battery_get_info(battery); 735 if (result) 736 return result; 737 acpi_battery_init_alarm(battery); 738 } 739 if (!battery->bat.dev) { 740 result = sysfs_add_battery(battery); 741 if (result) 742 return result; 743 } 744 result = acpi_battery_get_state(battery); 745 if (result) 746 return result; 747 acpi_battery_quirks(battery); 748 749 /* 750 * Wakeup the system if battery is critical low 751 * or lower than the alarm level 752 */ 753 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) || 754 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) && 755 (battery->capacity_now <= battery->alarm))) 756 pm_wakeup_event(&battery->device->dev, 0); 757 758 return result; 759 } 760 761 static void acpi_battery_refresh(struct acpi_battery *battery) 762 { 763 int power_unit; 764 765 if (!battery->bat.dev) 766 return; 767 768 power_unit = battery->power_unit; 769 770 acpi_battery_get_info(battery); 771 772 if (power_unit == battery->power_unit) 773 return; 774 775 /* The battery has changed its reporting units. */ 776 sysfs_remove_battery(battery); 777 sysfs_add_battery(battery); 778 } 779 780 /* -------------------------------------------------------------------------- 781 FS Interface (/proc) 782 -------------------------------------------------------------------------- */ 783 784 #ifdef CONFIG_ACPI_PROCFS_POWER 785 static struct proc_dir_entry *acpi_battery_dir; 786 787 static int acpi_battery_print_info(struct seq_file *seq, int result) 788 { 789 struct acpi_battery *battery = seq->private; 790 791 if (result) 792 goto end; 793 794 seq_printf(seq, "present: %s\n", 795 acpi_battery_present(battery) ? "yes" : "no"); 796 if (!acpi_battery_present(battery)) 797 goto end; 798 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 799 seq_printf(seq, "design capacity: unknown\n"); 800 else 801 seq_printf(seq, "design capacity: %d %sh\n", 802 battery->design_capacity, 803 acpi_battery_units(battery)); 804 805 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 806 seq_printf(seq, "last full capacity: unknown\n"); 807 else 808 seq_printf(seq, "last full capacity: %d %sh\n", 809 battery->full_charge_capacity, 810 acpi_battery_units(battery)); 811 812 seq_printf(seq, "battery technology: %srechargeable\n", 813 (!battery->technology)?"non-":""); 814 815 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 816 seq_printf(seq, "design voltage: unknown\n"); 817 else 818 seq_printf(seq, "design voltage: %d mV\n", 819 battery->design_voltage); 820 seq_printf(seq, "design capacity warning: %d %sh\n", 821 battery->design_capacity_warning, 822 acpi_battery_units(battery)); 823 seq_printf(seq, "design capacity low: %d %sh\n", 824 battery->design_capacity_low, 825 acpi_battery_units(battery)); 826 seq_printf(seq, "cycle count: %i\n", battery->cycle_count); 827 seq_printf(seq, "capacity granularity 1: %d %sh\n", 828 battery->capacity_granularity_1, 829 acpi_battery_units(battery)); 830 seq_printf(seq, "capacity granularity 2: %d %sh\n", 831 battery->capacity_granularity_2, 832 acpi_battery_units(battery)); 833 seq_printf(seq, "model number: %s\n", battery->model_number); 834 seq_printf(seq, "serial number: %s\n", battery->serial_number); 835 seq_printf(seq, "battery type: %s\n", battery->type); 836 seq_printf(seq, "OEM info: %s\n", battery->oem_info); 837 end: 838 if (result) 839 seq_printf(seq, "ERROR: Unable to read battery info\n"); 840 return result; 841 } 842 843 static int acpi_battery_print_state(struct seq_file *seq, int result) 844 { 845 struct acpi_battery *battery = seq->private; 846 847 if (result) 848 goto end; 849 850 seq_printf(seq, "present: %s\n", 851 acpi_battery_present(battery) ? "yes" : "no"); 852 if (!acpi_battery_present(battery)) 853 goto end; 854 855 seq_printf(seq, "capacity state: %s\n", 856 (battery->state & 0x04) ? "critical" : "ok"); 857 if ((battery->state & 0x01) && (battery->state & 0x02)) 858 seq_printf(seq, 859 "charging state: charging/discharging\n"); 860 else if (battery->state & 0x01) 861 seq_printf(seq, "charging state: discharging\n"); 862 else if (battery->state & 0x02) 863 seq_printf(seq, "charging state: charging\n"); 864 else 865 seq_printf(seq, "charging state: charged\n"); 866 867 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 868 seq_printf(seq, "present rate: unknown\n"); 869 else 870 seq_printf(seq, "present rate: %d %s\n", 871 battery->rate_now, acpi_battery_units(battery)); 872 873 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 874 seq_printf(seq, "remaining capacity: unknown\n"); 875 else 876 seq_printf(seq, "remaining capacity: %d %sh\n", 877 battery->capacity_now, acpi_battery_units(battery)); 878 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 879 seq_printf(seq, "present voltage: unknown\n"); 880 else 881 seq_printf(seq, "present voltage: %d mV\n", 882 battery->voltage_now); 883 end: 884 if (result) 885 seq_printf(seq, "ERROR: Unable to read battery state\n"); 886 887 return result; 888 } 889 890 static int acpi_battery_print_alarm(struct seq_file *seq, int result) 891 { 892 struct acpi_battery *battery = seq->private; 893 894 if (result) 895 goto end; 896 897 if (!acpi_battery_present(battery)) { 898 seq_printf(seq, "present: no\n"); 899 goto end; 900 } 901 seq_printf(seq, "alarm: "); 902 if (!battery->alarm) 903 seq_printf(seq, "unsupported\n"); 904 else 905 seq_printf(seq, "%u %sh\n", battery->alarm, 906 acpi_battery_units(battery)); 907 end: 908 if (result) 909 seq_printf(seq, "ERROR: Unable to read battery alarm\n"); 910 return result; 911 } 912 913 static ssize_t acpi_battery_write_alarm(struct file *file, 914 const char __user * buffer, 915 size_t count, loff_t * ppos) 916 { 917 int result = 0; 918 char alarm_string[12] = { '\0' }; 919 struct seq_file *m = file->private_data; 920 struct acpi_battery *battery = m->private; 921 922 if (!battery || (count > sizeof(alarm_string) - 1)) 923 return -EINVAL; 924 if (!acpi_battery_present(battery)) { 925 result = -ENODEV; 926 goto end; 927 } 928 if (copy_from_user(alarm_string, buffer, count)) { 929 result = -EFAULT; 930 goto end; 931 } 932 alarm_string[count] = '\0'; 933 battery->alarm = simple_strtol(alarm_string, NULL, 0); 934 result = acpi_battery_set_alarm(battery); 935 end: 936 if (!result) 937 return count; 938 return result; 939 } 940 941 typedef int(*print_func)(struct seq_file *seq, int result); 942 943 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = { 944 acpi_battery_print_info, 945 acpi_battery_print_state, 946 acpi_battery_print_alarm, 947 }; 948 949 static int acpi_battery_read(int fid, struct seq_file *seq) 950 { 951 struct acpi_battery *battery = seq->private; 952 int result = acpi_battery_update(battery, false); 953 return acpi_print_funcs[fid](seq, result); 954 } 955 956 #define DECLARE_FILE_FUNCTIONS(_name) \ 957 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \ 958 { \ 959 return acpi_battery_read(_name##_tag, seq); \ 960 } \ 961 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \ 962 { \ 963 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \ 964 } 965 966 DECLARE_FILE_FUNCTIONS(info); 967 DECLARE_FILE_FUNCTIONS(state); 968 DECLARE_FILE_FUNCTIONS(alarm); 969 970 #undef DECLARE_FILE_FUNCTIONS 971 972 #define FILE_DESCRIPTION_RO(_name) \ 973 { \ 974 .name = __stringify(_name), \ 975 .mode = S_IRUGO, \ 976 .ops = { \ 977 .open = acpi_battery_##_name##_open_fs, \ 978 .read = seq_read, \ 979 .llseek = seq_lseek, \ 980 .release = single_release, \ 981 .owner = THIS_MODULE, \ 982 }, \ 983 } 984 985 #define FILE_DESCRIPTION_RW(_name) \ 986 { \ 987 .name = __stringify(_name), \ 988 .mode = S_IFREG | S_IRUGO | S_IWUSR, \ 989 .ops = { \ 990 .open = acpi_battery_##_name##_open_fs, \ 991 .read = seq_read, \ 992 .llseek = seq_lseek, \ 993 .write = acpi_battery_write_##_name, \ 994 .release = single_release, \ 995 .owner = THIS_MODULE, \ 996 }, \ 997 } 998 999 static const struct battery_file { 1000 struct file_operations ops; 1001 umode_t mode; 1002 const char *name; 1003 } acpi_battery_file[] = { 1004 FILE_DESCRIPTION_RO(info), 1005 FILE_DESCRIPTION_RO(state), 1006 FILE_DESCRIPTION_RW(alarm), 1007 }; 1008 1009 #undef FILE_DESCRIPTION_RO 1010 #undef FILE_DESCRIPTION_RW 1011 1012 static int acpi_battery_add_fs(struct acpi_device *device) 1013 { 1014 struct proc_dir_entry *entry = NULL; 1015 int i; 1016 1017 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded," 1018 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n"); 1019 if (!acpi_device_dir(device)) { 1020 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 1021 acpi_battery_dir); 1022 if (!acpi_device_dir(device)) 1023 return -ENODEV; 1024 } 1025 1026 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) { 1027 entry = proc_create_data(acpi_battery_file[i].name, 1028 acpi_battery_file[i].mode, 1029 acpi_device_dir(device), 1030 &acpi_battery_file[i].ops, 1031 acpi_driver_data(device)); 1032 if (!entry) 1033 return -ENODEV; 1034 } 1035 return 0; 1036 } 1037 1038 static void acpi_battery_remove_fs(struct acpi_device *device) 1039 { 1040 int i; 1041 if (!acpi_device_dir(device)) 1042 return; 1043 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) 1044 remove_proc_entry(acpi_battery_file[i].name, 1045 acpi_device_dir(device)); 1046 1047 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir); 1048 acpi_device_dir(device) = NULL; 1049 } 1050 1051 #endif 1052 1053 /* -------------------------------------------------------------------------- 1054 Driver Interface 1055 -------------------------------------------------------------------------- */ 1056 1057 static void acpi_battery_notify(struct acpi_device *device, u32 event) 1058 { 1059 struct acpi_battery *battery = acpi_driver_data(device); 1060 struct device *old; 1061 1062 if (!battery) 1063 return; 1064 old = battery->bat.dev; 1065 if (event == ACPI_BATTERY_NOTIFY_INFO) 1066 acpi_battery_refresh(battery); 1067 acpi_battery_update(battery, false); 1068 acpi_bus_generate_netlink_event(device->pnp.device_class, 1069 dev_name(&device->dev), event, 1070 acpi_battery_present(battery)); 1071 acpi_notifier_call_chain(device, event, acpi_battery_present(battery)); 1072 /* acpi_battery_update could remove power_supply object */ 1073 if (old && battery->bat.dev) 1074 power_supply_changed(&battery->bat); 1075 } 1076 1077 static int battery_notify(struct notifier_block *nb, 1078 unsigned long mode, void *_unused) 1079 { 1080 struct acpi_battery *battery = container_of(nb, struct acpi_battery, 1081 pm_nb); 1082 int result; 1083 1084 switch (mode) { 1085 case PM_POST_HIBERNATION: 1086 case PM_POST_SUSPEND: 1087 if (!acpi_battery_present(battery)) 1088 return 0; 1089 1090 if (!battery->bat.dev) { 1091 result = acpi_battery_get_info(battery); 1092 if (result) 1093 return result; 1094 1095 result = sysfs_add_battery(battery); 1096 if (result) 1097 return result; 1098 } else 1099 acpi_battery_refresh(battery); 1100 1101 acpi_battery_init_alarm(battery); 1102 acpi_battery_get_state(battery); 1103 break; 1104 } 1105 1106 return 0; 1107 } 1108 1109 static struct dmi_system_id bat_dmi_table[] = { 1110 { 1111 .ident = "NEC LZ750/LS", 1112 .matches = { 1113 DMI_MATCH(DMI_SYS_VENDOR, "NEC"), 1114 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"), 1115 }, 1116 }, 1117 {}, 1118 }; 1119 1120 static int acpi_battery_add(struct acpi_device *device) 1121 { 1122 int result = 0; 1123 struct acpi_battery *battery = NULL; 1124 1125 if (!device) 1126 return -EINVAL; 1127 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 1128 if (!battery) 1129 return -ENOMEM; 1130 battery->device = device; 1131 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 1132 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 1133 device->driver_data = battery; 1134 mutex_init(&battery->lock); 1135 mutex_init(&battery->sysfs_lock); 1136 if (acpi_has_method(battery->device->handle, "_BIX")) 1137 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 1138 result = acpi_battery_update(battery, false); 1139 if (result) 1140 goto fail; 1141 #ifdef CONFIG_ACPI_PROCFS_POWER 1142 result = acpi_battery_add_fs(device); 1143 #endif 1144 if (result) { 1145 #ifdef CONFIG_ACPI_PROCFS_POWER 1146 acpi_battery_remove_fs(device); 1147 #endif 1148 goto fail; 1149 } 1150 1151 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 1152 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 1153 device->status.battery_present ? "present" : "absent"); 1154 1155 battery->pm_nb.notifier_call = battery_notify; 1156 register_pm_notifier(&battery->pm_nb); 1157 1158 device_init_wakeup(&device->dev, 1); 1159 1160 return result; 1161 1162 fail: 1163 sysfs_remove_battery(battery); 1164 mutex_destroy(&battery->lock); 1165 mutex_destroy(&battery->sysfs_lock); 1166 kfree(battery); 1167 return result; 1168 } 1169 1170 static int acpi_battery_remove(struct acpi_device *device) 1171 { 1172 struct acpi_battery *battery = NULL; 1173 1174 if (!device || !acpi_driver_data(device)) 1175 return -EINVAL; 1176 device_init_wakeup(&device->dev, 0); 1177 battery = acpi_driver_data(device); 1178 unregister_pm_notifier(&battery->pm_nb); 1179 #ifdef CONFIG_ACPI_PROCFS_POWER 1180 acpi_battery_remove_fs(device); 1181 #endif 1182 sysfs_remove_battery(battery); 1183 mutex_destroy(&battery->lock); 1184 mutex_destroy(&battery->sysfs_lock); 1185 kfree(battery); 1186 return 0; 1187 } 1188 1189 #ifdef CONFIG_PM_SLEEP 1190 /* this is needed to learn about changes made in suspended state */ 1191 static int acpi_battery_resume(struct device *dev) 1192 { 1193 struct acpi_battery *battery; 1194 1195 if (!dev) 1196 return -EINVAL; 1197 1198 battery = acpi_driver_data(to_acpi_device(dev)); 1199 if (!battery) 1200 return -EINVAL; 1201 1202 battery->update_time = 0; 1203 acpi_battery_update(battery, true); 1204 return 0; 1205 } 1206 #else 1207 #define acpi_battery_resume NULL 1208 #endif 1209 1210 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); 1211 1212 static struct acpi_driver acpi_battery_driver = { 1213 .name = "battery", 1214 .class = ACPI_BATTERY_CLASS, 1215 .ids = battery_device_ids, 1216 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1217 .ops = { 1218 .add = acpi_battery_add, 1219 .remove = acpi_battery_remove, 1220 .notify = acpi_battery_notify, 1221 }, 1222 .drv.pm = &acpi_battery_pm, 1223 }; 1224 1225 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 1226 { 1227 if (acpi_disabled) 1228 return; 1229 1230 if (dmi_check_system(bat_dmi_table)) 1231 battery_bix_broken_package = 1; 1232 1233 #ifdef CONFIG_ACPI_PROCFS_POWER 1234 acpi_battery_dir = acpi_lock_battery_dir(); 1235 if (!acpi_battery_dir) 1236 return; 1237 #endif 1238 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) { 1239 #ifdef CONFIG_ACPI_PROCFS_POWER 1240 acpi_unlock_battery_dir(acpi_battery_dir); 1241 #endif 1242 return; 1243 } 1244 return; 1245 } 1246 1247 static int __init acpi_battery_init(void) 1248 { 1249 async_schedule(acpi_battery_init_async, NULL); 1250 return 0; 1251 } 1252 1253 static void __exit acpi_battery_exit(void) 1254 { 1255 acpi_bus_unregister_driver(&acpi_battery_driver); 1256 #ifdef CONFIG_ACPI_PROCFS_POWER 1257 acpi_unlock_battery_dir(acpi_battery_dir); 1258 #endif 1259 } 1260 1261 module_init(acpi_battery_init); 1262 module_exit(acpi_battery_exit); 1263